feat: wire filter_summary end-to-end (Direction A live)

Phase 4 plumbing existed but wasn't connected. Now:

- engine/telemetry.build_filter_summary(db): composes the dict shape
  consumed by build_generation_prompt — saturated_concepts (top 5)
  and high_filter_rate_categories (>=70% threshold, sorted desc)
- IdeaGenerator.generate accepts filter_summary kwarg and forwards it
  to build_generation_prompt
- cron/scheduler.generate_and_store calls build_filter_summary on every
  cycle and passes the result through, so Claude now sees on every
  generation: "Saturated concepts (avoid): certificate, detection,
  compliance, migration, chain. High filter-rate categories:
  nist-standards (80%), security-tool (73%), pqc-cryptography (71%)."

End-to-end TDD: 6 new tests, full suite still green.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: rayketcham

src/project_forge/cron/scheduler.py

@@ -91,6 +91,11 @@ async def generate_and_store(db: Database, generator: IdeaGenerator) -> Idea:
         "\n".join(f"- {r.repo_full_name}: {r.description}" for r in repos) if repos else None
     )
 
+    # Build saturation/filter-rate summary so Claude knows what to avoid (Phase 4 wiring)
+    from project_forge.engine.telemetry import build_filter_summary
+
+    filter_summary = await build_filter_summary(db)
+
     run = GenerationRun(category=category)
 
     try:
@@ -100,6 +105,7 @@ async def generate_and_store(db: Database, generator: IdeaGenerator) -> Idea:
             use_contrarian=use_contrarian,
             use_combinatoric=use_combinatoric,
             portfolio_context=portfolio_context,
+            filter_summary=filter_summary,
         )
         result = review_idea(idea)
         if not result.passed:

src/project_forge/engine/generator.py

@@ -31,6 +31,8 @@ async def generate(
         use_combinatoric: bool = False,
         prompt_override: str | None = None,
         portfolio_context: str | None = None,
+        *,
+        filter_summary: dict | None = None,
     ) -> Idea:
         if prompt_override is not None:
             prompt = prompt_override
@@ -41,6 +43,7 @@ async def generate(
                 use_contrarian=use_contrarian,
                 use_combinatoric=use_combinatoric,
                 portfolio_context=portfolio_context,
+                filter_summary=filter_summary,
             )
 
         logger.info("Generating idea for category: %s", category.value)

src/project_forge/engine/telemetry.py

