feat(backend): MCP d'édition de templates (#81)

Ajoute le MCP dédié à l'édition de templates : catalogue et classification
des templates (mcp/templates.rs infrastructure + app-tauri), use cases et
provider (application/template), enforcement de la policy des tools (mod.rs,
server.rs, tools.rs), avec la parité côté chemin OpenAI-compatible
(openai_tools.rs x2).

Lots B1 (catalogue/classification), B2 (use cases/provider) et B3
(enforcement policy) livrés en un seul commit cohérent.

QA vert (seul l'échec de bind loopback #80, connu et non-régression, écarté).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

crates/infrastructure/src/orchestrator/mcp/server.rs

@@ -33,6 +33,7 @@ use super::jsonrpc::{
     JSONRPC_VERSION,
 };
 use super::policy::ToolPolicyRegistry;
+use super::templates::TemplateToolProvider;
 use super::tickets::TicketToolProvider;
 use super::tools::{self, ToolMapError};
 
@@ -70,6 +71,9 @@ pub struct McpServer {
     /// Optional public ticket provider. The MCP surface says `ticket`; the
     /// provider maps those calls to application/domain `Issue` use cases.
     ticket_tools: Option<Arc<dyn TicketToolProvider>>,
+    /// Optional public template provider. The MCP surface says `template`; the
+    /// provider maps those calls to application/domain `Template` use cases.
+    template_tools: Option<Arc<dyn TemplateToolProvider>>,
     /// Optional per-requester MCP tool policy registry for constrained sessions.
     tool_policies: Option<Arc<ToolPolicyRegistry>>,
     /// Optional durable MCP tool permission store. When wired, absence of project or
@@ -90,6 +94,7 @@ impl McpServer {
             requester: String::new(),
             ready_sink: None,
             ticket_tools: None,
+            template_tools: None,
             tool_policies: None,
             mcp_tool_permissions: None,
         }
@@ -123,6 +128,13 @@ impl McpServer {
         self
     }
 
+    /// Attaches the public template tool provider.
+    #[must_use]
+    pub fn with_template_tools(mut self, template_tools: Arc<dyn TemplateToolProvider>) -> Self {
+        self.template_tools = Some(template_tools);
+        self
+    }
+
     /// Attaches the requester-scoped MCP tool policy registry.
     #[must_use]
     pub fn with_tool_policies(mut self, tool_policies: Arc<ToolPolicyRegistry>) -> Self {
@@ -157,6 +169,7 @@ impl McpServer {
             requester: requester.into(),
             ready_sink: self.ready_sink.clone(),
             ticket_tools: self.ticket_tools.clone(),
+            template_tools: self.template_tools.clone(),
             tool_policies: self.tool_policies.clone(),
             mcp_tool_permissions: self.mcp_tool_permissions.clone(),
         }
@@ -507,6 +520,44 @@ impl McpServer {
             };
         }
 
+        if tools::is_template_tool(&name) {
+            let result = match &self.template_tools {
+                Some(provider) => {
+                    provider
+                        .handle_template_tool(&self.project, &self.requester, &name, arguments)
+                        .await
+                }
+                None => Err(super::templates::TemplateToolError::new(
+                    "notConfigured",
+                    "template tools are not configured",
+                )),
+            };
+            self.publish_processed(&name, result.is_ok());
+            return match result {
+                Ok(value) => {
+                    let text = serde_json::to_string(&value).unwrap_or_else(|_| "null".to_owned());
+                    application::diag!(
+                        "[mcp] tools_call end tool={name} requester={requester_label} \
+                         target={arg_target} ok=true is_error=false result_len={} elapsed_ms={}",
+                        text.len(),
+                        started.elapsed().as_millis(),
+                    );
+                    Ok(tool_result_text(&text, false))
+                }
+                Err(err) => {
+                    let text =
+                        serde_json::to_string(&err.to_value()).unwrap_or_else(|_| err.to_string());
+                    application::diag!(
+                        "[mcp] tools_call end tool={name} requester={requester_label} \
+                         target={arg_target} ok=false is_error=true result_len={} elapsed_ms={}",
+                        text.len(),
+                        started.elapsed().as_millis(),
+                    );
+                    Ok(tool_result_text(&text, true))
+                }
+            };
+        }
+
         // The handshake-provided requester is still passed to the mapper for tools that
         // need peer identity.
         let command = match tools::map_tool_call(&name, &arguments, &self.requester) {