feat(tickets): checkpoint backend V1 du système de tickets (T1-T5)

Checkpoint de travail — QA formelle encore à venir (après reset Codex).
`cargo build` workspace OK, tests ticket/issue verts (domaine, store,
use cases, app-tauri 47/51). Le domaine s'appelle `Issue`, exposé
« ticket » côté MCP/UI.

- T1 domaine : entité Issue (statut, priorité, liens, carnet),
  events, ids, ports.
- T2 infra : store FS Markdown + allocator de références #N.
- T3 application : use cases Issue (create/read/list/update/status/
  priority/carnet/link/unlink/assign) + erreurs dédiées.
- T4 surface MCP : 10 outils publics idea_ticket_* (23 outils au
  total), mappés vers les use cases Issue.
- T5 app-tauri : commandes Tauri ticket_* + DTOs d'events Issue +
  câblage state.rs.

Dette de test PRÉ-EXISTANTE héritée de develop (4 tests app-tauri
mcp_e2e_loopback / mcp_serve_peer rouges) hors périmètre tickets,
non traitée ici.

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

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

@@ -28,6 +28,7 @@ use super::jsonrpc::{
     error_codes, JsonRpcError, JsonRpcRequest, JsonRpcResponse, Transport, TransportError,
     JSONRPC_VERSION,
 };
+use super::tickets::TicketToolProvider;
 use super::tools::{self, ToolMapError};
 
 /// The MCP protocol version this server speaks (advertised on `initialize`).
@@ -61,6 +62,9 @@ pub struct McpServer {
     /// (fix race cold-launch, signal MCP). L'infra ne connaît pas `AgentId` : la
     /// composition root parse le `requester`. `None` ⇒ no-op.
     ready_sink: Option<Arc<dyn Fn(&str) + Send + Sync>>,
+    /// 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>>,
 }
 
 impl McpServer {
@@ -75,6 +79,7 @@ impl McpServer {
             events: None,
             requester: String::new(),
             ready_sink: None,
+            ticket_tools: None,
         }
     }
 
@@ -99,6 +104,13 @@ impl McpServer {
         self
     }
 
+    /// Attaches the public ticket tool provider.
+    #[must_use]
+    pub fn with_ticket_tools(mut self, ticket_tools: Arc<dyn TicketToolProvider>) -> Self {
+        self.ticket_tools = Some(ticket_tools);
+        self
+    }
+
     /// Returns a per-connection clone of this server tagged with the connected
     /// peer's `requester` id (the loopback handshake's `requester`, cadrage v5 §1.4).
     ///
@@ -115,6 +127,7 @@ impl McpServer {
             events: self.events.clone(),
             requester: requester.into(),
             ready_sink: self.ready_sink.clone(),
+            ticket_tools: self.ticket_tools.clone(),
         }
     }
 
@@ -333,6 +346,44 @@ impl McpServer {
              task_len={task_len}",
         );
 
+        if tools::is_ticket_tool(&name) {
+            let result = match &self.ticket_tools {
+                Some(provider) => {
+                    provider
+                        .handle_ticket_tool(&self.project, &self.requester, &name, arguments)
+                        .await
+                }
+                None => Err(super::tickets::TicketToolError::new(
+                    "notConfigured",
+                    "ticket 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) {