feat(O2): continuous PR review — PrEventSource seam + org sync CLI

Implements Slice O2: every PR opened on a governed repo gets its verdict
with no human action.

Architecture (webhook-swap ready):
  - PrEvent dataclass (frozen, 7 fields) — the seam between poll and webhooks
  - PrEventSource abstract base; GitHubPollEventSource wraps list_prs today
  - O6 webhook endpoint maps GitHub payloads to the same PrEvent → same
    handler, zero rework at swap time (as designed)

Per new/updated head SHA:
  - Trailer links extracted from mirror (failure-safe; sync_org constructs
    LinkStore like first_results when none injected)
  - Analysis runs via run_analysis (idempotency cache skips repeats)
  - check:analyzed activity_events row emitted (failure-safe, absorbs U4)
  - Optional publish_comment gated by HARD RULE: non-giladax remotes (psf,
    pallets, …) NEVER receive comments; giladax requires publish_enabled:true
    in sync_meta.yaml; default OFF everywhere

Budget discipline: max_prs_per_repo caps per-pass analysis; list_prs capped
at 2 pages; sync_meta.yaml tracks seen SHA set and last_seen_updated_at.

CLI: `python3 -m quire.cli org sync [--loop --interval N] [--max-prs N]`

Live proof (tokenless, ≤20 API calls): one pass detected + analyzed
psf/requests#7586, pallets/itsdangerous#428, #1; verdicts
on the org cards; 3 check:analyzed rows in activity_events; publish guard
asserted OFF for all residents; registry state committed.

Also: github adapter list_prs gains updated_at field (backward-compatible).

Tests: 44 new offline tests (no live GitHub, no live Postgres); backend
707 passed, 1 skipped; app vitest (from app/) 59/59 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016cmqJ7aie4Kap4ZsZraMF1

Author: Gilad Koch

backend/quire/adapters/github.py

@@ -129,6 +129,7 @@ def list_prs(
                     "base_sha": (pr.get("base") or {}).get("sha", ""),
                     "author": (pr.get("user") or {}).get("login", ""),
                     "created_at": pr.get("created_at", ""),
+                    "updated_at": pr.get("updated_at", ""),
                     "html_url": pr.get("html_url", ""),
                 })
             if len(batch) < per_page:

backend/quire/analysis/graph.py

