amfs-http-server 0.1.2__tar.gz → 0.2.0__tar.gz

{amfs_http_server-0.1.2 → amfs_http_server-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amfs-http-server
-Version: 0.1.2
+Version: 0.2.0
 Summary: AMFS HTTP/REST API server with SSE support
 License-Expression: Apache-2.0
 Requires-Python: >=3.11

{amfs_http_server-0.1.2 → amfs_http_server-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amfs-http-server"
-version = "0.1.2"
+version = "0.2.0"
 description = "AMFS HTTP/REST API server with SSE support"
 requires-python = ">=3.11"
 license = "Apache-2.0"

{amfs_http_server-0.1.2 → amfs_http_server-0.2.0}/src/amfs_http/models.py

@@ -88,11 +88,24 @@ class UpdateTeamMemberRequest(BaseModel):
 
 
 class RunPatternDetectionRequest(BaseModel):
-    incident_threshold: int = 2
-    stale_days: int = 30
-    hot_entity_stddev: float = 2.0
-    drift_stddev: float = 2.0
     entity_path: str | None = None
+    agent_id: str | None = None
+    stale_days: int = 14
+    orphan_days: int = 7
+    pr_stale_days: int = 3
+    similarity_threshold: float = 0.75
+    incident_threshold: int = 2
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Agent Snapshots
+# ──────────────────────────────────────────────────────────────────────
+
+
+class CreateSnapshotRequest(BaseModel):
+    name: str
+    description: str = ""
+    snapshot_data: dict[str, Any] = Field(default_factory=dict)
 
 
 # ──────────────────────────────────────────────────────────────────────

{amfs_http_server-0.1.2 → amfs_http_server-0.2.0}/src/amfs_http/server.py

@@ -19,23 +19,35 @@ import json
 import logging
 import os
 import secrets
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any
 
 import uvicorn
 from fastapi import Depends, FastAPI, HTTPException, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 from sse_starlette.sse import EventSourceResponse
 
 from amfs import AgentMemory, MemoryType, OutcomeType
 from amfs.config import load_config_or_default
-from amfs_core.models import AMFSConfig, LayerConfig, MemoryEntry, SearchQuery
+from pydantic import BaseModel, Field
+from amfs_core.models import (
+    AMFSConfig,
+    Event,
+    EventType,
+    GraphEdge,
+    LayerConfig,
+    MemoryEntry,
+    SearchQuery,
+)
+from amfs_core.quality import HeuristicQualityEvaluator
 
 from amfs_http.auth import verify_api_key
 from amfs_http.models import (
     AddTeamMemberRequest,
     ContextRequest,
     CreateAPIKeyRequest,
+    CreateSnapshotRequest,
     CreateTeamRequest,
     EventRequest,
     OutcomeRequest,
@@ -224,6 +236,11 @@ async def health() -> dict[str, str]:
     return {"status": "ok"}
 
 
+@app.get("/api/v1/health")
+async def health_v1() -> dict[str, str]:
+    return {"status": "ok"}
+
+
 @app.get("/api/v1/auth/whoami")
 async def whoami(
     request: Request,
@@ -277,6 +294,43 @@ async def read_entry(
     return _entry_to_response(entry)
 
 
+@app.get("/api/v1/quality/{entity_path:path}/{key}")
+async def entry_quality(
+    entity_path: str,
+    key: str,
+    branch: str = Query("main"),
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Compute a quality report for a stored entry on demand."""
+    mem = _get_memory()
+    entry = mem.read(entity_path, key, branch=branch)
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Entry not found")
+
+    try:
+        existing_entries = mem.list(entity_path)
+        existing_keys = [e.key for e in existing_entries if e.key != key]
+    except Exception:
+        existing_keys = []
+
+    evaluator = HeuristicQualityEvaluator()
+    mt = entry.memory_type.value if hasattr(entry.memory_type, "value") else str(entry.memory_type)
+    report = evaluator.evaluate(
+        entry.value,
+        entity_path=entity_path,
+        key=key,
+        confidence=entry.confidence,
+        memory_type=mt,
+        pattern_refs=list(entry.provenance.pattern_refs),
+        existing_keys=existing_keys,
+    )
+    return {
+        "entity_path": entity_path,
+        "key": key,
+        "quality": report.model_dump(mode="json"),
+    }
+
+
 @app.post("/api/v1/entries")
 async def write_entry(
     req: WriteRequest,
@@ -319,6 +373,26 @@ async def write_entry(
         resource=f"{req.entity_path}/{req.key}",
         ip_address=request.client.host if request.client else None,
     )
+
+    try:
+        agent = entry.provenance.agent_id
+        ek = f"{entry.entity_path}/{entry.key}"
+        mem._adapter.upsert_graph_edge(
+            GraphEdge(
+                source_entity=agent,
+                source_type="agent",
+                relation="wrote",
+                target_entity=ek,
+                target_type="entry",
+                confidence=entry.confidence,
+                provenance={"agent_id": agent, "trigger": "write"},
+            ),
+            namespace=mem.namespace,
+            branch=entry.branch or "main",
+        )
+    except Exception:
+        logger.debug("Failed to materialize wrote edge", exc_info=True)
+
     return _entry_to_response(entry)
 
 
@@ -644,7 +718,6 @@ async def get_trace(
     mem = _get_memory()
     trace = mem._adapter.get_trace(trace_id)
     if trace is None:
-        from fastapi.responses import JSONResponse
         return JSONResponse({"error": "Trace not found"}, status_code=404)
     return trace.model_dump(mode="json")
 
@@ -654,8 +727,6 @@ async def explain_trace(
     trace_id: str,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
-    from fastapi.responses import JSONResponse
-
     api_key = os.environ.get("AMFS_LLM_API_KEY", "")
     if not api_key:
         return JSONResponse(
@@ -848,6 +919,8 @@ async def list_agents(
     entries = mem.list()
     agent_data: dict[str, dict[str, Any]] = {}
     for e in entries:
+        if e.entity_path.startswith("_system/"):
+            continue
         aid = e.provenance.agent_id
         if aid not in agent_data:
             agent_data[aid] = {
@@ -861,13 +934,28 @@ async def list_agents(
         if e.provenance.written_at > agent_data[aid]["last_active"]:
             agent_data[aid]["last_active"] = e.provenance.written_at
 
+    agent_descriptions: dict[str, dict[str, Any]] = {}
+    try:
+        desc_entries = mem.list("_system/agents")
+        for de in desc_entries:
+            val = de.value if isinstance(de.value, dict) else {}
+            agent_descriptions[de.key] = {
+                "description": val.get("description", ""),
+                "platform": val.get("platform", ""),
+            }
+    except Exception:
+        pass
+
     agents = []
     for ad in sorted(agent_data.values(), key=lambda x: x["entries_written"], reverse=True):
+        desc_info = agent_descriptions.get(ad["agent_id"], {})
         agents.append({
             "agentId": ad["agent_id"],
             "entriesWritten": ad["entries_written"],
             "entitiesTouched": len(ad["entities_touched"]),
             "lastActive": ad["last_active"].isoformat() if ad["last_active"] else None,
+            "description": desc_info.get("description", ""),
+            "platform": desc_info.get("platform", ""),
         })
     return {"agents": agents}
 
@@ -882,7 +970,10 @@ async def agent_memory_graph(
     entries = mem.list()
     traces = mem._adapter.list_traces(agent_id=agent_id, limit=10000)
 
-    written_by_agent = [e for e in entries if e.provenance.agent_id == agent_id]
+    written_by_agent = [
+        e for e in entries
+        if e.provenance.agent_id == agent_id and not e.entity_path.startswith("_system/")
+    ]
     entities_written: dict[str, list[dict]] = {}
     for e in written_by_agent:
         ep = e.entity_path
@@ -1050,9 +1141,12 @@ async def agent_activity(
     limit: int = Query(100),
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
-    """Timeline of writes and outcomes for this agent."""
+    """Timeline of writes, outcomes, reads, and other events for this agent."""
     mem = _get_memory()
-    entries = [e for e in mem.list() if e.provenance.agent_id == agent_id]
+    entries = [
+        e for e in mem.list()
+        if e.provenance.agent_id == agent_id and not e.entity_path.startswith("_system/")
+    ]
     entries.sort(key=lambda e: e.provenance.written_at, reverse=True)
 
     writes = [
@@ -1079,7 +1173,23 @@ async def agent_activity(
         for t in traces if t.outcome_ref
     ]
 
-    timeline = sorted(writes + outcomes, key=lambda x: x["timestamp"], reverse=True)[:limit]
+    events = mem._adapter.list_events(agent_id, mem.namespace, limit=limit)
+    event_items = [
+        {
+            "type": evt.event_type.value if hasattr(evt.event_type, "value") else str(evt.event_type),
+            "summary": evt.summary,
+            "details": evt.details,
+            "actorAgentId": evt.actor_agent_id,
+            "timestamp": evt.created_at.isoformat(),
+        }
+        for evt in events
+    ]
+
+    timeline = sorted(
+        writes + outcomes + event_items,
+        key=lambda x: x["timestamp"],
+        reverse=True,
+    )[:limit]
     return {"agentId": agent_id, "timeline": timeline}
 
 
@@ -1107,6 +1217,293 @@ async def agent_timeline(
     }
 
 
+class LogEventRequest(BaseModel):
+    agent_id: str
+    event_type: str
+    summary: str | None = None
+    details: dict[str, Any] = Field(default_factory=dict)
+    actor_agent_id: str | None = None
+    branch: str = "main"
+
+
+@app.post("/api/v1/timeline/events")
+async def log_timeline_event(
+    body: LogEventRequest,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Log a timeline event for an agent."""
+    mem = _get_memory()
+    try:
+        event_type_enum = EventType(body.event_type)
+    except ValueError:
+        return JSONResponse(
+            status_code=400,
+            content={"error": f"Unknown event_type: {body.event_type}"},
+        )
+    event = Event(
+        namespace=mem.namespace,
+        agent_id=body.agent_id,
+        branch=body.branch,
+        event_type=event_type_enum,
+        summary=body.summary,
+        details=body.details,
+        actor_agent_id=body.actor_agent_id,
+    )
+    saved = mem._adapter.log_event(event)
+    return saved.model_dump(mode="json")
+
+
+class UpsertGraphEdgeRequest(BaseModel):
+    source_entity: str
+    source_type: str = "agent"
+    relation: str
+    target_entity: str
+    target_type: str = "agent"
+    provenance: dict[str, Any] = Field(default_factory=dict)
+    branch: str = "main"
+
+
+@app.post("/api/v1/graph/edges")
+async def upsert_graph_edge_endpoint(
+    body: UpsertGraphEdgeRequest,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Create or update a knowledge graph edge."""
+    mem = _get_memory()
+    edge = GraphEdge(
+        source_entity=body.source_entity,
+        source_type=body.source_type,
+        relation=body.relation,
+        target_entity=body.target_entity,
+        target_type=body.target_type,
+        provenance=body.provenance,
+    )
+    mem._adapter.upsert_graph_edge(edge, namespace=mem.namespace, branch=body.branch)
+    return {"status": "ok"}
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Agent Snapshots
+# ──────────────────────────────────────────────────────────────────────
+
+
+SNAPSHOT_ENTITY = "_system/agent-snapshots"
+
+
+@app.post("/api/v1/agents/{agent_id}/snapshots")
+async def create_snapshot(
+    agent_id: str,
+    req: CreateSnapshotRequest,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Create a named snapshot of an agent's brain state."""
+    mem = _get_memory()
+    snapshot_id = f"snap-{int(datetime.now(timezone.utc).timestamp() * 1000)}"
+    snapshot_value = {
+        "id": snapshot_id,
+        "agent_id": agent_id,
+        "name": req.name,
+        "description": req.description,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "stats": req.snapshot_data.get("stats", {}),
+        "data": req.snapshot_data,
+    }
+
+    original_agent = mem._tagger.agent_id
+    mem._tagger.agent_id = agent_id
+    try:
+        mem.write(
+            SNAPSHOT_ENTITY,
+            f"{agent_id}/{snapshot_id}",
+            snapshot_value,
+            confidence=1.0,
+        )
+    finally:
+        mem._tagger.agent_id = original_agent
+
+    try:
+        mem._adapter.log_event(Event(
+            namespace=mem.namespace,
+            agent_id=agent_id,
+            branch="main",
+            event_type=EventType.SNAPSHOT_TAKEN,
+            summary=f"Snapshot '{req.name}' taken",
+            details={
+                "snapshot_id": snapshot_id,
+                "name": req.name,
+                "description": req.description,
+                **snapshot_value.get("stats", {}),
+            },
+        ))
+    except Exception:
+        logger.debug("Failed to log snapshot event", exc_info=True)
+
+    return {
+        "id": snapshot_id,
+        "name": req.name,
+        "agent_id": agent_id,
+        "created_at": snapshot_value["created_at"],
+    }
+
+
+@app.get("/api/v1/agents/{agent_id}/snapshots")
+async def list_snapshots(
+    agent_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """List all snapshots for an agent."""
+    mem = _get_memory()
+    entries = mem.list(entity_path=SNAPSHOT_ENTITY)
+    prefix = f"{agent_id}/"
+    snapshots = []
+    for e in entries:
+        if not e.key.startswith(prefix):
+            continue
+        val = e.value if isinstance(e.value, dict) else {}
+        snapshots.append({
+            "id": val.get("id", e.key.split("/")[-1]),
+            "name": val.get("name", e.key),
+            "description": val.get("description", ""),
+            "agent_id": agent_id,
+            "created_at": val.get("created_at", e.provenance.written_at.isoformat()),
+            "stats": val.get("stats", {}),
+        })
+    snapshots.sort(key=lambda s: s["created_at"], reverse=True)
+    return {"snapshots": snapshots, "count": len(snapshots)}
+
+
+@app.get("/api/v1/agents/{agent_id}/snapshots/{snapshot_id}")
+async def get_snapshot(
+    agent_id: str,
+    snapshot_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Get the full data for a specific snapshot."""
+    mem = _get_memory()
+    key = f"{agent_id}/{snapshot_id}"
+    entry = mem.recall(SNAPSHOT_ENTITY, key)
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Snapshot not found")
+    val = entry.value if isinstance(entry.value, dict) else {}
+    return val
+
+
+@app.delete("/api/v1/agents/{agent_id}/snapshots/{snapshot_id}")
+async def delete_snapshot(
+    agent_id: str,
+    snapshot_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Delete a snapshot."""
+    mem = _get_memory()
+    key = f"{agent_id}/{snapshot_id}"
+    entry = mem.recall(SNAPSHOT_ENTITY, key)
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Snapshot not found")
+    mem.write(SNAPSHOT_ENTITY, key, None, confidence=0.0)
+    return {"deleted": True, "id": snapshot_id}
+
+
+@app.post("/api/v1/agents/{agent_id}/snapshots/{snapshot_id}/recover")
+async def recover_snapshot(
+    agent_id: str,
+    snapshot_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Recover an agent's memory to the state captured in a snapshot."""
+    mem = _get_memory()
+    key = f"{agent_id}/{snapshot_id}"
+    entry = mem.recall(SNAPSHOT_ENTITY, key)
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Snapshot not found")
+
+    val = entry.value if isinstance(entry.value, dict) else {}
+    created_at = val.get("created_at")
+    if not created_at:
+        raise HTTPException(status_code=400, detail="Snapshot missing timestamp")
+
+    timestamp = datetime.fromisoformat(created_at)
+    count = mem._adapter.rollback_to_timestamp(
+        agent_id, "main", timestamp, mem.namespace,
+    )
+
+    try:
+        mem._adapter.log_event(Event(
+            namespace=mem.namespace,
+            agent_id=agent_id,
+            branch="main",
+            event_type=EventType.SNAPSHOT_RECOVERED,
+            summary=f"Recovered from snapshot '{val.get('name', snapshot_id)}'",
+            details={
+                "snapshot_id": snapshot_id,
+                "name": val.get("name", ""),
+                "recovered_to": created_at,
+                "entries_restored": count,
+            },
+        ))
+    except Exception:
+        logger.debug("Failed to log recovery event", exc_info=True)
+
+    return {
+        "recovered": True,
+        "snapshot_id": snapshot_id,
+        "entries_restored": count,
+        "recovered_to": created_at,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Agent-scoped branches & pull requests
+# ──────────────────────────────────────────────────────────────────────
+
+
+@app.get("/api/v1/agents/{agent_id}/branches")
+async def agent_branches(
+    agent_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Branches created or merged by this agent."""
+    mem = _get_memory()
+    try:
+        all_branches = mem.list_branches()  # type: ignore[attr-defined]
+    except (AttributeError, Exception):
+        return {"agentId": agent_id, "branches": [], "count": 0}
+    scoped = [
+        b for b in all_branches
+        if getattr(b, "created_by", None) == agent_id
+        or getattr(b, "merged_by", None) == agent_id
+    ]
+    return {
+        "agentId": agent_id,
+        "branches": [b.model_dump(mode="json") if hasattr(b, "model_dump") else b for b in scoped],
+        "count": len(scoped),
+    }
+
+
+@app.get("/api/v1/agents/{agent_id}/pull-requests")
+async def agent_pull_requests(
+    agent_id: str,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Pull requests created, merged, or closed by this agent."""
+    mem = _get_memory()
+    try:
+        all_prs = mem.list_pull_requests()  # type: ignore[attr-defined]
+    except (AttributeError, Exception):
+        return {"agentId": agent_id, "pullRequests": [], "count": 0}
+    scoped = [
+        pr for pr in all_prs
+        if getattr(pr, "created_by", None) == agent_id
+        or getattr(pr, "merged_by", None) == agent_id
+        or getattr(pr, "closed_by", None) == agent_id
+    ]
+    return {
+        "agentId": agent_id,
+        "pullRequests": [pr.model_dump(mode="json") if hasattr(pr, "model_dump") else pr for pr in scoped],
+        "count": len(scoped),
+    }
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Pro Branching Plugin (amfs_branching — proprietary)
 # ──────────────────────────────────────────────────────────────────────
@@ -1119,6 +1516,18 @@ except ImportError:
     pass
 
 
+# ──────────────────────────────────────────────────────────────────────
+# Control Plane Plugin (amfs_control_plane — proprietary SaaS billing)
+# ──────────────────────────────────────────────────────────────────────
+
+try:
+    from amfs_control_plane import mount_control_plane  # type: ignore[import-not-found]
+    mount_control_plane(app)
+    logger.info("Control-plane routes mounted (auth, billing, Stripe webhook)")
+except ImportError:
+    pass
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Admin — API Keys
 # ──────────────────────────────────────────────────────────────────────
@@ -1133,6 +1542,18 @@ def _get_db_pool():
     return None
 
 
+def _get_namespace() -> str:
+    """Return the namespace for the current adapter.
+
+    All admin queries MUST use this to scope data to the correct tenant.
+    """
+    mem = _get_memory()
+    adapter = mem._adapter
+    if hasattr(adapter, "_namespace"):
+        return adapter._namespace
+    return "default"
+
+
 def _audit_log(
     action: str,
     *,
@@ -1145,14 +1566,15 @@ def _audit_log(
     pool = _get_db_pool()
     if pool is None:
         return
+    ns = _get_namespace()
     try:
         with pool.connection() as conn:
             with conn.cursor() as cur:
                 cur.execute(
                     """INSERT INTO amfs_audit_log
-                           (actor_type, actor_name, action, resource, ip_address)
-                       VALUES (%s, %s, %s, %s, %s)""",
-                    (actor_type, actor_name, action, resource, ip_address),
+                           (namespace, actor_type, actor_name, action, resource, ip_address)
+                       VALUES (%s, %s, %s, %s, %s, %s)""",
+                    (ns, actor_type, actor_name, action, resource, ip_address),
                 )
     except Exception:
         logger.debug("Failed to write audit log", exc_info=True)
@@ -1165,12 +1587,16 @@ async def list_api_keys(
     pool = _get_db_pool()
     if pool is None:
         return {"keys": []}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
                 """SELECT id, name, prefix, key_type, active, scopes,
                           rate_limit_rpm, last_used, created_at, expires_at
-                   FROM amfs_api_keys ORDER BY created_at DESC"""
+                   FROM amfs_api_keys
+                   WHERE namespace = %s
+                   ORDER BY created_at DESC""",
+                (ns,),
             )
             rows = cur.fetchall()
     keys = []
@@ -1206,15 +1632,17 @@ async def create_api_key(
     raw_key = f"amfs_{secrets.token_urlsafe(32)}"
     prefix = raw_key[:12]
     key_hash = hashlib.sha256(raw_key.encode()).hexdigest()
+    ns = _get_namespace()
 
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
                 """INSERT INTO amfs_api_keys
-                       (name, key_hash, prefix, key_type, scopes, rate_limit_rpm, expires_at)
-                   VALUES (%s, %s, %s, %s, %s::jsonb, %s, %s)
+                       (namespace, name, key_hash, prefix, key_type, scopes, rate_limit_rpm, expires_at)
+                   VALUES (%s, %s, %s, %s, %s, %s::jsonb, %s, %s)
                    RETURNING id, created_at""",
                 (
+                    ns,
                     req.name,
                     key_hash,
                     prefix,
@@ -1251,11 +1679,14 @@ async def revoke_api_key(
     pool = _get_db_pool()
     if pool is None:
         return {"error": "API key management requires a Postgres backend"}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
-                "UPDATE amfs_api_keys SET active = FALSE WHERE id = %s::uuid RETURNING id, name",
-                (key_id,),
+                """UPDATE amfs_api_keys SET active = FALSE
+                   WHERE id = %s::uuid AND namespace = %s
+                   RETURNING id, name""",
+                (key_id, ns),
             )
             row = cur.fetchone()
     if row is None:
@@ -1283,8 +1714,9 @@ async def list_audit_log(
     if pool is None:
         return {"entries": []}
 
-    conditions = ["1=1"]
-    params: list[Any] = []
+    ns = _get_namespace()
+    conditions = ["namespace = %s"]
+    params: list[Any] = [ns]
 
     if action is not None and action != "all":
         conditions.append("action = %s")
@@ -1370,6 +1802,7 @@ async def list_teams(
     pool = _get_db_pool()
     if pool is None:
         return {"teams": []}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
@@ -1377,9 +1810,12 @@ async def list_teams(
                           t.created_at, t.updated_at,
                           COUNT(m.id) AS member_count
                    FROM amfs_teams t
-                   LEFT JOIN amfs_team_members m ON m.team_id = t.id
+                   LEFT JOIN amfs_team_members m
+                       ON m.team_id = t.id AND m.removed_at IS NULL
+                   WHERE t.namespace = %s
                    GROUP BY t.id
-                   ORDER BY t.created_at DESC"""
+                   ORDER BY t.created_at DESC""",
+                (ns,),
             )
             rows = cur.fetchall()
     return {
@@ -1407,13 +1843,14 @@ async def create_team(
     pool = _get_db_pool()
     if pool is None:
         return {"error": "Team management requires a Postgres backend"}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
-                """INSERT INTO amfs_teams (name, slug, description)
-                   VALUES (%s, %s, %s)
+                """INSERT INTO amfs_teams (namespace, name, slug, description)
+                   VALUES (%s, %s, %s, %s)
                    RETURNING id, created_at, updated_at""",
-                (req.name, req.slug, req.description),
+                (ns, req.name, req.slug, req.description),
             )
             row = cur.fetchone()
     _audit_log(
@@ -1455,13 +1892,14 @@ async def update_team(
         return {"error": "No fields to update"}
 
     updates.append("updated_at = NOW()")
-    params.append(team_id)
+    ns = _get_namespace()
+    params.extend([team_id, ns])
 
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
                 f"""UPDATE amfs_teams SET {', '.join(updates)}
-                    WHERE id = %s::uuid
+                    WHERE id = %s::uuid AND namespace = %s
                     RETURNING id, name, slug, description, created_at, updated_at""",
                 params,
             )
@@ -1493,11 +1931,14 @@ async def delete_team(
     pool = _get_db_pool()
     if pool is None:
         return {"error": "Team management requires a Postgres backend"}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
-                "DELETE FROM amfs_teams WHERE id = %s::uuid RETURNING id, slug",
-                (team_id,),
+                """DELETE FROM amfs_teams
+                   WHERE id = %s::uuid AND namespace = %s
+                   RETURNING id, slug""",
+                (team_id, ns),
             )
             row = cur.fetchone()
     if row is None:
@@ -1518,21 +1959,36 @@ async def delete_team(
 @app.get("/api/v1/admin/teams/{team_id}/members")
 async def list_team_members(
     team_id: str,
+    include_removed: bool = Query(False),
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     pool = _get_db_pool()
     if pool is None:
         return {"members": []}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
-            cur.execute(
-                """SELECT id, email, display_name, role,
-                          invited_at, accepted_at, created_at
-                   FROM amfs_team_members
-                   WHERE team_id = %s::uuid
-                   ORDER BY created_at""",
-                (team_id,),
-            )
+            if include_removed:
+                cur.execute(
+                    """SELECT id, email, display_name, role,
+                              invited_at, accepted_at, created_at,
+                              removed_at, removed_by
+                       FROM amfs_team_members
+                       WHERE team_id = %s::uuid AND namespace = %s
+                       ORDER BY created_at""",
+                    (team_id, ns),
+                )
+            else:
+                cur.execute(
+                    """SELECT id, email, display_name, role,
+                              invited_at, accepted_at, created_at,
+                              removed_at, removed_by
+                       FROM amfs_team_members
+                       WHERE team_id = %s::uuid AND namespace = %s
+                         AND removed_at IS NULL
+                       ORDER BY created_at""",
+                    (team_id, ns),
+                )
             rows = cur.fetchall()
     return {
         "members": [
@@ -1544,6 +2000,8 @@ async def list_team_members(
                 "invitedAt": row["invited_at"].isoformat(),
                 "acceptedAt": row["accepted_at"].isoformat() if row["accepted_at"] else None,
                 "createdAt": row["created_at"].isoformat(),
+                "removedAt": row["removed_at"].isoformat() if row.get("removed_at") else None,
+                "removedBy": row.get("removed_by"),
             }
             for row in rows
         ]
@@ -1560,15 +2018,36 @@ async def add_team_member(
     pool = _get_db_pool()
     if pool is None:
         return {"error": "Team management requires a Postgres backend"}
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
+            # If this email was previously removed from this team, reinstate instead of duplicating
             cur.execute(
-                """INSERT INTO amfs_team_members (team_id, email, display_name, role)
-                   VALUES (%s::uuid, %s, %s, %s)
-                   RETURNING id, invited_at, created_at""",
-                (team_id, req.email, req.display_name, req.role),
+                """SELECT id FROM amfs_team_members
+                   WHERE team_id = %s::uuid AND email = %s AND namespace = %s
+                     AND removed_at IS NOT NULL""",
+                (team_id, req.email, ns),
             )
-            row = cur.fetchone()
+            existing_removed = cur.fetchone()
+            if existing_removed:
+                cur.execute(
+                    """UPDATE amfs_team_members
+                       SET removed_at = NULL, removed_by = NULL,
+                           role = %s, display_name = %s
+                       WHERE id = %s::uuid
+                       RETURNING id, invited_at, created_at""",
+                    (req.role, req.display_name, existing_removed["id"]),
+                )
+                row = cur.fetchone()
+            else:
+                cur.execute(
+                    """INSERT INTO amfs_team_members
+                       (namespace, team_id, email, display_name, role)
+                       VALUES (%s, %s::uuid, %s, %s, %s)
+                       RETURNING id, invited_at, created_at""",
+                    (ns, team_id, req.email, req.display_name, req.role),
+                )
+                row = cur.fetchone()
     _audit_log(
         "team.member.add",
         resource=f"{team_id}/{req.email}",
@@ -1609,13 +2088,14 @@ async def update_team_member(
     if not updates:
         return {"error": "No fields to update"}
 
-    params.extend([member_id, team_id])
+    ns = _get_namespace()
+    params.extend([member_id, team_id, ns])
 
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
                 f"""UPDATE amfs_team_members SET {', '.join(updates)}
-                    WHERE id = %s::uuid AND team_id = %s::uuid
+                    WHERE id = %s::uuid AND team_id = %s::uuid AND namespace = %s
                     RETURNING id, email, display_name, role, invited_at, accepted_at, created_at""",
                 params,
             )
@@ -1649,13 +2129,17 @@ async def remove_team_member(
     pool = _get_db_pool()
     if pool is None:
         return {"error": "Team management requires a Postgres backend"}
+    removed_by = request.headers.get("X-AMFS-Dashboard-Actor", "api")
+    ns = _get_namespace()
     with pool.connection() as conn:
         with conn.cursor() as cur:
             cur.execute(
-                """DELETE FROM amfs_team_members
+                """UPDATE amfs_team_members
+                   SET removed_at = NOW(), removed_by = %s
                    WHERE id = %s::uuid AND team_id = %s::uuid
+                     AND namespace = %s AND removed_at IS NULL
                    RETURNING id, email""",
-                (member_id, team_id),
+                (removed_by, member_id, team_id, ns),
             )
             row = cur.fetchone()
     if row is None:
@@ -1668,6 +2152,107 @@ async def remove_team_member(
     return {"deleted": str(row["id"])}
 
 
+@app.post("/api/v1/admin/teams/{team_id}/members/{member_id}/reinstate")
+async def reinstate_team_member(
+    team_id: str,
+    member_id: str,
+    request: Request,
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Re-activate a previously removed team member."""
+    pool = _get_db_pool()
+    if pool is None:
+        return {"error": "Team management requires a Postgres backend"}
+    ns = _get_namespace()
+    with pool.connection() as conn:
+        with conn.cursor() as cur:
+            cur.execute(
+                """UPDATE amfs_team_members
+                   SET removed_at = NULL, removed_by = NULL
+                   WHERE id = %s::uuid AND team_id = %s::uuid
+                     AND namespace = %s AND removed_at IS NOT NULL
+                   RETURNING id, email, display_name, role,
+                             invited_at, accepted_at, created_at""",
+                (member_id, team_id, ns),
+            )
+            row = cur.fetchone()
+    if row is None:
+        return {"error": "Removed member not found"}
+    _audit_log(
+        "team.member.reinstate",
+        resource=f"{team_id}/{row['email']}",
+        ip_address=request.client.host if request.client else None,
+    )
+    return {
+        "id": str(row["id"]),
+        "email": row["email"],
+        "displayName": row["display_name"],
+        "role": row["role"],
+        "invitedAt": row["invited_at"].isoformat(),
+        "acceptedAt": row["accepted_at"].isoformat() if row["accepted_at"] else None,
+        "createdAt": row["created_at"].isoformat(),
+        "reinstated": True,
+    }
+
+
+@app.get("/api/v1/admin/members/check-email")
+async def check_member_email(
+    email: str = Query(...),
+    _auth: str | None = Depends(verify_api_key),
+) -> dict[str, Any]:
+    """Check if an email is associated with any active or removed team memberships.
+
+    Called by the dashboard OAuth flow to determine if a returning user
+    should be blocked (removed) or allowed through.
+
+    Returns status: "active", "removed", or "not_found".
+    """
+    pool = _get_db_pool()
+    if pool is None:
+        return {"email": email, "status": "unknown", "memberships": []}
+    ns = _get_namespace()
+    with pool.connection() as conn:
+        with conn.cursor() as cur:
+            cur.execute(
+                """SELECT m.id, m.team_id, t.name AS team_name, m.role,
+                          m.removed_at, m.removed_by,
+                          m.created_at, m.accepted_at
+                   FROM amfs_team_members m
+                   JOIN amfs_teams t ON t.id = m.team_id
+                   WHERE m.email = %s AND m.namespace = %s
+                   ORDER BY m.removed_at NULLS FIRST""",
+                (email, ns),
+            )
+            rows = cur.fetchall()
+    if not rows:
+        return {"email": email, "status": "not_found", "memberships": []}
+    active = [r for r in rows if r["removed_at"] is None]
+    removed = [r for r in rows if r["removed_at"] is not None]
+    if active:
+        status = "active"
+    elif removed:
+        status = "removed"
+    else:
+        status = "not_found"
+    return {
+        "email": email,
+        "status": status,
+        "memberships": [
+            {
+                "id": str(r["id"]),
+                "teamId": str(r["team_id"]),
+                "teamName": r["team_name"],
+                "role": r["role"],
+                "removedAt": r["removed_at"].isoformat() if r["removed_at"] else None,
+                "removedBy": r["removed_by"],
+                "createdAt": r["created_at"].isoformat(),
+                "acceptedAt": r["accepted_at"].isoformat() if r["accepted_at"] else None,
+            }
+            for r in rows
+        ],
+    }
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Admin — Pattern Detection (Pro)
 # ──────────────────────────────────────────────────────────────────────
@@ -1676,36 +2261,50 @@ async def remove_team_member(
 @app.get("/api/v1/admin/patterns")
 async def list_detected_patterns(
     pattern_type: str | None = Query(None),
+    category: str | None = Query(None),
     severity: str | None = Query(None),
     resolved: bool | None = Query(None),
+    agent_id: str | None = Query(None),
     limit: int = Query(100),
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """List previously detected patterns from the database."""
+    from amfs_patterns.detector import PATTERN_CATEGORIES, PATTERN_METADATA
+
     pool = _get_db_pool()
     if pool is None:
-        return {"patterns": []}
+        return {"patterns": [], "categories": PATTERN_CATEGORIES, "metadata": PATTERN_METADATA}
 
-    conditions = ["1=1"]
-    params: list[Any] = []
+    ns = _get_namespace()
+    conditions = ["namespace = %s"]
+    params: list[Any] = [ns]
 
     if pattern_type is not None:
         conditions.append("pattern_type = %s")
         params.append(pattern_type)
+    if category is not None:
+        conditions.append("category = %s")
+        params.append(category)
     if severity is not None:
         conditions.append("severity = %s")
         params.append(severity)
     if resolved is not None:
         conditions.append("resolved = %s")
         params.append(resolved)
+    if agent_id is not None:
+        conditions.append("(details->>'agent' = %s OR details->>'agent_a' = %s OR details->>'agent_b' = %s)")
+        params.extend([agent_id, agent_id, agent_id])
 
     where = " AND ".join(conditions)
     sql = f"""
         SELECT id, pattern_type, severity, entity_path, description,
-               details, resolved, detected_at, resolved_at
+               details, resolved, detected_at, resolved_at,
+               COALESCE(category, 'collaboration') as category
         FROM amfs_detected_patterns
         WHERE {where}
-        ORDER BY detected_at DESC
+        ORDER BY
+            CASE severity WHEN 'critical' THEN 0 WHEN 'warning' THEN 1 ELSE 2 END,
+            detected_at DESC
         LIMIT %s
     """
     params.append(limit)
@@ -1721,6 +2320,7 @@ async def list_detected_patterns(
                 "id": str(row["id"]),
                 "patternType": row["pattern_type"],
                 "severity": row["severity"],
+                "category": row["category"],
                 "entityPath": row["entity_path"],
                 "description": row["description"],
                 "details": row["details"] or {},
@@ -1729,7 +2329,9 @@ async def list_detected_patterns(
                 "resolvedAt": row["resolved_at"].isoformat() if row["resolved_at"] else None,
             }
             for row in rows
-        ]
+        ],
+        "categories": PATTERN_CATEGORIES,
+        "metadata": PATTERN_METADATA,
     }
 
 
@@ -1739,9 +2341,10 @@ async def run_pattern_scan(
     request: Request,
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
-    """Run the pattern detector and persist results."""
+    """Run the collaboration-aware pattern detector and persist results."""
     try:
         from amfs_patterns import PatternDetector
+        from amfs_patterns.detector import PATTERN_CATEGORIES, PATTERN_METADATA
     except ImportError:
         return {"error": "amfs-patterns package not installed"}
 
@@ -1749,28 +2352,50 @@ async def run_pattern_scan(
     entries = mem.list(req.entity_path)
     outcomes = mem._adapter.list_outcomes(entity_path=req.entity_path, limit=10000)
 
+    if req.agent_id:
+        entries = [e for e in entries if e.provenance.agent_id == req.agent_id]
+
+    branches: list[Any] = []
+    pull_requests: list[Any] = []
+    try:
+        branches = mem.list_branches()  # type: ignore[attr-defined]
+    except (AttributeError, Exception):
+        pass
+    try:
+        pull_requests = mem.list_pull_requests()  # type: ignore[attr-defined]
+    except (AttributeError, Exception):
+        pass
+
     detector = PatternDetector(
-        incident_threshold=req.incident_threshold,
         stale_days=req.stale_days,
-        hot_entity_stddev=req.hot_entity_stddev,
-        drift_stddev=req.drift_stddev,
+        orphan_days=req.orphan_days,
+        pr_stale_days=req.pr_stale_days,
+        similarity_threshold=req.similarity_threshold,
+        incident_threshold=req.incident_threshold,
+    )
+    report = detector.analyze(
+        entries,
+        outcome_data=outcomes,
+        branches=branches,
+        pull_requests=pull_requests,
     )
-    report = detector.analyze(entries, outcome_data=outcomes)
 
     pool = _get_db_pool()
     persisted = 0
     if pool is not None:
         with pool.connection() as conn:
             with conn.cursor() as cur:
+                cur.execute("DELETE FROM amfs_detected_patterns WHERE resolved = FALSE")
                 for p in report.patterns:
                     cur.execute(
                         """INSERT INTO amfs_detected_patterns
-                               (pattern_type, severity, entity_path, description,
-                                details, detected_at)
-                           VALUES (%s, %s, %s, %s, %s::jsonb, %s)""",
+                               (pattern_type, severity, category, entity_path,
+                                description, details, detected_at)
+                           VALUES (%s, %s, %s, %s, %s, %s::jsonb, %s)""",
                         (
                             p.pattern_type,
                             p.severity,
+                            p.category,
                             p.entity_path,
                             p.description,
                             json.dumps(p.details, default=str),
@@ -1795,6 +2420,7 @@ async def run_pattern_scan(
             {
                 "patternType": p.pattern_type,
                 "severity": p.severity,
+                "category": p.category,
                 "entityPath": p.entity_path,
                 "description": p.description,
                 "details": p.details,
@@ -1802,6 +2428,8 @@ async def run_pattern_scan(
             }
             for p in report.patterns
         ],
+        "categories": PATTERN_CATEGORIES,
+        "metadata": PATTERN_METADATA,
     }
 
 
@@ -1851,8 +2479,6 @@ async def graph_neighbors(
     _auth: str | None = Depends(verify_api_key),
 ) -> dict[str, Any]:
     """Traverse the knowledge graph from an entity."""
-    from fastapi.responses import JSONResponse
-
     mem = _get_memory()
     try:
         edges = mem.graph_neighbors(
@@ -1878,6 +2504,7 @@ async def graph_neighbors(
 
 @app.get("/api/v1/pro/graph/expertise")
 async def expertise_graph(
+    agent_id: str | None = Query(None),
     limit_agents: int = Query(30, ge=1, le=200),
     limit_entities: int = Query(30, ge=1, le=200),
     _auth: str | None = Depends(verify_api_key),
@@ -1885,7 +2512,8 @@ async def expertise_graph(
     """Build an agent×entity expertise heatmap.
 
     Returns a list of agents, entities, and cells with scores derived
-    from write counts. The dashboard renders this as a heatmap table.
+    from write counts. When ``agent_id`` is provided, results are scoped
+    to that single agent.
     """
     mem = _get_memory()
     entries = mem.list()
@@ -1896,6 +2524,8 @@ async def expertise_graph(
 
     for e in entries:
         aid = e.provenance.agent_id
+        if agent_id and aid != agent_id:
+            continue
         ep = e.entity_path
         agent_totals[aid] = agent_totals.get(aid, 0) + 1
         entity_totals[ep] = entity_totals.get(ep, 0) + 1
@@ -1949,11 +2579,12 @@ async def graph_backfill(
     outcome causal chains → 'informed' + 'read' edges,
     agent writes → 'wrote' edges.
     """
-    from amfs_core.models import GraphEdge
-
     mem = _get_memory()
     entries = mem.list()
-    outcomes = mem._adapter.list_outcomes(namespace=mem.namespace) if hasattr(mem._adapter, "list_outcomes") else []
+    try:
+        outcomes = mem._adapter.list_outcomes() if hasattr(mem._adapter, "list_outcomes") else []
+    except Exception:
+        outcomes = []
 
     created = 0
     errors = 0