feat: exposition outils mutants Phase 2 + câblage par phase (v0.12.0)

registry.listAllTools expose les outils mutants (contrôle délégué au
gatekeeper). Prompt système phase-aware. index.ts branche Phase 1
(read-only + ReadOnlyGuard) ou Phase 2 (tous outils + GatekeeperGuard sur
table assets, alerte sur tentative bloquée). Build + 35 tests verts.

Palier de risque : privilégié (active la capacité d'écriture) — gardé
derrière CHLOVA_PHASE=2 + gatekeeper ; aucune mutation réelle sans review.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

orchestrator/src/mcp/registry.ts

@@ -2,7 +2,10 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { Logger } from "pino";
 import type { ToolHandle, ToolSpec } from "../agent/types.js";
-import { isReadOnly, resolveRiskTier } from "./readonly-filter.js";
+import { isReadOnly, resolveRiskTier, type McpToolLike } from "./readonly-filter.js";
+
+/** Forme d'un outil telle que renvoyée par listTools (sous-ensemble utilisé). */
+type McpTool = McpToolLike & { description?: string; inputSchema?: unknown };
 
 /**
  * Registry MCP : connecte les serveurs MCP configurés (n8n, Portainer), liste
@@ -43,22 +46,48 @@ export class McpRegistry {
   }
 
   /**
-   * Liste les outils LECTURE SEULE de tous les serveurs, sous forme de
-   * ToolHandle exécutables. Les outils non read-only sont écartés ET journalisés.
+   * Liste les outils LECTURE SEULE de tous les serveurs (Phase 1).
+   * Les outils non read-only sont écartés ET journalisés.
    */
   async listReadOnlyTools(): Promise<ToolHandle[]> {
-    const handles: ToolHandle[] = [];
+    const handles = await this.collect((tool, srv) => {
+      if (!isReadOnly(tool)) {
+        this.logger.debug(
+          { server: srv, tool: tool.name },
+          "outil non read-only écarté (Phase 1)",
+        );
+        return false;
+      }
+      return true;
+    });
+    this.logger.info({ count: handles.length }, "outils read-only exposés");
+    return handles;
+  }
 
+  /**
+   * Liste TOUS les outils (lecture seule + mutants) sous forme de ToolHandle
+   * (Phase 2). Le contrôle d'exécution est délégué au Gatekeeper via le Guard :
+   * les outils mutants sont exposés mais ne s'exécutent qu'après review.
+   */
+  async listAllTools(): Promise<ToolHandle[]> {
+    const handles = await this.collect(() => true);
+    const writable = handles.filter((h) => h.spec.riskTier === "privileged").length;
+    this.logger.info(
+      { count: handles.length, privileged: writable },
+      "outils exposés (Phase 2, mutants sous gatekeeper)",
+    );
+    return handles;
+  }
+
+  /** Construit les ToolHandle des serveurs, en gardant ceux qui passent `keep`. */
+  private async collect(
+    keep: (tool: McpTool, server: string) => boolean,
+  ): Promise<ToolHandle[]> {
+    const handles: ToolHandle[] = [];
     for (const srv of this.servers) {
       const { tools } = await srv.client.listTools();
       for (const tool of tools) {
-        if (!isReadOnly(tool)) {
-          this.logger.debug(
-            { server: srv.name, tool: tool.name },
-            "outil non read-only écarté (Phase 1)",
-          );
-          continue;
-        }
+        if (!keep(tool, srv.name)) continue;
 
         const spec: ToolSpec = {
           name: `${srv.name}.${tool.name}`,
@@ -68,7 +97,7 @@ export class McpRegistry {
             properties: {},
           },
           server: srv.name,
-          readOnly: true,
+          readOnly: isReadOnly(tool),
           riskTier: resolveRiskTier(tool),
         };
 
@@ -83,8 +112,6 @@ export class McpRegistry {
         });
       }
     }
-
-    this.logger.info({ count: handles.length }, "outils read-only exposés");
     return handles;
   }