feat(fusion): serveur MCP complété (ACC-5.1) + pont MCP ObsiGate (ACC-2.2) — 7.83.0

ACC-5.1 (#24) — app/routers/mcp_server.py : catalogue §7.2 complété
(list_projects, get_project, read_page tronqué proprement,
list_project_tasks), search_pages en plein texte, liens profonds +
kind sur chaque résultat, scopes du jeton appliqués (écriture
refusée -32002 sans scope write) et journalisation §7.4 de chaque
tools/call dans api_audit_log (clés d'arguments seulement).

ACC-2.2 (#20) — pont MCP Flowdeck → ObsiGate, côté client :
- mcp_client : serveurs à session (capture/réémission de
  Mcp-Session-Id, handshake avant tools/call), décodage SSE
  multi-messages par id de réponse, classification des outils à la
  découverte (readOnlyHint sinon heuristique ; lecture par défaut).
- preset connecteur « obsigate » (URL dérivée dev/prod), kinds MCP
  factorisés (connectors.MCP_KINDS), option dans le panneau agent.
- garde-fou n° 2 : permission_manager.is_write_tool couvre les
  outils MCP écrivants → portes politique d'approbation
  (agent_engine) et rôles (assert_can) ; McpTool bloque tout
  apply_* distant (patron §7.5).

Tests : test_fusion_mcp_server 18, nouveau test_fusion_pont_obsigate
7 (faux serveur ObsiGate à session stricte via le vrai _rpc).
Preuve réelle T0-T5 : attend la clé ObsiGate dédiée (1 vault) et
Q-A/Q-B côté Bruno.

tests/test_fusion_mcp_server.py

@@ -70,8 +70,9 @@ def test_mcp_handshake_et_outils(client, jeton):
     noms = [t["name"] for t in r.json()["result"]["tools"]]
     assert noms == ["list_workspaces", "get_workspace",
                     "list_collections", "get_collection", "get_page",
-                    "search_pages", "list_repos", "create_page",
-                    "update_page", "create_collection"]
+                    "search_pages", "list_repos", "list_projects",
+                    "get_project", "read_page", "list_project_tasks",
+                    "create_page", "update_page", "create_collection"]
 
 
 def test_mcp_workspaces(client, jeton):
@@ -107,7 +108,13 @@ def test_mcp_collections_et_pages(client, jeton, donnees):
     assert titres == ["Page de cadrage", "Revue hebdo"]
     assert detail["pages"][0]["properties"] == {"statut": "en cours"}
     res = _appel(client, jeton, 3, "search_pages", {"query": "cadrage"})
-    assert [p["title"] for p in res] == ["Page de cadrage"]
+    # ACC-5.1 : la recherche est plein texte et couvre aussi les pages
+    # classiques — on vérifie la ligne de collection, sa famille et son
+    # URL profonde (§7.2 : l'URL est systématique).
+    lignes = [p for p in res if p["kind"] == "collection_page"]
+    assert [p["title"] for p in lignes] == ["Page de cadrage"]
+    assert all(p["url"].endswith(f"/collections/{donnees}") for p in lignes)
+    assert all("url" in p and "kind" in p for p in res)
     res = _appel(client, jeton, 4, "get_collection", {"id": 99999})
     assert "introuvable" in res["erreur"]
 
@@ -237,3 +244,160 @@ def test_mcp_info_get(client, jeton):
     assert "create_page" in infos["tools"]
     assert "update_page" in infos["tools"]
     assert "create_collection" in infos["tools"]
+    # ACC-5.1 : le catalogue distingue lectures et écritures.
+    assert "list_projects" in infos["read_tools"]
+    assert "read_page" in infos["read_tools"]
+    assert infos["write_tools"] == ["create_page", "update_page",
+                                     "create_collection"]
+
+
+# ── ACC-5.1 : catalogue de lecture §7.2 ────────────────────────────────────
+
+
+@pytest.fixture()
+def projet_taches(client):
+    """Un workspace + une base de tâches configurée (mapping complet)."""
+    with get_conn() as conn:
+        conn.execute("INSERT OR IGNORE INTO users (id, login) VALUES (1, 'tester')")
+        cur = conn.execute(
+            "INSERT INTO workspaces (name, owner_id) VALUES ('Atelier MCP', 1)")
+        wid = cur.lastrowid
+        cur = conn.execute(
+            "INSERT INTO collections (name, description, icon, workspace_id, is_task) "
+            "VALUES ('Suivi projet', 'Base de tâches', '🗂️', ?, 1)", (wid,))
+        cid = cur.lastrowid
+        props = {}
+        for nom, typ, opts in (
+                ("Assigné à", "person", "[]"),
+                ("Statut", "status", json.dumps(
+                    [{"name": "À faire"}, {"name": "Terminé"}])),
+                ("Échéance", "date", "[]")):
+            cur = conn.execute(
+                "INSERT INTO collection_properties "
+                "(collection_id, name, prop_type, options_json) VALUES (?, ?, ?, ?)",
+                (cid, nom, typ, opts))
+            props[nom] = cur.lastrowid
+        conn.execute(
+            "UPDATE collections SET task_assignee_prop=?, task_status_prop=?, "
+            "task_due_prop=? WHERE id=?",
+            (props["Assigné à"], props["Statut"], props["Échéance"], cid))
+        conn.execute(
+            "INSERT INTO collection_pages (collection_id, title, icon, position, "
+            "property_values_json) VALUES (?, 'Relire le pont MCP', 'file', 1, ?)",
+            (cid, json.dumps({str(props["Statut"]): "À faire",
+                              str(props["Échéance"]): "2026-10-30"})))
+        conn.execute(
+            "INSERT INTO collection_pages (collection_id, title, icon, position, "
+            "property_values_json) VALUES (?, 'Brancher ObsiGate', 'file', 2, ?)",
+            (cid, json.dumps({str(props["Statut"]): "Terminé"})))
+        conn.commit()
+    return {"workspace_id": wid, "collection_id": cid, "props": props}
+
+
+def test_mcp_projets_catalogue(client, jeton, donnees, projet_taches):
+    projets = _appel(client, jeton, 90, "list_projects")
+    alpha = [p for p in projets if p["title"] == "Projet Alpha"]
+    assert alpha and alpha[0]["id"] == donnees
+    assert alpha[0]["url"].endswith(f"/collections/{donnees}")
+    assert alpha[0]["page_count"] == 2
+    suivi = [p for p in projets if p["title"] == "Suivi projet"]
+    assert suivi and suivi[0]["is_task"] is True
+
+    detail = _appel(client, jeton, 91, "get_project", {"id": donnees})
+    assert detail["project"]["title"] == "Projet Alpha"
+    assert detail["project"]["url"].endswith(f"/collections/{donnees}")
+    # Détail sans contenu complet : titres seulement.
+    assert [p["title"] for p in detail["pages"]] == ["Page de cadrage",
+                                                     "Revue hebdo"]
+    assert all(set(p) == {"id", "title"} for p in detail["pages"])
+    res = _appel(client, jeton, 92, "get_project", {"id": 99999})
+    assert "introuvable" in res["erreur"]
+
+
+def test_mcp_list_project_tasks(client, jeton, projet_taches):
+    cid = projet_taches["collection_id"]
+    taches = _appel(client, jeton, 93, "list_project_tasks",
+                    {"project_id": cid})
+    assert [t["title"] for t in taches] == ["Relire le pont MCP",
+                                            "Brancher ObsiGate"]
+    assert taches[0]["status"] == "À faire" and taches[0]["done"] is False
+    assert taches[0]["due"] == "2026-10-30"
+    assert taches[1]["done"] is True
+    assert taches[0]["url"].endswith(f"/collections/{cid}")
+    toutes = _appel(client, jeton, 94, "list_project_tasks")
+    assert {t["title"] for t in toutes} >= {"Relire le pont MCP"}
+    res = _appel(client, jeton, 95, "list_project_tasks",
+                 {"project_id": 99999})
+    assert "introuvable" in res["erreur"]
+
+
+def test_mcp_read_page_classique_et_troncature(client, jeton, projet_taches):
+    long_contenu = "mot " * 6000  # 24 000 caractères > borne 20 000
+    with get_conn() as conn:
+        cur = conn.execute(
+            "INSERT INTO pages (workspace, workspace_id, title, content, "
+            "parent_section) VALUES ('Atelier MCP', ?, 'Grande note', ?, 'Private')",
+            (projet_taches["workspace_id"], long_contenu))
+        pid = cur.lastrowid
+        conn.commit()
+    res = _appel(client, jeton, 96, "read_page", {"id": pid})
+    assert res["kind"] == "page" and res["title"] == "Grande note"
+    assert res["truncated"] is True and len(res["content"]) <= 20000
+    assert res["url"].endswith(f"/pages/{pid}")
+    res = _appel(client, jeton, 97, "read_page", {"id": 99999, "kind": "page"})
+    assert "introuvable" in res["erreur"]
+
+
+def test_mcp_read_page_ligne_de_collection(client, jeton, donnees):
+    with get_conn() as conn:
+        ligne = conn.execute(
+            "SELECT id FROM collection_pages WHERE collection_id=? AND "
+            "title='Page de cadrage'", (donnees,)).fetchone()["id"]
+        conn.execute(
+            "INSERT INTO pages (workspace, title, content, collection_row_id) "
+            "VALUES ('', 'contenu', 'Le contenu porté de la ligne', ?)",
+            (ligne,))
+        conn.commit()
+    res = _appel(client, jeton, 98, "read_page",
+                 {"id": ligne, "kind": "collection_page"})
+    assert res["kind"] == "collection_page"
+    assert res["content"] == "Le contenu porté de la ligne"
+    assert res["truncated"] is False
+    assert res["properties"] == {"statut": "en cours"}
+
+
+def test_mcp_jeton_lecture_seule_refuse_les_ecritures(client, jeton, donnees):
+    """§7.4 : un jeton au scope « read » (pont de lecture) ne peut pas
+    écrire via MCP, mais il peut toujours lire."""
+    lecture = "fd_token_lecture_seule"
+    with get_conn() as conn:
+        conn.execute(
+            "INSERT INTO api_tokens (user_id, name, token_hash, token_prefix, "
+            "revoked, scopes) VALUES (1, 'pont-lecture', ?, ?, 0, 'read')",
+            (hashlib.sha256(lecture.encode()).hexdigest(), lecture[:12]))
+        conn.commit()
+    cols = _appel(client, lecture, 100, "list_projects")
+    assert any(c["title"] == "Projet Alpha" for c in cols)
+    r = _rpc(client, lecture, 101, "tools/call",
+             {"name": "create_page",
+              "arguments": {"collection_id": donnees, "title": "Interdite"}})
+    assert r.status_code == 200
+    erreur = r.json()["error"]
+    assert erreur["code"] == -32002 and "lecture seule" in erreur["message"]
+    with get_conn() as conn:
+        n = conn.execute(
+            "SELECT COUNT(*) FROM collection_pages WHERE title='Interdite'"
+        ).fetchone()[0]
+    assert n == 0
+
+
+def test_mcp_journalisation_des_appels(client, jeton, donnees):
+    """§7.4 : chaque tools/call laisse une trace dans api_audit_log."""
+    _appel(client, jeton, 110, "list_projects")
+    with get_conn() as conn:
+        rows = conn.execute(
+            "SELECT action, user_id, token_id, detail FROM api_audit_log "
+            "WHERE action='mcp:list_projects'").fetchall()
+    assert rows, "aucune ligne d'audit pour l'appel MCP"
+    assert rows[-1]["user_id"] == 1 and rows[-1]["token_id"] is not None
+    assert "statut=ok" in rows[-1]["detail"]