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/app-tauri/src/lib.rs

@@ -25,6 +25,7 @@ pub mod pty;
 pub mod server;
 pub mod state;
 pub mod stream;
+pub mod templates;
 pub mod tickets;
 
 use std::process::ExitCode;

crates/app-tauri/src/openai_tools.rs

@@ -14,7 +14,7 @@ use domain::ports::{
     ToolSpec,
 };
 use domain::{AgentId, AgentToolPolicy, IssueRef, McpToolPolicy, Project};
-use infrastructure::TicketToolProvider;
+use infrastructure::{TemplateToolProvider, TicketToolProvider};
 use serde_json::Value;
 
 const PROJECT_ROOT_ARG: &str = "__ideaProjectRoot";
@@ -27,6 +27,7 @@ pub struct AppOpenAiToolInvoker {
     policies: Arc<dyn AgentToolPolicyStore>,
     mcp_tool_permissions: Arc<dyn McpToolPermissionStore>,
     ticket_tools: Arc<dyn TicketToolProvider>,
+    template_tools: Arc<dyn TemplateToolProvider>,
 }
 
 /// Proxy injecté avant que l'orchestrateur soit construit, puis lié dans la
@@ -83,6 +84,7 @@ impl AppOpenAiToolInvoker {
         policies: Arc<dyn AgentToolPolicyStore>,
         mcp_tool_permissions: Arc<dyn McpToolPermissionStore>,
         ticket_tools: Arc<dyn TicketToolProvider>,
+        template_tools: Arc<dyn TemplateToolProvider>,
     ) -> Self {
         Self {
             orchestrator,
@@ -90,6 +92,7 @@ impl AppOpenAiToolInvoker {
             policies,
             mcp_tool_permissions,
             ticket_tools,
+            template_tools,
         }
     }
 }
@@ -170,6 +173,19 @@ impl ToolInvoker for AppOpenAiToolInvoker {
             return serde_json::to_string(&value)
                 .map_err(|e| ToolInvocationError::Execution(format!("JSON ticket tool: {e}")));
         }