@@ -147,6 +147,35 @@ async def diversity_lever_usage(
     return {"contrarian": 0.0, "combinatoric": 0.0, "static": 0.0}
 
 
+async def build_filter_summary(
+    db: Database,
+    *,
+    top_concepts: int = 5,
+    rate_threshold: float = 0.7,
+    days: int = 30,
+) -> dict:
+    """Compose the filter_summary dict consumed by build_generation_prompt.
+
+    Calls saturation_per_concept + filter_rate_by_category and shapes the
+    result for direct injection into the prompt.
+
+    Returns: {"saturated_concepts": list[str],
+              "high_filter_rate_categories": list[tuple[str, float]]}
+    """
+    sat = await saturation_per_concept(db, days=days, top_n=top_concepts)
+    rates = await filter_rate_by_category(db, days=min(days, 7))
+
+    high = sorted(
+        ((cat.value, r) for cat, r in rates.items() if r >= rate_threshold),
+        key=lambda x: -x[1],
+    )
+
+    return {
+        "saturated_concepts": [w for w, _ in sat],
+        "high_filter_rate_categories": list(high),
+    }
+
+
 async def coverage_gaps(
     db: Database, threshold: int = 5,
 ) -> list[IdeaCategory]:

tests/test_filter_summary_wiring.py

@@ -0,0 +1,181 @@
+"""TDD: Wire telemetry.build_filter_summary + IdeaGenerator integration.
+
+Phase 4 plumbing was landed; this wires it end-to-end so the cron runner
+actually injects the saturation summary into Claude's prompt.
+
+- engine/telemetry.build_filter_summary(db, ...) returns the dict shape
+  expected by build_generation_prompt(filter_summary=...).
+- IdeaGenerator.generate(... filter_summary=...) forwards it to the
+  prompt builder so cron only needs to build the summary once and pass it in.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+
+import pytest
+import pytest_asyncio
+
+from project_forge.models import FilteredIdea, Idea, IdeaCategory
+from project_forge.storage.db import Database
+
+
+def _idea(name: str, *, category: IdeaCategory = IdeaCategory.SECURITY_TOOL) -> Idea:
+    return Idea(
+        name=name,
+        tagline=f"tag for {name}",
+        description="d",
+        category=category,
+        market_analysis="m",
+        feasibility_score=0.8,
+        mvp_scope="mvp",
+        tech_stack=["python"],
+    )
+
+
+def _filtered(name: str, *, category: IdeaCategory = IdeaCategory.SECURITY_TOOL,
+              days_ago: int = 1) -> FilteredIdea:
+    fi = FilteredIdea(
+        idea_name=name,
+        idea_tagline="t",
+        idea_category=category,
+        filter_reason="duplicate:tagline_similarity:0.9",
+        original_idea_json="{}",
+    )
+    fi.filtered_at = datetime.now(UTC) - timedelta(days=days_ago)
+    return fi
+
+
+@pytest_asyncio.fixture
+async def db(tmp_path):
+    d = Database(tmp_path / "wire_filter.db")
+    await d.connect()
+    yield d
+    await d.close()
+
+
+# ── build_filter_summary: produces shape consumed by build_generation_prompt
+
+
+class TestBuildFilterSummary:
+    @pytest.mark.asyncio
+    async def test_returns_expected_keys(self, db):
+        from project_forge.engine.telemetry import build_filter_summary
+
+        summary = await build_filter_summary(db)
+        assert "saturated_concepts" in summary
+        assert "high_filter_rate_categories" in summary
+
+    @pytest.mark.asyncio
+    async def test_lists_top_saturated_concepts(self, db):
+        from project_forge.engine.telemetry import build_filter_summary
+
+        for name in (
+            "certificate alpha", "certificate beta", "certificate gamma",
+            "certificate delta", "certificate epsilon",
+        ):
+            await db.save_filtered_idea(_filtered(name))
+        for name in ("detection one", "detection two"):
+            await db.save_filtered_idea(_filtered(name))
+
+        summary = await build_filter_summary(db, top_concepts=2)
+        # Most-rejected concept first
+        assert summary["saturated_concepts"][0] == "certificate"
+        assert len(summary["saturated_concepts"]) <= 2
+
+    @pytest.mark.asyncio
+    async def test_lists_high_filter_rate_categories(self, db):
+        from project_forge.engine.telemetry import build_filter_summary
+
+        # security-tool: 1 accept, 4 reject → 0.80
+        await db.save_idea(_idea("Accept ST"))
+        for n in ("R1", "R2", "R3", "R4"):
+            await db.save_filtered_idea(_filtered(n))
+        # privacy: 1 accept, 0 reject → 0.00 (well below threshold)
+        await db.save_idea(_idea("Accept PR", category=IdeaCategory.PRIVACY))
+
+        summary = await build_filter_summary(db, rate_threshold=0.5)
+        cats = [c for c, _ in summary["high_filter_rate_categories"]]
+        assert "security-tool" in cats
+        assert "privacy" not in cats
+
+    @pytest.mark.asyncio
+    async def test_empty_db_returns_empty_lists(self, db):
+        from project_forge.engine.telemetry import build_filter_summary
+
+        summary = await build_filter_summary(db)
+        assert summary["saturated_concepts"] == []
+        assert summary["high_filter_rate_categories"] == []
+
+    @pytest.mark.asyncio
+    async def test_categories_sorted_by_rate_descending(self, db):
+        from project_forge.engine.telemetry import build_filter_summary
+
+        # security-tool: 4 of 5 = 0.80
+        await db.save_idea(_idea("Accept ST"))
+        for n in ("R1", "R2", "R3", "R4"):
+            await db.save_filtered_idea(_filtered(n, category=IdeaCategory.SECURITY_TOOL))
+        # automation: 7 of 10 = 0.70
+        for i in range(3):
+            await db.save_idea(_idea(f"Acc auto {i}", category=IdeaCategory.AUTOMATION))
+        for i in range(7):
+            await db.save_filtered_idea(_filtered(f"Rej auto {i}", category=IdeaCategory.AUTOMATION))
+
+        summary = await build_filter_summary(db, rate_threshold=0.6)
+        rates = summary["high_filter_rate_categories"]
+        # First entry must have higher rate than second
+        assert len(rates) >= 2
+        assert rates[0][1] >= rates[1][1]
+
+
+# ── IdeaGenerator forwards filter_summary to build_generation_prompt
+
+
+class TestIdeaGeneratorFilterSummaryForwarding:
+    def test_generate_accepts_filter_summary_kwarg(self, monkeypatch):
+        """IdeaGenerator.generate must accept and forward filter_summary."""
+        import asyncio
+
+        from project_forge.engine.generator import IdeaGenerator
+
+        captured = {}
+
+        _FAKE_JSON = (
+            '{"name":"X","tagline":"t","description":"d","category":"security-tool",'
+            '"market_analysis":"m","feasibility_score":0.8,"mvp_scope":"mvp",'
+            '"tech_stack":["py"]}'
+        )
+
+        # Stub anthropic + the prompt builder so we observe what was passed
+        class _StubMessages:
+            def create(self, **kwargs):  # noqa: ARG002
+                class _Resp:
+                    content = [type("X", (), {"text": _FAKE_JSON})]
+                return _Resp()
+
+        class _StubClient:
+            messages = _StubMessages()
+
+        def stub_build_prompt(**kwargs):
+            captured.update(kwargs)
+            return "PROMPT"
+
+        gen = IdeaGenerator.__new__(IdeaGenerator)
+        gen.client = _StubClient()
+        gen.model = "stub-model"
+        monkeypatch.setattr(
+            "project_forge.engine.generator.build_generation_prompt",
+            stub_build_prompt,
+        )
+
+        summary = {
+            "saturated_concepts": ["certificate"],
+            "high_filter_rate_categories": [("security-tool", 0.80)],
+        }
+
+        asyncio.run(gen.generate(
+            category=IdeaCategory.SECURITY_TOOL,
+            filter_summary=summary,
+        ))
+
+        assert captured.get("filter_summary") == summary