test(acp-nats): cover all new write_text_file stubs to satisfy coverage gate

Add tests exercising read_text_file stubs on fs_write_text_file mocks,
and write_text_file covers_stubs dispatches for TerminalKillFailingClient,
TerminalReleaseFailingClient, TerminalWaitForExitFailingClient,
TerminalWaitForExitTimeoutClient, and RpcMockClient.

Author: yordis

rsworkspace/crates/acp-nats/src/client/fs_write_text_file.rs

@@ -657,6 +657,28 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[tokio::test]
+    async fn mock_client_read_text_file_returns_err() {
+        let client = MockClient;
+        let req = ReadTextFileRequest::new(
+            agent_client_protocol::SessionId::from("sess-1"),
+            "/tmp/file.txt".to_string(),
+        );
+        let result = client.read_text_file(req).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn failing_client_read_text_file_returns_err() {
+        let client = FailingClient;
+        let req = ReadTextFileRequest::new(
+            agent_client_protocol::SessionId::from("sess-1"),
+            "/tmp/file.txt".to_string(),
+        );
+        let result = client.read_text_file(req).await;
+        assert!(result.is_err());
+    }
+
     #[tokio::test]
     async fn failing_client_request_permission_returns_err() {
         let client = FailingClient;

rsworkspace/crates/acp-nats/src/client/mod.rs

@@ -1609,6 +1609,43 @@ mod tests {
         assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
     }
 
+    #[tokio::test]
+    async fn dispatch_client_method_terminal_wait_for_exit_failing_client_write_text_file_covers_stubs()
+     {
+        let nats = MockNatsClient::new();
+        let client = TerminalWaitForExitFailingClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/foo.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id: AcpSessionId::new("sess-1").unwrap(),
+            method: ClientMethod::FsWriteTextFile,
+        };
+        let bridge = make_bridge(nats.clone());
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            bridge: &bridge,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.write_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
     #[tokio::test]
     async fn dispatch_client_method_terminal_wait_for_exit_timeout_client_read_text_file_covers_stubs()
      {
@@ -1777,6 +1814,116 @@ mod tests {
         assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
     }
 
+    #[tokio::test]
+    async fn dispatch_client_method_terminal_wait_for_exit_timeout_client_write_text_file_covers_stubs()
+     {
+        let nats = MockNatsClient::new();
+        let client = TerminalWaitForExitTimeoutClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/foo.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id: AcpSessionId::new("sess-1").unwrap(),
+            method: ClientMethod::FsWriteTextFile,
+        };
+        let bridge = make_bridge(nats.clone());
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            bridge: &bridge,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.write_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
+    #[tokio::test]
+    async fn dispatch_client_method_terminal_kill_failing_client_write_text_file_covers_stubs() {
+        let nats = MockNatsClient::new();
+        let client = TerminalKillFailingClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/foo.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id: AcpSessionId::new("sess-1").unwrap(),
+            method: ClientMethod::FsWriteTextFile,
+        };
+        let bridge = make_bridge(nats.clone());
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            bridge: &bridge,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.write_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
+    #[tokio::test]
+    async fn dispatch_client_method_terminal_release_failing_client_write_text_file_covers_stubs()
+     {
+        let nats = MockNatsClient::new();
+        let client = TerminalReleaseFailingClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/foo.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id: AcpSessionId::new("sess-1").unwrap(),
+            method: ClientMethod::FsWriteTextFile,
+        };
+        let bridge = make_bridge(nats.clone());
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            bridge: &bridge,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.write_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
     #[tokio::test]
     async fn dispatch_client_method_dispatches_terminal_release_session_id_mismatch_publishes_error_reply()
      {
@@ -3406,6 +3553,42 @@ mod tests {
         assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
     }
 
+    #[tokio::test]
+    async fn dispatch_client_method_rpc_mock_client_write_text_file_covers_stubs() {
+        let nats = MockNatsClient::new();
+        let client = RpcMockClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/foo.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id: AcpSessionId::new("sess-1").unwrap(),
+            method: ClientMethod::FsWriteTextFile,
+        };
+        let bridge = make_bridge(nats.clone());
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            bridge: &bridge,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.write_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
     #[tokio::test]
     async fn dispatch_client_method_dispatches_request_permission_client_error_publishes_error_reply()
      {