@@ -128,4 +128,9 @@ def run_analysis(
         llm = AnthropicAlignmentLLM()
     graph = build_analysis_graph(adapter, llm, store=store, config=config)
     result = graph.invoke({"pr_number": pr_number, "force": force})
-    return result["analysis"]
+    analysis = result["analysis"]
+    if analysis is not None:
+        # Thread the cache-hit flag out of the graph state so callers can
+        # distinguish a fresh analysis from a cached one (org_sync `skipped`).
+        analysis.from_cache = result.get("cached", False)
+    return analysis

backend/quire/cli.py

@@ -13,6 +13,7 @@
 from __future__ import annotations
 
 import pathlib
+import time
 
 import typer
 
@@ -1038,5 +1039,122 @@ def mcp():
     start_mcp_server()
 
 
+# ── Org sub-group (O2+) ────────────────────────────────────────────────────
+
+org_app = typer.Typer(no_args_is_help=True, add_completion=False,
+                      help="Org platform — governed repos, continuous PR review.")
+app.add_typer(org_app, name="org")
+
+
+@org_app.command("sync")
+def org_sync(
+    loop: bool = typer.Option(False, "--loop", help="poll continuously"),
+    interval: int = typer.Option(
+        300, "--interval", help="seconds between passes when --loop is active"
+    ),
+    max_prs: int = typer.Option(
+        5, "--max-prs", help="max new PRs analyzed per repo per pass"
+    ),
+    db: str = typer.Option("", help="database URL (default sqlite file for alignment store)"),
+):
+    """Analyze new/updated PRs across all active GitHub-governed repos (O2).
+
+    One pass: for each active GitHub workspace in the org, poll open PRs,
+    detect new or updated head SHAs, run the alignment analyzer, and emit a
+    check:analyzed activity event per result.
+
+    Publishing comments on GitHub is OFF by default and must be explicitly
+    enabled per workspace (publish_enabled: true in sync_meta.yaml) AND the
+    repo must be owned by giladax.  Third-party repos (psf/requests, etc.)
+    NEVER receive comments from this system.
+
+    Rate limits: ~3–5 API calls per new PR head SHA; list_prs capped at 2
+    pages (≤200 PRs) per repo per pass.  GITHUB_TOKEN from .env is used when
+    present; tokenless rate limit is 60 req/hr (falls back gracefully).
+    """
+    import os
+
+    from quire.org_store import OrgStore, seed_demo_org
+    from quire.org_sync import sync_org
+    from quire.store import Store
+
+    alignment_store = Store(url=db or None)
+
+    try:
+        from quire.db.engine import get_engine
+        engine = get_engine()
+        org_store = OrgStore(engine=engine)
+        seed_demo_org(org_store)
+    except Exception as exc:
+        typer.secho(
+            f"could not connect to org Postgres: {exc} — "
+            "check DATABASE_URL and that `quire up` is running",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(1)
+
+    def _run_pass() -> None:
+        results = sync_org(
+            org_store,
+            alignment_store,
+            max_prs_per_repo=max_prs,
+        )
+        for r in results:
+            ws = r["workspace"]
+            repo = r["repository"]
+            if r.get("error"):
+                typer.secho(
+                    f"  {ws} ({repo}): ERROR — {r['error']}",
+                    fg=typer.colors.RED,
+                )
+                continue
+            polled = r["events_polled"]
+            analyzed = r["analyzed"]
+            typer.echo(f"  {ws} ({repo}): {polled} PRs polled, {analyzed} analyzed")
+            for res in r["results"]:
+                if res.get("error"):
+                    typer.secho(
+                        f"    PR #{res['pr_number']}: ERROR — {res['error']}",
+                        fg=typer.colors.YELLOW,
+                    )
+                elif res.get("skipped"):
+                    typer.echo(f"    PR #{res['pr_number']}: already analyzed (cached)")
+                else:
+                    from quire import vocab
+                    v = vocab.verdict(res.get("verdict"))
+                    colour = {
+                        "red": typer.colors.RED,
+                        "amber": typer.colors.YELLOW,
+                        "green": typer.colors.GREEN,
+                        "blue": typer.colors.BLUE,
+                    }.get(v["ink"], typer.colors.WHITE)
+                    url_note = (
+                        f" → published: {res['publish_url']}"
+                        if res.get("publish_url")
+                        else ""
+                    )
+                    typer.secho(
+                        f"    PR #{res['pr_number']}: {v['label']}{url_note}",
+                        fg=colour,
+                    )
+
+    if loop:
+        typer.secho(
+            f"org sync --loop: polling every {interval}s (Ctrl-C to stop)",
+            fg=typer.colors.CYAN,
+        )
+        while True:
+            typer.secho(f"\n[pass] {_now_str()}", fg=typer.colors.CYAN)
+            _run_pass()
+            time.sleep(interval)
+    else:
+        _run_pass()
+
+
+def _now_str() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(tz=timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+
+
 if __name__ == "__main__":
     app()

backend/quire/models.py

@@ -405,3 +405,9 @@ class PRAnalysis(BaseModel):
     artifact_snapshot_ids: list[str] = Field(default_factory=list)
     comment_markdown: str = ""
     created_at: datetime = Field(default_factory=utc_now)
+
+    # Transient: set by run_analysis when this result came from the identity
+    # cache (same head_sha + contract snapshot already analyzed). Not a stored
+    # fact — a runtime signal so callers (org_sync) can skip re-publishing and
+    # re-marking the SHA as seen.
+    from_cache: bool = False

backend/quire/org_store.py

@@ -32,6 +32,7 @@
         "github_remote": "https://github.com/giladax/intent-ai",
         "status": "active",
         "read_only": False,
+        "repository": "giladax/intent-ai",  # alignment key matches GitHub owner/name (org_sync writes under it)
     },
     {
         "id": "intent-ai-live",