@m13v/s4l 1.6.197-rc.7

package/scripts/project_excludes.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""project_excludes.py — HTTP-backed exclude list (2026-05-12 migration).
+
+Self-improving per-project exclusion list. Claude proposes specific keywords
+during Phase 2b-prep when it rejects an off-topic candidate; those keywords
+get appended as `-term` to all future search queries for that project after
+they clear an activation gate (>=2 distinct batches).
+
+All reads and writes now route through /api/v1/project-excludes on the
+social-autoposter-website API. Direct SQL is GONE; the only Python state
+this module owns is the local reserved-keyword check (which reads
+config.json on disk).
+
+CLI usage
+---------
+    # List active excludes for a project (JSON to stdout):
+    python3 scripts/project_excludes.py active --platform twitter --project Vipassana
+
+    # Active excludes split by kind (reddit):
+    python3 scripts/project_excludes.py active-split --platform reddit --project studyly
+
+    # Propose a new exclude (used by log_twitter_skips.py / post_reddit.py):
+    python3 scripts/project_excludes.py propose \
+        --platform reddit --project studyly --term subreddit:bestofredditorupdates \
+        --candidate-id 10196 --batch-id rdtcycle-20260512-163303 \
+        --reason 'off-topic drama subreddit'
+
+    # Stamp last_used_at when terms get appended to a live query:
+    python3 scripts/project_excludes.py mark-used \
+        --platform reddit --project studyly --terms subreddit:foo subreddit:bar
+
+    # Decay: prune terms unused in 60 days with <3 batches.
+    python3 scripts/project_excludes.py decay [--days 60]
+
+Module API
+----------
+    from project_excludes import active_excludes, active_excludes_by_kind, \
+        propose, mark_used, decay
+
+Activation gate
+---------------
+A term is APPLIED to live queries only when array_length(batch_ids,1) >= 2,
+so one false-rejection can't mute the searches. The proposal IS recorded
+on first emission so we can audit "Claude proposed this once but never again".
+
+False-negative guards: structural validation (term shape, allowed kinds per
+platform) is enforced server-side. Reserved-keyword check is enforced LOCALLY
+before we hit the network, because config.json lives on the client.
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from http_api import api_get, api_post, api_delete
+from project_topics import topics_for_project
+
+
+ACTIVATION_BATCH_FLOOR = 2          # term must appear in this many distinct batches before applying
+DECAY_DAYS_DEFAULT = 60             # prune unused terms older than this with <3 distinct batches
+TERM_MIN_LEN = 3
+# Bare-keyword form (Twitter): "cricket", "kohli". Kept for back-compat.
+TERM_RE = re.compile(r"^[a-z0-9][a-z0-9\-]{1,30}$")
+# Reddit-only typed form: "subreddit:bestofredditorupdates" (sub bans) or
+# "keyword:foo" (explicit keyword ban). The 2026-05-11 reddit wiring writes
+# subreddit: rows; keyword: is kept as a future-proof typed-keyword path so
+# reddit and twitter never collide on the same row even if they share a name.
+TYPED_TERM_RE = re.compile(r"^(subreddit|keyword):[a-z0-9][a-z0-9_\-]{1,40}$")
+
+# Per-platform allowed term kinds. Twitter stays bare-keyword-only (legacy
+# behavior unchanged); reddit accepts subreddit: and keyword: typed forms only,
+# so an accidentally-bare term ("anki") can never silently kill a core seed.
+ALLOWED_KINDS = {
+    "twitter": {"bare"},
+    "reddit": {"subreddit", "keyword"},
+}
+
+
+def parse_term(term):
+    """Return (kind, value) for a normalized term.
+
+    - Bare "cricket"                    -> ("bare", "cricket")           [twitter form]
+    - "subreddit:bestofredditorupdates" -> ("subreddit", "bestofredditorupdates")
+    - "keyword:powerpoint"              -> ("keyword", "powerpoint")
+    Returns (None, None) for unrecognized shapes.
+    """
+    if not isinstance(term, str):
+        return None, None
+    t = term.strip().lower()
+    if ":" in t:
+        kind, _, val = t.partition(":")
+        kind = kind.strip()
+        val = val.strip()
+        if kind in ("subreddit", "keyword") and val:
+            return kind, val
+        return None, None
+    if TERM_RE.match(t):
+        return "bare", t
+    return None, None
+
+
+def _load_reserved_terms_for_project(project_name):
+    """Tokens we MUST NEVER let Claude exclude. Source: project_search_topics (DB) for the project.
+
+    Topic entries can be Twitter-search-style strings with OR/parens/quotes;
+    we split them into bare lowercase tokens so a query string like
+    `"vipassana" OR "Goenka"` reserves both `vipassana` and `goenka`.
+    """
+    reserved = set()
+    if not project_name:
+        return reserved
+    try:
+        topics = topics_for_project(project_name)
+    except Exception:
+        return reserved
+    for t in topics:
+        if not isinstance(t, str):
+            continue
+        for tok in re.split(r"[\s\(\)\"\'\|]+|\bOR\b|\bAND\b|\bNOT\b|min_faves:\d+|since:[\d\-]+|-filter:\w+", t):
+            tok = tok.strip().lower()
+            if tok and TERM_MIN_LEN <= len(tok) <= 32:
+                reserved.add(tok)
+    # Also reserve the project name itself (case-insensitive single token).
+    reserved.add(project_name.lower())
+    return reserved
+
+
+def normalize_term(term):
+    """Return a normalized term, or None if invalid."""
+    if not isinstance(term, str):
+        return None
+    t = term.strip().lower().strip("\"'")
+    if len(t) < TERM_MIN_LEN:
+        return None
+    if TYPED_TERM_RE.match(t):
+        return t
+    if TERM_RE.match(t):
+        return t
+    return None
+
+
+def _kind_allowed_for_platform(kind, platform):
+    """Gate which term kinds a given platform may write/read."""
+    if not kind:
+        return False
+    allowed = ALLOWED_KINDS.get(platform)
+    if not allowed:
+        return False
+    return kind in allowed
+
+
+def active_excludes(platform, project, min_batches=ACTIVATION_BATCH_FLOOR):
+    """Return the list of currently-active exclude terms for (platform, project).
+
+    Only terms that have cleared the activation gate (>=ACTIVATION_BATCH_FLOOR
+    distinct proposing batches) are returned. Order: longest-first so when
+    the query drafter appends them, more-specific terms win lex-sort tooltips.
+    """
+    resp = api_get(
+        "/api/v1/project-excludes",
+        query={"platform": platform, "project": project, "min_batches": min_batches},
+    )
+    data = resp.get("data") if isinstance(resp, dict) else None
+    if not data:
+        return []
+    return list(data.get("terms") or [])
+
+
+def active_excludes_by_kind(platform, project):
+    """Same as active_excludes() but split by kind for reddit callers."""
+    terms = active_excludes(platform, project)
+    out = {"subreddit": [], "keyword": [], "bare": []}
+    for t in terms:
+        kind, value = parse_term(t)
+        if kind in out and value:
+            out[kind].append(value)
+    return out
+
+
+def propose(platform, project, term, candidate_id=None, batch_id=None, reason=None):
+    """UPSERT a single proposed exclude via HTTP.
+
+    The reserved-keyword check runs LOCALLY (config.json is on the client).
+    Structural validation (regex, platform-kind allowed) runs on both sides;
+    the server is authoritative.
+
+    outcome keys:
+        ok (bool)         success
+        term (str | None) normalized term (None if rejected by validation)
+        action (str)      one of: 'inserted', 'bumped', 'duplicate_batch',
+                          'rejected_invalid', 'rejected_reserved'
+        active (bool)     whether the term is now ACTIVE (>=ACTIVATION_BATCH_FLOOR)
+    """
+    norm = normalize_term(term)
+    if norm is None:
+        return {"ok": False, "term": None, "action": "rejected_invalid", "active": False}
+
+    kind, value = parse_term(norm)
+    if not _kind_allowed_for_platform(kind, platform):
+        return {"ok": False, "term": norm, "action": "rejected_invalid", "active": False}
+
+    if kind in ("bare", "keyword"):
+        reserved = _load_reserved_terms_for_project(project)
+        check_val = value if kind == "keyword" else norm
+        if check_val in reserved:
+            return {"ok": False, "term": norm, "action": "rejected_reserved", "active": False}
+        reserved_for_post = sorted(reserved)
+    else:
+        reserved_for_post = []
+
+    body = {
+        "platform": platform,
+        "project": project,
+        "term": norm,
+        "reserved_terms": reserved_for_post,
+    }
+    if candidate_id is not None:
+        body["candidate_id"] = int(candidate_id)
+    if batch_id:
+        body["batch_id"] = batch_id
+    if reason:
+        body["reason"] = reason[:500]
+    resp = api_post("/api/v1/project-excludes", body)
+    data = resp.get("data") if isinstance(resp, dict) else None
+    if not data:
+        return {"ok": False, "term": norm, "action": "rejected_invalid", "active": False}
+    return {
+        "ok": bool(data.get("ok")),
+        "term": data.get("term") or norm,
+        "action": data.get("action") or "unknown",
+        "active": bool(data.get("active")),
+    }
+
+
+def mark_used(platform, project, terms):
+    """Stamp last_used_at for each term we just appended to a query."""
+    if not terms:
+        return 0
+    resp = api_post(
+        "/api/v1/project-excludes/mark-used",
+        {"platform": platform, "project": project, "terms": list(terms)},
+    )
+    data = resp.get("data") if isinstance(resp, dict) else None
+    if not data:
+        return 0
+    return int(data.get("stamped") or 0)
+
+
+def decay(days=DECAY_DAYS_DEFAULT, dry_run=False):
+    """Prune terms with <3 distinct batches that haven't been used in `days`."""
+    resp = api_delete(
+        "/api/v1/project-excludes",
+        query={"days": days, "dry_run": "true" if dry_run else None},
+    )
+    data = resp.get("data") if isinstance(resp, dict) else None
+    if dry_run:
+        rows = (data or {}).get("rows") or []
+        return [
+            {
+                "platform": r.get("platform"),
+                "project": r.get("project"),
+                "term": r.get("term"),
+                "batches": r.get("batches"),
+                "last_used_at": r.get("last_used_at"),
+            }
+            for r in rows
+        ]
+    return int((data or {}).get("pruned_count") or 0)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    a = sub.add_parser("active", help="List active excludes for a project")
+    a.add_argument("--platform", required=True)
+    a.add_argument("--project", required=True)
+    a.add_argument("--as-flags", action="store_true",
+                   help="Print as space-joined `-term` flags instead of JSON list.")
+
+    asplit = sub.add_parser("active-split",
+                            help="Active excludes split by kind {subreddit, keyword, bare}. Reddit-friendly.")
+    asplit.add_argument("--platform", required=True)
+    asplit.add_argument("--project", required=True)
+
+    p = sub.add_parser("propose", help="Propose a new exclude term")
+    p.add_argument("--platform", required=True)
+    p.add_argument("--project", required=True)
+    p.add_argument("--term", required=True)
+    p.add_argument("--candidate-id", type=int)
+    p.add_argument("--batch-id")
+    p.add_argument("--reason")
+
+    m = sub.add_parser("mark-used", help="Stamp last_used_at on terms appended to a live query")
+    m.add_argument("--platform", required=True)
+    m.add_argument("--project", required=True)
+    m.add_argument("--terms", nargs="+", required=True)
+
+    d = sub.add_parser("decay", help="Prune unused unverified terms")
+    d.add_argument("--days", type=int, default=DECAY_DAYS_DEFAULT)
+    d.add_argument("--dry-run", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.cmd == "active":
+        terms = active_excludes(args.platform, args.project)
+        if args.as_flags:
+            sys.stdout.write(" ".join(f"-{t}" for t in terms))
+            sys.stdout.write("\n")
+        else:
+            json.dump(terms, sys.stdout)
+            sys.stdout.write("\n")
+        return 0
+
+    if args.cmd == "active-split":
+        split = active_excludes_by_kind(args.platform, args.project)
+        json.dump(split, sys.stdout)
+        sys.stdout.write("\n")
+        return 0
+
+    if args.cmd == "propose":
+        out = propose(
+            args.platform, args.project, args.term,
+            candidate_id=args.candidate_id,
+            batch_id=args.batch_id,
+            reason=args.reason,
+        )
+        json.dump(out, sys.stdout)
+        sys.stdout.write("\n")
+        return 0 if out["ok"] else 2
+
+    if args.cmd == "mark-used":
+        n = mark_used(args.platform, args.project, args.terms)
+        print(f"mark_used: {n} rows stamped")
+        return 0
+
+    if args.cmd == "decay":
+        if args.dry_run:
+            rows = decay(days=args.days, dry_run=True)
+            json.dump(rows, sys.stdout, indent=2)
+            sys.stdout.write("\n")
+        else:
+            n = decay(days=args.days, dry_run=False)
+            print(f"decay: {n} rows pruned (older than {args.days}d, <3 batches)")
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/project_slugs.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Single source of truth for project -> client_slug + booking_table.
+
+Derives both from ~/social-autoposter/config.json so no list of projects is
+maintained in parallel across project_stats.py, pick_top_page.py,
+pick_top_pages.py, or the cal webhook routing.
+
+client_slug rule:
+    project `name` lowercased with dashes/spaces stripped, unless the
+    project explicitly defines a `client_slug` field. Matches every entry
+    hard-coded historically (Cyrano->cyrano, PieLine->pieline, paperback-expert
+    ->paperbackexpert, fde10x->fde10x, etc.).
+
+booking_table rule:
+    cal.com/*       -> cal_bookings
+    calendly.com/*  -> calendly_bookings
+    anything else / unset -> None (project does not attribute bookings)
+"""
+
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+CONFIG_PATH = Path(__file__).resolve().parent.parent / "config.json"
+
+
+def _derive_slug(name: str) -> str:
+    return name.lower().replace("-", "").replace(" ", "")
+
+
+@lru_cache(maxsize=1)
+def _projects() -> list[dict]:
+    try:
+        return json.loads(CONFIG_PATH.read_text()).get("projects", [])
+    except (OSError, ValueError):
+        return []
+
+
+def _find(project_name: str) -> Optional[dict]:
+    for p in _projects():
+        if p.get("name") == project_name:
+            return p
+    return None
+
+
+def get_client_slug(project_name: str) -> Optional[str]:
+    """Return the client_slug used in cal_bookings / calendly_bookings for
+    this project. Returns None if the project is not in config.json."""
+    p = _find(project_name)
+    if p is None:
+        return None
+    return p.get("client_slug") or _derive_slug(project_name)
+
+
+def get_booking_table(project_name: str) -> Optional[str]:
+    """Return 'cal_bookings', 'calendly_bookings', or None if the project has
+    no booking link configured."""
+    p = _find(project_name)
+    if p is None:
+        return None
+    link = (p.get("booking_link") or "").lower()
+    if "calendly.com" in link:
+        return "calendly_bookings"
+    if "cal.com" in link:
+        return "cal_bookings"
+    return None
+
+
+def bookings_require_utm(project_name: str) -> bool:
+    """Whether to gate `real_bookings` on `utm_source IS NOT NULL`.
+
+    Default False: each cal.com booking page is product-specific, so any
+    non-test booking on it is by definition a prospect for that product, no
+    UTM needed. Set True for projects whose booking destination is a shared
+    surface (e.g. paperback-expert's calendly account hosts Michael DeLon's
+    whole business funnel, not just b00kd.com inbound)."""
+    p = _find(project_name)
+    if p is None:
+        return False
+    return bool(p.get("bookings_require_utm"))
+
+
+if __name__ == "__main__":
+    # Smoke-test: print the derivation for every project in config.json.
+    for p in _projects():
+        name = p.get("name", "")
+        print(f"{name!r:<28} slug={get_client_slug(name)!r:<22} "
+              f"table={get_booking_table(name)!r}")

package/scripts/project_stats.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""Unified funnel stats per project: social posts -> pageviews -> CTA clicks -> bookings.
+
+Reads config.json for project definitions, queries:
+  - Posts + bookings stats via s4l.ai HTTP /api/v1/stats/* (no direct DB)
+  - PostHog API (POSTHOG_PERSONAL_API_KEY): pageviews + CTA clicks by domain
+
+Usage:
+    python3 scripts/project_stats.py [--project NAME] [--days 30] [--quiet]
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from datetime import datetime, timedelta, timezone
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get  # noqa: E402
+from project_slugs import get_client_slug, get_booking_table  # noqa: E402
+
+ENV_PATH = os.path.expanduser("~/social-autoposter/.env")
+CONFIG_PATH = os.path.expanduser("~/social-autoposter/config.json")
+
+
+def load_env():
+    if os.path.exists(ENV_PATH):
+        with open(ENV_PATH) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    k, v = line.split("=", 1)
+                    os.environ.setdefault(k.strip(), v.strip())
+
+
+def load_config():
+    with open(CONFIG_PATH) as f:
+        return json.load(f)
+
+
+def posthog_query(api_key, project_id, event, host_filter, after_date):
+    """Query PostHog events API for events matching a host."""
+    url = f"https://us.posthog.com/api/projects/{project_id}/events/"
+    params = {
+        "event": event,
+        "limit": 1000,
+        "after": after_date,
+    }
+    if host_filter:
+        params["properties"] = json.dumps([
+            {"key": "$host", "value": host_filter, "type": "event"}
+        ])
+
+    query = "&".join(f"{k}={urllib.request.quote(str(v))}" for k, v in params.items())
+    full_url = f"{url}?{query}"
+
+    req = urllib.request.Request(full_url, headers={
+        "Authorization": f"Bearer {api_key}",
+    })
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read())
+            return data.get("results", [])
+    except (urllib.error.URLError, urllib.error.HTTPError) as e:
+        print(f"  PostHog API error for {event} on {host_filter}: {e}", file=sys.stderr)
+        return []
+
+
+def get_posthog_stats(api_key, project_id, domains, days):
+    """Get pageviews and CTA clicks from PostHog for given domains."""
+    after = (datetime.now(timezone.utc) - timedelta(days=days)).strftime("%Y-%m-%dT%H:%M:%S")
+    stats = {"pageviews": 0, "cta_clicks": 0, "pageview_details": {}, "cta_details": []}
+
+    for domain in domains:
+        pvs = posthog_query(api_key, project_id, "$pageview", domain, after)
+        stats["pageviews"] += len(pvs)
+        paths = {}
+        for ev in pvs:
+            path = ev.get("properties", {}).get("$pathname", "/")
+            paths[path] = paths.get(path, 0) + 1
+        stats["pageview_details"][domain] = {
+            "total": len(pvs),
+            "top_pages": dict(sorted(paths.items(), key=lambda x: -x[1])[:10]),
+        }
+
+        ctas = posthog_query(api_key, project_id, "cta_click", domain, after)
+        if not ctas:
+            ctas = posthog_query(api_key, project_id, "$autocapture", domain, after)
+            ctas = [e for e in ctas if "book" in (e.get("properties", {}).get("$el_text", "") or "").lower()]
+        stats["cta_clicks"] += len(ctas)
+        for c in ctas:
+            props = c.get("properties", {})
+            stats["cta_details"].append({
+                "text": props.get("$el_text") or props.get("text", "?"),
+                "section": props.get("section", "?"),
+                "time": c.get("timestamp", "?")[:16],
+            })
+
+    return stats
+
+
+def get_project_domains(project):
+    """Extract all domains associated with a project."""
+    domains = []
+    website = project.get("website", "")
+    if website:
+        domain = website.replace("https://", "").replace("http://", "").rstrip("/")
+        domains.append(domain)
+
+    lp = project.get("landing_pages")
+    if isinstance(lp, dict):
+        base = lp.get("base_url", "")
+        if base:
+            domain = base.replace("https://", "").replace("http://", "").rstrip("/")
+            if domain not in domains:
+                domains.append(domain)
+    elif isinstance(lp, str) and lp.startswith("http"):
+        domain = lp.replace("https://", "").replace("http://", "").rstrip("/")
+        if domain not in domains:
+            domains.append(domain)
+
+    return domains
+
+
+def print_project_report(name, post_stats, platforms, posthog, bookings, quiet=False):
+    """Print formatted report for one project."""
+    print(f"\n{'='*60}")
+    print(f"  {name}")
+    print(f"{'='*60}")
+
+    print(f"\n  Social Posts:")
+    print(f"    Total: {post_stats.get('total', 0)}  |  Recent: {post_stats.get('recent', 0)}  |  Active: {post_stats.get('active', 0)}  |  Removed: {post_stats.get('removed', 0)}")
+    print(f"    Engagement: {post_stats.get('total_upvotes', 0)} upvotes, {post_stats.get('total_comments', 0)} comments, {post_stats.get('total_views', 0)} views")
+    if platforms:
+        parts = [f"{p}: {c}" for p, c in platforms.items()]
+        print(f"    Platforms: {', '.join(parts)}")
+
+    if posthog and (posthog["pageviews"] > 0 or posthog["cta_clicks"] > 0):
+        print(f"\n  Website Analytics (PostHog):")
+        print(f"    Pageviews: {posthog['pageviews']}  |  CTA Clicks: {posthog['cta_clicks']}")
+        if not quiet:
+            for domain, info in posthog.get("pageview_details", {}).items():
+                print(f"    {domain}: {info['total']} pageviews")
+                for path, count in list(info.get("top_pages", {}).items())[:5]:
+                    print(f"      {path}: {count}")
+            if posthog["cta_details"]:
+                print(f"    CTA clicks:")
+                for cta in posthog["cta_details"][:5]:
+                    print(f"      [{cta['time']}] \"{cta['text']}\" ({cta['section']})")
+
+    if bookings:
+        print(f"\n  Cal.com Bookings:")
+        print(f"    Total: {bookings.get('total', 0)}  |  Booked: {bookings.get('booked', 0)}  |  Cancelled: {bookings.get('cancelled', 0)}  |  Real: {bookings.get('real_bookings', 0)}")
+        if not quiet and bookings.get("recent"):
+            for b in bookings["recent"][:3]:
+                flag = " [TEST]" if "test" in (b["name"] or "").lower() or "example" in (b["email"] or "").lower() else ""
+                print(f"      {b['created']} - {b['name']} ({b['email']}) - {b['status']}{flag}")
+
+    if posthog and bookings:
+        pvs = posthog["pageviews"]
+        ctas = posthog["cta_clicks"]
+        real = bookings.get("real_bookings", 0)
+        print(f"\n  Funnel:")
+        if pvs:
+            print(f"    Pageviews -> CTA Clicks: {pvs} -> {ctas} ({(ctas/pvs*100):.1f}% CTR)")
+        else:
+            print(f"    Pageviews -> CTA Clicks: 0 -> {ctas}")
+        if ctas:
+            print(f"    CTA Clicks -> Bookings: {ctas} -> {real} ({(real/ctas*100):.1f}% conversion)")
+        else:
+            print(f"    CTA Clicks -> Bookings: 0 -> {real}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Unified project funnel stats")
+    parser.add_argument("--project", help="Filter to specific project name")
+    parser.add_argument("--days", type=int, default=30, help="Lookback period in days (default: 30)")
+    parser.add_argument("--quiet", action="store_true", help="Compact output")
+    args = parser.parse_args()
+
+    load_env()
+    config = load_config()
+
+    api_key = os.environ.get("POSTHOG_PERSONAL_API_KEY")
+    project_id = os.environ.get("POSTHOG_PROJECT_ID", "330744")
+
+    if not api_key:
+        print("ERROR: POSTHOG_PERSONAL_API_KEY not set in .env", file=sys.stderr)
+        sys.exit(1)
+
+    projects_with_stats = [
+        "fazm", "Cyrano", "PieLine", "Terminator", "S4L",
+        "macOS MCP", "Vipassana", "WhatsApp MCP", "AI Browser Profile", "macOS Session Replay",
+    ]
+
+    print(f"Project Funnel Stats (last {args.days} days)")
+    print(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
+
+    for proj in config.get("projects", []):
+        name = proj["name"]
+        if args.project and args.project.lower() != name.lower():
+            continue
+        if name not in projects_with_stats and not args.project:
+            continue
+
+        client_slug = get_client_slug(name)
+        booking_table = get_booking_table(name)
+        detail = (api_get("/api/v1/stats/project-detail", query={
+            "project": name, "days": int(args.days), "platform": "",
+            "client_slug": client_slug or "",
+            "booking_table": booking_table or "cal_bookings",
+            "require_utm": "0",
+        }).get("data") or {})
+        post_stats = detail.get("post_stats") or {}
+        platforms = detail.get("platforms") or {}
+        bookings = detail.get("bookings") if client_slug else None
+
+        domains = get_project_domains(proj)
+        ph_override = proj.get("posthog", {})
+        ph_key = os.environ.get(ph_override.get("api_key_env", ""), api_key)
+        ph_pid = ph_override.get("project_id", project_id)
+        posthog = get_posthog_stats(ph_key, ph_pid, domains, args.days) if domains else None
+
+        print_project_report(name, post_stats, platforms, posthog, bookings, args.quiet)
+
+    # Overall summary
+    overall = (api_get("/api/v1/stats/posts-overall", query={
+        "days": int(args.days), "platform": "",
+    }).get("data") or {})
+    total_all = int(overall.get("total") or 0)
+    total_recent = int(overall.get("recent") or 0)
+    print(f"\n{'='*60}")
+    print(f"  Overall: {total_all} total posts, {total_recent} in last {args.days} days")
+    print(f"{'='*60}")
+
+
+if __name__ == "__main__":
+    main()