Add Paperclip agent activity mirror to case detail page

New "Agents" tab in case detail shows all Paperclip agent comments,
issue status, and agent status for each case — eliminating the need
to switch between Legal-AI and Paperclip UIs.

Backend: 4 new DB query functions in paperclip_client.py (issues,
comments, agents, post_comment) + 2 new API endpoints (GET/POST
/api/cases/{case_number}/agents). Comment posting uses Board API
with DB+wakeup fallback to ensure CEO routing.

Frontend: agents.ts hooks (10s polling), AgentActivityFeed component
(markdown timeline + comment input), AgentStatusWidget (sidebar),
4th tab in case detail page.

Also includes new-company-setup-guide.md documenting the process
for setting up the betterment levy (CMPA) company.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

web/app.py

@@ -37,7 +37,11 @@ from web.gitea_client import create_repo, setup_remote_and_push
 from web.paperclip_client import (
     create_project as pc_create_project,
     create_workflow_issue as pc_create_workflow_issue,
+    get_agents_for_company as pc_get_agents,
+    get_case_issues as pc_get_case_issues,
+    get_issue_comments as pc_get_issue_comments,
     get_project_url,
+    post_comment as pc_post_comment,
     wake_ceo_agent as pc_wake_ceo,
 )
 
@@ -2214,6 +2218,55 @@ async def api_start_workflow(case_number: str):
     }
 
 
+# ── Agent Activity Mirror ─────────────────────────────────────────
+
+
+@app.get("/api/cases/{case_number}/agents")
+async def api_case_agents(case_number: str):
+    """Get all Paperclip agent activity for a case: issues, comments, agent status."""
+    issues = await pc_get_case_issues(case_number)
+    if not issues:
+        return {"issues": [], "comments": [], "agents": []}
+
+    issue_ids = [i["id"] for i in issues]
+    company_id = issues[0]["company_id"]
+
+    comments, agents = await pc_get_issue_comments(issue_ids), await pc_get_agents(company_id)
+
+    return {"issues": issues, "comments": comments, "agents": agents}
+
+
+class AgentCommentRequest(BaseModel):
+    body: str
+    issue_id: str | None = None
+
+
+@app.post("/api/cases/{case_number}/agents/comment")
+async def api_post_agent_comment(case_number: str, req: AgentCommentRequest):
+    """Post a comment on a Paperclip issue linked to a case.
+
+    If issue_id is omitted, the most recent non-done issue is used.
+    """
+    issues = await pc_get_case_issues(case_number)
+    if not issues:
+        raise HTTPException(404, f"לא נמצא פרויקט Paperclip לתיק {case_number}")
+
+    if req.issue_id:
+        target = next((i for i in issues if i["id"] == req.issue_id), None)
+        if not target:
+            raise HTTPException(404, f"Issue {req.issue_id} לא שייך לתיק {case_number}")
+    else:
+        # Pick the most recent non-done issue, or the last one
+        active = [i for i in issues if i["status"] != "done"]
+        target = active[-1] if active else issues[-1]
+
+    result = await pc_post_comment(target["id"], target["company_id"], req.body)
+
+    # Find the identifier for the response
+    result["issue_identifier"] = target.get("identifier", "")
+    return result
+
+
 # ── Settings: Tag → Company Mappings ──────────────────────────────
 
 @app.get("/api/settings/paperclip-companies")

web/paperclip_client.py

@@ -303,6 +303,159 @@ async def create_workflow_issue(case_number: str, title: str) -> dict:
         await conn.close()
 
 
