chore(wip): checkpoint P8/C avant chantier Codex inter-agents

Sauvegarde de l'arbre de travail en cours (persistance P8, conversations
C-series, write-portal frontend, médiation d'entrée) avant d'attaquer le
support de la délégation inter-agents pour les profils Codex.

Le round-trip inter-agent question/réponse est couvert sans tokens par
les tests loopback existants (state::mcp_e2e_loopback_tests).

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

crates/application/src/orchestrator/context_guard.rs

@@ -29,9 +29,7 @@ use domain::conversation::ConversationParty;
 use domain::fileguard::{FileGuard, GuardError, GuardedResource};
 use domain::markdown::MarkdownDoc;
 use domain::memory::{Memory, MemoryFrontmatter, MemorySlug, MemoryType};
-use domain::ports::{
-    AgentContextStore, Clock, FileSystem, MemoryStore, RemotePath,
-};
+use domain::ports::{AgentContextStore, Clock, FileSystem, MemoryStore, RemotePath};
 use domain::{AgentId, Project};
 
 use crate::error::AppError;
@@ -90,7 +88,11 @@ impl ReadContext {
         contexts: Arc<dyn AgentContextStore>,
         fs: Arc<dyn FileSystem>,
     ) -> Self {
-        Self { guard, contexts, fs }
+        Self {
+            guard,
+            contexts,
+            fs,
+        }
     }
 
     /// Reads the requested context, returning its Markdown body.
@@ -98,7 +100,11 @@ impl ReadContext {
     /// # Errors
     /// [`AppError`] when the agent/context does not exist or the store/fs fails.
     pub async fn execute(&self, input: ReadContextInput) -> Result<MarkdownDoc, AppError> {
-        let ReadContextInput { project, target, requester } = input;
+        let ReadContextInput {
+            project,
+            target,
+            requester,
+        } = input;
         match target {
             None => {
                 // Global project context: shared read-lease, then read the root file.
@@ -109,8 +115,8 @@ impl ReadContext {
                     .map_err(map_guard_err)?;
                 let path = join_root(&project, PROJECT_CONTEXT_FILE);
                 let bytes = self.fs.read(&path).await?;
-                let text = String::from_utf8(bytes)
-                    .map_err(|e| AppError::Invalid(e.to_string()))?;
+                let text =
+                    String::from_utf8(bytes).map_err(|e| AppError::Invalid(e.to_string()))?;
                 Ok(MarkdownDoc::new(text))
             }
             Some(name) => {
@@ -173,7 +179,12 @@ impl ProposeContext {
         fs: Arc<dyn FileSystem>,
         clock: Arc<dyn Clock>,
     ) -> Self {
-        Self { guard, contexts, fs, clock }
+        Self {
+            guard,
+            contexts,
+            fs,
+            clock,
+        }
     }
 
     /// Applies the proposal: direct write under a write-lease, or a materialised
@@ -182,7 +193,12 @@ impl ProposeContext {
     /// # Errors
     /// [`AppError`] when the agent does not exist or the store/fs fails.
     pub async fn execute(&self, input: ProposeContextInput) -> Result<ProposeOutcome, AppError> {
-        let ProposeContextInput { project, target, content, requester } = input;
+        let ProposeContextInput {
+            project,
+            target,
+            content,
+            requester,
+        } = input;
         match target {
             Some(name) => {
                 // Per-agent context: direct write under an exclusive write-lease.
@@ -273,7 +289,11 @@ impl ReadMemory {
     /// [`AppError`] when the note does not exist or the store fails. An invalid slug
     /// is [`AppError::Invalid`].
     pub async fn execute(&self, input: ReadMemoryInput) -> Result<String, AppError> {
-        let ReadMemoryInput { project, slug, requester } = input;
+        let ReadMemoryInput {
+            project,
+            slug,
+            requester,
+        } = input;
         match slug {
             Some(raw) => {
                 let slug = MemorySlug::new(raw).map_err(|e| AppError::Invalid(e.to_string()))?;
@@ -329,7 +349,12 @@ impl WriteMemory {
     /// [`AppError::Invalid`] for a bad slug or empty body; [`AppError`] on a store
     /// failure.
     pub async fn execute(&self, input: WriteMemoryInput) -> Result<(), AppError> {
-        let WriteMemoryInput { project, slug, content, requester } = input;
+        let WriteMemoryInput {
+            project,
+            slug,
+            content,
+            requester,
+        } = input;
         let slug = MemorySlug::new(slug).map_err(|e| AppError::Invalid(e.to_string()))?;
         let _lease = self
             .guard
@@ -527,11 +552,7 @@ mod tests {
         async fn list(&self, _root: &ProjectPath) -> Result<Vec<Memory>, MemoryError> {
             Ok(Vec::new())
         }
-        async fn get(
-            &self,
-            _root: &ProjectPath,
-            slug: &MemorySlug,
-        ) -> Result<Memory, MemoryError> {
+        async fn get(&self, _root: &ProjectPath, slug: &MemorySlug) -> Result<Memory, MemoryError> {
             let body = self
                 .notes
                 .lock()
@@ -556,11 +577,7 @@ mod tests {
                 .insert(memory.slug().to_string(), memory.body.as_str().to_owned());
             Ok(())
         }
-        async fn delete(
-            &self,
-            _root: &ProjectPath,
-            _slug: &MemorySlug,
-        ) -> Result<(), MemoryError> {
+        async fn delete(&self, _root: &ProjectPath, _slug: &MemorySlug) -> Result<(), MemoryError> {
             Ok(())
         }
         async fn read_index(
@@ -805,7 +822,10 @@ mod tests {
             guard.acquire_write(agent_party(2), slug.clone()),
         )
         .await;
-        assert!(blocked.is_err(), "a second writer must block while w1 holds");
+        assert!(
+            blocked.is_err(),
+            "a second writer must block while w1 holds"
+        );
         drop(w1);
         let w2 = tokio::time::timeout(
             Duration::from_millis(200),