+        if infrastructure::orchestrator::mcp::tools::is_template_tool(name) {
+            let value = self
+                .template_tools
+                .handle_template_tool(&project, &requester, name, value)
+                .await
+                .map_err(|e| {
+                    let detail =
+                        serde_json::to_string(&e.to_value()).unwrap_or_else(|_| e.to_string());
+                    ToolInvocationError::Execution(detail)
+                })?;
+            return serde_json::to_string(&value)
+                .map_err(|e| ToolInvocationError::Execution(format!("JSON template tool: {e}")));
+        }
         let command = infrastructure::orchestrator::mcp::map_tool_call(name, &value, &requester)
             .map_err(|e| match e {
                 infrastructure::orchestrator::mcp::ToolMapError::UnknownTool(tool) => {
@@ -312,7 +328,7 @@ mod tests {
         AgentId, AgentMcpToolPolicyOverride, McpToolPolicy, Project, ProjectId,
         ProjectMcpToolPermissions, ProjectPath, RemoteRef, StoreError, Workspace,
     };
-    use infrastructure::TicketToolError;
+    use infrastructure::{TemplateToolError, TicketToolError};
     use serde_json::json;
     use uuid::Uuid;
 
@@ -436,6 +452,33 @@ mod tests {
         }
     }
 
+    #[derive(Default)]
+    struct FakeTemplateTools {
+        calls: Mutex<Vec<(String, String, Value)>>,
+    }
+
+    #[async_trait]
+    impl TemplateToolProvider for FakeTemplateTools {
+        async fn handle_template_tool(
+            &self,
+            _project: &Project,
+            requester: &str,
+            name: &str,
+            arguments: Value,
+        ) -> Result<Value, TemplateToolError> {
+            self.calls.lock().unwrap().push((
+                requester.to_owned(),
+                name.to_owned(),
+                arguments.clone(),
+            ));
+            Ok(json!({
+                "ok": true,
+                "requester": requester,
+                "templateId": arguments.get("templateId").and_then(Value::as_str).unwrap_or_default(),
+            }))
+        }
+    }
+
     fn project() -> Project {
         Project::new(
             ProjectId::from_uuid(Uuid::from_u128(1)),
@@ -484,25 +527,29 @@ mod tests {
         let core = backend::BackendCore::build(temp.clone());
         let requester = AgentId::from_uuid(Uuid::from_u128(82)).to_string();
         let ticket_tools = Arc::new(FakeTicketTools::default());
+        let template_tools = Arc::new(FakeTemplateTools::default());
         let invoker = AppOpenAiToolInvoker::new(
             Arc::clone(&core.orchestrator_service),
             Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
             Arc::new(FakePolicies::default()),
             mcp_permissions(ProjectMcpToolPermissions::default()),
             ticket_tools.clone(),
+            template_tools.clone(),
         );
 
-        invoker
-            .call(
-                "idea_ticket_list",
-                &json!({
-                    PROJECT_ROOT_ARG: "/tmp/project",
-                    REQUESTER_ARG: requester,
-                })
-                .to_string(),
-            )
-            .await
-            .expect("read tool must pass the durable read-only policy");
+        for tool in ["idea_ticket_list", "idea_template_list"] {
+            invoker
+                .call(
+                    tool,
+                    &json!({
+                        PROJECT_ROOT_ARG: "/tmp/project",
+                        REQUESTER_ARG: requester,
+                    })
+                    .to_string(),
+                )
+                .await
+                .expect("read tool must pass the durable read-only policy");
+        }
 
         for (tool, arguments) in [
             (
@@ -521,6 +568,18 @@ mod tests {
                 "idea_run_in_background",
                 json!({ "label": "task", "command": "echo" }),
             ),
+            (
+                "idea_template_create",
+                json!({ "name": "Base", "content": "body", "defaultProfileId": Uuid::new_v4() }),
+            ),
+            (
+                "idea_template_update",
+                json!({ "templateId": Uuid::new_v4(), "content": "body" }),
+            ),
+            (
+                "idea_template_delete",
+                json!({ "templateId": Uuid::new_v4() }),
+            ),
         ] {
             let mut payload = arguments.as_object().unwrap().clone();
             payload.insert(PROJECT_ROOT_ARG.to_owned(), json!("/tmp/project"));
@@ -538,6 +597,13 @@ mod tests {
         let calls = ticket_tools.calls.lock().unwrap();
         assert_eq!(calls.len(), 1, "only the read ticket tool should run");
         assert_eq!(calls[0].1, "idea_ticket_list");
+        let template_calls = template_tools.calls.lock().unwrap();
+        assert_eq!(
+            template_calls.len(),
+            1,
+            "only the read template tool should run"
+        );
+        assert_eq!(template_calls[0].1, "idea_template_list");
 
         let _ = std::fs::remove_dir_all(temp);
     }
@@ -552,12 +618,14 @@ mod tests {
         let agent = AgentId::from_uuid(Uuid::from_u128(83));
         let requester = agent.to_string();
         let ticket_tools = Arc::new(FakeTicketTools::default());
+        let template_tools = Arc::new(FakeTemplateTools::default());
         let invoker = AppOpenAiToolInvoker::new(
             Arc::clone(&core.orchestrator_service),
             Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
             Arc::new(FakePolicies::default()),
             mcp_permissions(allow_doc(agent, &["idea_ticket_update_carnet"])),
             ticket_tools.clone(),
+            template_tools,
         );
 
         let result = invoker
@@ -585,6 +653,73 @@ mod tests {
         let _ = std::fs::remove_dir_all(temp);
     }
 
+    #[tokio::test]
+    async fn openai_durable_agent_override_allows_only_explicit_template_write_tool() {
+        let temp = std::env::temp_dir().join(format!(
+            "idea-app-tauri-openai-template-permissions-{}",
+            Uuid::new_v4()
+        ));
+        let core = backend::BackendCore::build(temp.clone());
+        let agent = AgentId::from_uuid(Uuid::from_u128(84));
+        let requester = agent.to_string();
+        let ticket_tools = Arc::new(FakeTicketTools::default());
+        let template_tools = Arc::new(FakeTemplateTools::default());
+        let template_id = Uuid::from_u128(7).to_string();
+        let invoker = AppOpenAiToolInvoker::new(
+            Arc::clone(&core.orchestrator_service),
+            Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
+            Arc::new(FakePolicies::default()),
+            mcp_permissions(allow_doc(agent, &["idea_template_update"])),
+            ticket_tools,
+            template_tools.clone(),
+        );
+
+        let result = invoker
+            .call(
+                "idea_template_update",
+                &json!({
+                    PROJECT_ROOT_ARG: "/tmp/project",
+                    REQUESTER_ARG: requester,
+                    "templateId": template_id,
+                    "content": "body",
+                })
+                .to_string(),
+            )
+            .await
+            .expect("explicit durable override should reach template provider");
+        let result: Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(result["requester"], requester);
+        assert_eq!(result["templateId"], template_id);
+
+        for tool in ["idea_template_create", "idea_template_delete"] {
+            let err = invoker
+                .call(
+                    tool,
+                    &json!({
+                        PROJECT_ROOT_ARG: "/tmp/project",
+                        REQUESTER_ARG: requester,
+                        "templateId": template_id,
+                        "name": "Base",
+                        "content": "body",
+                        "defaultProfileId": Uuid::from_u128(9),
+                    })
+                    .to_string(),
+                )
+                .await
+                .expect_err("non-allowlisted template write must be rejected");
+            assert!(
+                matches!(err, ToolInvocationError::Rejected(ref message) if message.contains(tool)),
+                "expected readable rejection for {tool}, got {err:?}"
+            );
+        }
+
+        let calls = template_tools.calls.lock().unwrap();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].1, "idea_template_update");
+
+        let _ = std::fs::remove_dir_all(temp);
+    }
+
     #[tokio::test]
     async fn openai_ticket_assistant_policy_still_bounds_ticket() {
         let temp = std::env::temp_dir().join(format!(
@@ -603,12 +738,14 @@ mod tests {
             ),
         );
         let ticket_tools = Arc::new(FakeTicketTools::default());
+        let template_tools = Arc::new(FakeTemplateTools::default());
         let invoker = AppOpenAiToolInvoker::new(
             Arc::clone(&core.orchestrator_service),
             Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
             policies,
             mcp_permissions(ProjectMcpToolPermissions::default()),
             ticket_tools.clone(),
+            template_tools,
         );
 
         let denied = invoker

crates/app-tauri/src/state.rs

@@ -10,12 +10,13 @@ use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
 use backend::BackendCore;
-use infrastructure::TicketToolProvider;
+use infrastructure::{TemplateToolProvider, TicketToolProvider};
 use serde::{Deserialize, Serialize};
 
 use crate::chat::ChatBridge;
 use crate::embedded_server::EmbeddedServerController;
 use crate::pty::PtyBridge;
+use crate::templates::AppTemplateToolProvider;
 use crate::tickets::AppTicketToolProvider;
 
 pub use backend::ResumeContext;
@@ -71,6 +72,14 @@ impl AppState {
                 unlink: Arc::clone(&core.unlink_issues),
                 list_sprints: Arc::clone(&core.list_sprints),
             }) as Arc<dyn TicketToolProvider>);
+        core.template_tool_binder
+            .bind(Arc::new(AppTemplateToolProvider {
+                create: Arc::clone(&core.create_template),
+                read: Arc::clone(&core.read_template),
+                list: Arc::clone(&core.list_templates),
+                update: Arc::clone(&core.update_template),
+                delete: Arc::clone(&core.delete_template),
+            }) as Arc<dyn TemplateToolProvider>);
 
         Self {
             core,

crates/app-tauri/src/templates.rs

@@ -0,0 +1,357 @@
+//! Desktop-owned MCP template tool provider.
+//!
+//! This module is a driving-adapter bridge: it maps the public MCP
+//! `idea_template_*` tools to the existing application template use cases.
+
+use std::sync::Arc;
+
+use application::{
+    CreateTemplate, CreateTemplateInput, DeleteTemplate, DeleteTemplateInput, ListTemplates,
+    ReadTemplate, ReadTemplateInput, UpdateTemplate, UpdateTemplateInput,
+};
+use async_trait::async_trait;
+use domain::{Project, TemplateId};
+use infrastructure::{TemplateToolError, TemplateToolProvider};
+use serde_json::{json, Value};
+
+use crate::dto::{parse_profile_id, parse_template_id, TemplateDto, TemplateListDto};
+
+/// Concrete provider for the public MCP template tools.
+#[derive(Clone)]
+pub struct AppTemplateToolProvider {
+    /// Template creation use case.
+    pub create: Arc<CreateTemplate>,
+    /// Template read use case.
+    pub read: Arc<ReadTemplate>,
+    /// Template list use case.
+    pub list: Arc<ListTemplates>,
+    /// Template update use case.
+    pub update: Arc<UpdateTemplate>,
+    /// Template delete use case.
+    pub delete: Arc<DeleteTemplate>,
+}
+
+#[async_trait]
+impl TemplateToolProvider for AppTemplateToolProvider {
+    async fn handle_template_tool(
+        &self,
+        _project: &Project,
+        _requester: &str,
+        name: &str,
+        arguments: Value,
+    ) -> Result<Value, TemplateToolError> {
+        let result = match name {
+            "idea_template_list" => {
+                let templates = self.list.execute().await.map_err(template_error)?;
+                json!(TemplateListDto::from(templates))
+            }
+            "idea_template_read" => {
+                let template_id = parse_json_template_id(&arguments)?;
+                let template = self
+                    .read
+                    .execute(ReadTemplateInput { template_id })
+                    .await
+                    .map_err(template_error)?;
+                json!(TemplateDto::from(template))
+            }
+            "idea_template_create" => {
+                let template = self
+                    .create
+                    .execute(CreateTemplateInput {
+                        name: required_str(&arguments, "name")?.to_owned(),
+                        content: required_str(&arguments, "content")?.to_owned(),
+                        default_profile_id: parse_profile_id(required_str(
+                            &arguments,
+                            "defaultProfileId",
+                        )?)
+                        .map_err(dto_tool_error)?,
+                    })
+                    .await
+                    .map_err(template_error)?;
+                json!(TemplateDto::from(template))
+            }
+            "idea_template_update" => {
+                let template = self
+                    .update
+                    .execute(UpdateTemplateInput {
+                        template_id: parse_json_template_id(&arguments)?,
+                        content: required_str(&arguments, "content")?.to_owned(),
+                    })
+                    .await
+                    .map_err(template_error)?;
+                json!(TemplateDto::from(template))
+            }
+            "idea_template_delete" => {
+                let template_id = parse_json_template_id(&arguments)?;
+                self.delete
+                    .execute(DeleteTemplateInput { template_id })
+                    .await
+                    .map_err(template_error)?;
+                json!({ "deleted": true, "templateId": template_id })
+            }
+            other => {
+                return Err(TemplateToolError::new(
+                    "notFound",
+                    format!("unknown template tool: {other}"),
+                ))
+            }
+        };
+        Ok(result)
+    }
+}
+
+fn template_error(err: application::AppError) -> TemplateToolError {
+    let code = match err.code() {
+        "NOT_FOUND" => "notFound",
+        "INVALID" => "invalid",
+        "STORE" => "store",
+        "FILESYSTEM" => "filesystem",
+        _ => "internal",
+    };
+    TemplateToolError::new(code, err.to_string())
+}
+
+fn dto_tool_error(err: crate::dto::ErrorDto) -> TemplateToolError {
+    let code = match err.code.as_str() {
+        "NOT_FOUND" => "notFound",
+        "INVALID" => "invalid",
+        "STORE" => "store",
+        "FILESYSTEM" => "filesystem",
+        _ => "internal",
+    };
+    TemplateToolError::new(code, err.message)
+}
+
+fn parse_json_template_id(arguments: &Value) -> Result<TemplateId, TemplateToolError> {
+    parse_template_id(required_str(arguments, "templateId")?).map_err(dto_tool_error)
+}
+
+fn required_str<'a>(arguments: &'a Value, key: &str) -> Result<&'a str, TemplateToolError> {
+    arguments
+        .get(key)
+        .and_then(Value::as_str)
+        .ok_or_else(|| TemplateToolError::new("invalid", format!("missing {key}")))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::sync::Mutex;
+
+    use application::{
+        CreateTemplate, DeleteTemplate, ListTemplates, ReadTemplate, UpdateTemplate,
+    };
+    use domain::ports::{EventBus, EventStream, IdGenerator, StoreError, TemplateStore};
+    use domain::{
+        AgentTemplate, DomainEvent, MarkdownDoc, ProfileId, ProjectId, ProjectPath, RemoteRef,
+        TemplateVersion,
+    };
+    use uuid::Uuid;
+
+    use super::*;
+
+    #[derive(Default)]
+    struct FakeTemplateStore {
+        templates: Mutex<HashMap<TemplateId, AgentTemplate>>,
+    }
+
+    #[async_trait]
+    impl TemplateStore for FakeTemplateStore {
+        async fn list(&self) -> Result<Vec<AgentTemplate>, StoreError> {
+            Ok(self.templates.lock().unwrap().values().cloned().collect())
+        }
+
+        async fn get(&self, id: TemplateId) -> Result<AgentTemplate, StoreError> {
+            self.templates
+                .lock()
+                .unwrap()
+                .get(&id)
+                .cloned()
+                .ok_or(StoreError::NotFound)
+        }
+
+        async fn save(&self, template: &AgentTemplate) -> Result<(), StoreError> {
+            self.templates
+                .lock()
+                .unwrap()
+                .insert(template.id, template.clone());
+            Ok(())
+        }
+
+        async fn delete(&self, id: TemplateId) -> Result<(), StoreError> {
+            self.templates
+                .lock()
+                .unwrap()
+                .remove(&id)
+                .map(|_| ())
+                .ok_or(StoreError::NotFound)
+        }
+    }
+
+    struct FakeIds;
+
+    impl IdGenerator for FakeIds {
+        fn new_uuid(&self) -> Uuid {
+            Uuid::from_u128(81)
+        }
+    }
+
+    #[derive(Default)]
+    struct FakeEvents {
+        events: Mutex<Vec<DomainEvent>>,
+    }
+
+    impl EventBus for FakeEvents {
+        fn publish(&self, event: DomainEvent) {
+            self.events.lock().unwrap().push(event);
+        }
+
+        fn subscribe(&self) -> EventStream {
+            Box::new(std::iter::empty())
+        }
+    }
+
+    fn project() -> Project {
+        Project::new(
+            ProjectId::from_uuid(Uuid::from_u128(1)),
+            "demo",
+            ProjectPath::new("/tmp/project").unwrap(),
+            RemoteRef::local(),
+            1_000,
+        )
+        .unwrap()
+    }
+
+    fn provider(store: Arc<FakeTemplateStore>, events: Arc<FakeEvents>) -> AppTemplateToolProvider {
+        let store_port = store as Arc<dyn TemplateStore>;
+        AppTemplateToolProvider {
+            create: Arc::new(CreateTemplate::new(
+                Arc::clone(&store_port),
+                Arc::new(FakeIds),
+            )),
+            read: Arc::new(ReadTemplate::new(Arc::clone(&store_port))),
+            list: Arc::new(ListTemplates::new(Arc::clone(&store_port))),
+            update: Arc::new(UpdateTemplate::new(
+                Arc::clone(&store_port),
+                events as Arc<dyn EventBus>,
+            )),
+            delete: Arc::new(DeleteTemplate::new(store_port)),
+        }
+    }
+
+    #[tokio::test]
+    async fn template_provider_crud_round_trips_and_update_publishes_event() {
+        let store = Arc::new(FakeTemplateStore::default());
+        let events = Arc::new(FakeEvents::default());
+        let provider = provider(Arc::clone(&store), Arc::clone(&events));
+        let profile_id = ProfileId::from_uuid(Uuid::from_u128(9));
+
+        let created = provider
+            .handle_template_tool(
+                &project(),
+                "agent",
+                "idea_template_create",
+                json!({
+                    "name": "Base",
+                    "content": "v1",
+                    "defaultProfileId": profile_id,
+                }),
+            )
+            .await
+            .unwrap();
+        let template_id = created["id"].as_str().unwrap().to_owned();
+        assert_eq!(created["version"], json!(TemplateVersion::INITIAL));
+
+        let read = provider
+            .handle_template_tool(
+                &project(),
+                "agent",
+                "idea_template_read",
+                json!({ "templateId": template_id }),
+            )
+            .await
+            .unwrap();
+        assert_eq!(read["name"], "Base");
+        assert_eq!(read["contentMd"], "v1");
+
+        let listed = provider
+            .handle_template_tool(&project(), "agent", "idea_template_list", json!({}))
+            .await
+            .unwrap();
+        assert_eq!(listed.as_array().unwrap().len(), 1);
+
+        let updated = provider
+            .handle_template_tool(
+                &project(),
+                "agent",
+                "idea_template_update",
+                json!({ "templateId": template_id, "content": "v2" }),
+            )
+            .await
+            .unwrap();
+        assert_eq!(updated["contentMd"], "v2");
+        assert_eq!(updated["version"], json!(2));
+        assert!(matches!(
+            events.events.lock().unwrap().as_slice(),
+            [DomainEvent::TemplateUpdated { .. }]
+        ));
+
+        let deleted = provider
+            .handle_template_tool(
+                &project(),
+                "agent",
+                "idea_template_delete",
+                json!({ "templateId": template_id }),
+            )
+            .await
+            .unwrap();
+        assert_eq!(deleted["deleted"], true);
+
+        let missing = provider
+            .handle_template_tool(
+                &project(),
+                "agent",
+                "idea_template_read",
+                json!({ "templateId": template_id }),
+            )
+            .await
+            .expect_err("deleted template must be missing");
+        assert_eq!(missing.code, "notFound");
+    }
+
+    #[tokio::test]
+    async fn template_provider_rejects_invalid_tool_arguments() {
+        let provider = provider(
+            Arc::new(FakeTemplateStore::default()),
+            Arc::new(FakeEvents::default()),
+        );
+
+        let err = provider
+            .handle_template_tool(
+                &project(),
+                "agent",
+                "idea_template_create",
+                json!({ "name": "Base", "content": "v1", "defaultProfileId": "bad" }),
+            )
+            .await
+            .expect_err("bad profile id should be invalid");
+
+        assert_eq!(err.code, "invalid");
+    }
+
+    #[test]
+    fn template_provider_preserves_content_only_b4_boundary() {
+        let template = AgentTemplate::new(
+            TemplateId::from_uuid(Uuid::from_u128(7)),
+            "Base",
+            MarkdownDoc::new("v1"),
+            ProfileId::from_uuid(Uuid::from_u128(9)),
+        )
+        .unwrap();
+        let updated = template.with_updated_content(MarkdownDoc::new("v2"));
+
+        assert_eq!(updated.name, "Base");
+        assert_eq!(updated.default_profile_id, template.default_profile_id);
+        assert_eq!(updated.version, TemplateVersion(2));
+    }
+}