+async def get_case_issues(case_number: str) -> list[dict]:
+    """Get all Paperclip issues linked to a legal-ai case number."""
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        rows = await conn.fetch(
+            """SELECT i.id, i.title, i.status, i.identifier, i.priority,
+                      i.assignee_agent_id, a.name AS assignee_name,
+                      i.started_at, i.completed_at, i.created_at, i.company_id
+               FROM issues i
+               JOIN plugin_state ps ON ps.scope_id = i.id::text
+               LEFT JOIN agents a ON i.assignee_agent_id = a.id
+               WHERE ps.plugin_id = $1::uuid
+                 AND ps.state_key = 'legal-case-number'
+                 AND ps.value_json = $2::jsonb
+               ORDER BY i.created_at""",
+            PLUGIN_ID, json.dumps(case_number),
+        )
+        return [
+            {
+                "id": str(r["id"]),
+                "title": r["title"],
+                "status": r["status"],
+                "identifier": r["identifier"],
+                "priority": r["priority"],
+                "assignee_name": r["assignee_name"],
+                "started_at": r["started_at"].isoformat() if r["started_at"] else None,
+                "completed_at": r["completed_at"].isoformat() if r["completed_at"] else None,
+                "created_at": r["created_at"].isoformat() if r["created_at"] else None,
+                "company_id": str(r["company_id"]),
+            }
+            for r in rows
+        ]
+    finally:
+        await conn.close()
+
+
+async def get_issue_comments(issue_ids: list[str]) -> list[dict]:
+    """Get all comments on a list of Paperclip issues, with agent metadata."""
+    if not issue_ids:
+        return []
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        rows = await conn.fetch(
+            """SELECT ic.id, ic.issue_id, ic.body, ic.created_at,
+                      ic.author_agent_id, ic.author_user_id,
+                      a.name AS agent_name, a.role AS agent_role, a.icon AS agent_icon
+               FROM issue_comments ic
+               LEFT JOIN agents a ON ic.author_agent_id = a.id
+               WHERE ic.issue_id = ANY($1::uuid[])
+               ORDER BY ic.created_at""",
+            issue_ids,
+        )
+        return [
+            {
+                "id": str(r["id"]),
+                "issue_id": str(r["issue_id"]),
+                "body": r["body"],
+                "created_at": r["created_at"].isoformat() if r["created_at"] else None,
+                "author_agent_id": str(r["author_agent_id"]) if r["author_agent_id"] else None,
+                "author_user_id": r["author_user_id"],
+                "agent_name": r["agent_name"],
+                "agent_role": r["agent_role"],
+                "agent_icon": r["agent_icon"],
+            }
+            for r in rows
+        ]
+    finally:
+        await conn.close()
+
+
+async def get_agents_for_company(company_id: str) -> list[dict]:
+    """Get all agents belonging to a Paperclip company."""
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        rows = await conn.fetch(
+            """SELECT id, name, role, title, status, icon, last_heartbeat_at
+               FROM agents
+               WHERE company_id = $1::uuid
+               ORDER BY role, name""",
+            company_id,
+        )
+        return [
+            {
+                "id": str(r["id"]),
+                "name": r["name"],
+                "role": r["role"],
+                "title": r["title"],
+                "status": r["status"],
+                "icon": r["icon"],
+                "last_heartbeat_at": r["last_heartbeat_at"].isoformat() if r["last_heartbeat_at"] else None,
+            }
+            for r in rows
+        ]
+    finally:
+        await conn.close()
+
+
+async def post_comment(issue_id: str, company_id: str, body: str) -> dict:
+    """Post a comment on a Paperclip issue.
+
+    Tries the Board API first (triggers plugin events for CEO routing).
+    Falls back to direct DB insert + CEO wakeup if API fails.
+    """
+    # Try Board API first — this triggers the event bus
+    if PAPERCLIP_BOARD_API_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=15) as client:
+                resp = await client.post(
+                    f"{PAPERCLIP_API_URL}/api/board/issues/{issue_id}/comments",
+                    json={"body": body},
+                    headers={"Authorization": f"Bearer {PAPERCLIP_BOARD_API_KEY}"},
+                )
+                if resp.status_code < 400:
+                    result = resp.json()
+                    logger.info("Posted comment via Board API on issue %s", issue_id)
+                    return {"comment_id": result.get("id", ""), "issue_id": issue_id, "method": "api"}
+        except Exception:
+            logger.debug("Board API comment failed for issue %s, falling back to DB", issue_id)
+
+    # Fallback: direct DB insert + explicit CEO wakeup
+    comment_id = str(uuid.uuid4())
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        await conn.execute(
+            """INSERT INTO issue_comments (id, company_id, issue_id, author_user_id, body)
+               VALUES ($1, $2::uuid, $3::uuid, 'chaim', $4)""",
+            comment_id, company_id, issue_id, body,
+        )
+        logger.info("Posted comment via DB fallback on issue %s", issue_id)
+    finally:
+        await conn.close()
+
+    # Wake CEO so it processes the comment
+    try:
+        url = f"{PAPERCLIP_API_URL}/api/agents/{CEO_AGENT_ID}/wakeup"
+        payload = {
+            "source": "on_demand",
+            "triggerDetail": "manual",
+            "reason": f"user_comment_{issue_id}",
+            "payload": {"issueId": issue_id, "mutation": "comment"},
+        }
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.post(
+                url, json=payload,
+                headers={"Authorization": f"Bearer {PAPERCLIP_BOARD_API_KEY}"},
+            )
+            resp.raise_for_status()
+    except Exception:
+        logger.warning("Failed to wake CEO after DB comment on issue %s", issue_id)
+
+    return {"comment_id": comment_id, "issue_id": issue_id, "method": "db_fallback"}
+
+
 async def wake_ceo_agent(issue_id: str, case_number: str) -> dict:
     """Wake the CEO agent via Paperclip's wakeup API.