feat(infra): tmp partagé inter-projets géré par IdeA (handles opaques, leases, GC, projection sandbox) — #189 (QA verte)

- Domaine: port ManagedTempStore + modèle (handle opaque, kind Directory/File, état Active/Released, allocation/lease, expiry).
- Application: use cases Allocate/Resolve/Release/GcManagedTemp, horodatés via Clock.
- Infrastructure: impl FS FsManagedTempStore sous app_data_dir/managed-tmp (root global inter-projets, métadonnées par handle, GC des leases expirés/libérés).
- Exposition MCP contrôlée (ManagedTempToolProvider, catalogue) + câblage sandbox: les agents résolvent un handle au lieu d'inventer un path libre.
- Tests: application/infrastructure managed_temp.

crates/backend/src/openai_tools.rs

@@ -14,7 +14,7 @@ use domain::ports::{
     ToolSpec,
 };
 use domain::{AgentToolPolicy, IssueRef, McpToolPolicy, Project};
-use infrastructure::{TemplateToolProvider, TicketToolProvider};
+use infrastructure::{ManagedTempToolProvider, TemplateToolProvider, TicketToolProvider};
 use serde_json::Value;
 
 const PROJECT_ROOT_ARG: &str = "__ideaProjectRoot";
@@ -28,6 +28,7 @@ pub struct AppOpenAiToolInvoker {
     mcp_tool_permissions: Arc<dyn McpToolPermissionStore>,
     ticket_tools: Arc<dyn TicketToolProvider>,
     template_tools: Arc<dyn TemplateToolProvider>,
+    managed_temp_tools: Arc<dyn ManagedTempToolProvider>,
 }
 
 /// Proxy injecté avant que l'orchestrateur soit construit, puis lié dans la
@@ -101,6 +102,7 @@ impl AppOpenAiToolInvoker {
         mcp_tool_permissions: Arc<dyn McpToolPermissionStore>,
         ticket_tools: Arc<dyn TicketToolProvider>,
         template_tools: Arc<dyn TemplateToolProvider>,
+        managed_temp_tools: Arc<dyn ManagedTempToolProvider>,
     ) -> Self {
         Self {
             orchestrator,
@@ -109,6 +111,7 @@ impl AppOpenAiToolInvoker {
             mcp_tool_permissions,
             ticket_tools,
             template_tools,
+            managed_temp_tools,
         }
     }
 }
@@ -215,6 +218,20 @@ impl ToolInvoker for AppOpenAiToolInvoker {
             return serde_json::to_string(&value)
                 .map_err(|e| ToolInvocationError::Execution(format!("JSON template tool: {e}")));
         }
+        if infrastructure::orchestrator::mcp::tools::is_managed_temp_tool(name) {
+            let value = self
+                .managed_temp_tools
+                .handle_managed_temp_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 managed temp tool: {e}"))
+            });
+        }
         let command = infrastructure::orchestrator::mcp::map_tool_call(name, &value, &requester)
             .map_err(|e| match e {
                 infrastructure::orchestrator::mcp::ToolMapError::UnknownTool(tool) => {
@@ -407,7 +424,7 @@ mod tests {
         AgentId, AgentMcpToolPolicyOverride, McpToolPolicy, Project, ProjectId,
         ProjectMcpToolPermissions, ProjectPath, RemoteRef, StoreError, Workspace,
     };
-    use infrastructure::{TemplateToolError, TicketToolError};
+    use infrastructure::{ManagedTempToolError, TemplateToolError, TicketToolError};
     use serde_json::json;
     use uuid::Uuid;
 
@@ -558,6 +575,37 @@ mod tests {
         }
     }
 
+    #[derive(Default)]
+    struct FakeManagedTempTools {
+        calls: Mutex<Vec<(String, String, Value)>>,
+    }
+
+    #[async_trait]
+    impl ManagedTempToolProvider for FakeManagedTempTools {
+        async fn handle_managed_temp_tool(
+            &self,
+            _project: &Project,
+            requester: &str,
+            name: &str,
+            arguments: Value,
+        ) -> Result<Value, ManagedTempToolError> {
+            self.calls.lock().unwrap().push((
+                requester.to_owned(),
+                name.to_owned(),
+                arguments.clone(),
+            ));
+            Ok(json!({
+                "ok": true,
+                "requester": requester,
+                "handle": arguments.get("handle").and_then(Value::as_str).unwrap_or_default(),
+            }))
+        }
+    }
+
+    fn fake_managed_temp_tools() -> Arc<FakeManagedTempTools> {
+        Arc::new(FakeManagedTempTools::default())
+    }
+
     fn issue_ref(raw: &str) -> IssueRef {
         IssueRef::from_str(raw).unwrap()
     }
@@ -723,6 +771,7 @@ mod tests {
             mcp_permissions(ProjectMcpToolPermissions::default()),
             ticket_tools.clone(),
             template_tools,
+            fake_managed_temp_tools(),
         );
 
         let denied = invoker
@@ -788,6 +837,7 @@ mod tests {
             mcp_permissions(ProjectMcpToolPermissions::default()),
             ticket_tools.clone(),
             template_tools.clone(),
+            fake_managed_temp_tools(),
         );
 
         for tool in ["idea_ticket_list", "idea_template_list"] {
@@ -877,6 +927,7 @@ mod tests {
             )),
             Arc::new(FakeTicketTools::default()),
             Arc::new(FakeTemplateTools::default()),
+            fake_managed_temp_tools(),
         );
 
         let tools = invoker
@@ -916,6 +967,7 @@ mod tests {
             )),
             Arc::new(FakeTicketTools::default()),
             Arc::new(FakeTemplateTools::default()),
+            fake_managed_temp_tools(),
         );
 
         let tools = invoker
@@ -948,6 +1000,7 @@ mod tests {
             mcp_permissions(allow_doc(agent, &["idea_ticket_update_carnet"])),
             ticket_tools.clone(),
             template_tools,
+            fake_managed_temp_tools(),
         );
 
         let result = invoker
@@ -994,6 +1047,7 @@ mod tests {
             mcp_permissions(allow_doc(agent, &["idea_template_update"])),
             ticket_tools,
             template_tools.clone(),
+            fake_managed_temp_tools(),
         );
 
         let result = invoker