chore(rust): replace inline_module_block allows with file-backed modules (#387)

yordis · web-flow · commit 6a45f24e6a93 · 2026-06-22T23:39:50.000-04:00
Signed-off-by: Yordis Prieto &lt;yordis.prieto@gmail.com&gt;
diff --git a/rsworkspace/crates/acp-nats-agent/src/connection.rs b/rsworkspace/crates/acp-nats-agent/src/connection.rs
@@ -1,7 +1,6 @@
 use acp_nats::jetstream::consumers::commands_observer;
 use acp_nats::jetstream::streams::commands_stream_name;
-use acp_nats::nats::agent::wildcards::GlobalAllSubject;
-use acp_nats::nats::session::wildcards::{AllAgentExtSubject, AllAgentSubject};
+use acp_nats::nats::subscriptions::{AllAgentExtSubject, AllAgentSubject, GlobalAllSubject};
 use acp_nats::nats::{GlobalAgentMethod, ParsedAgentSubject, SessionAgentMethod, parse_agent_subject};
 use acp_nats::{AcpPrefix, AcpSessionId, NatsClientProxy, PromptResponseSubject, ReqId, ResponseSubject};
 use agent_client_protocol::{
diff --git a/rsworkspace/crates/acp-nats/src/agent/authenticate.rs b/rsworkspace/crates/acp-nats/src/agent/authenticate.rs
@@ -1,6 +1,6 @@
 use super::Bridge;
 use crate::error::map_nats_error;
-use crate::nats::{self, RequestClient, agent};
+use crate::nats::{self, RequestClient, global};
 use agent_client_protocol::{AuthenticateRequest, AuthenticateResponse, Result};
 use tracing::{info, instrument};
 use trogon_std::time::GetElapsed;
@@ -21,7 +21,7 @@ pub async fn handle<N: RequestClient, C: GetElapsed, J>(
 
     let result = nats::request_with_timeout::<N, AuthenticateRequest, AuthenticateResponse>(
         nats,
-        &agent::AuthenticateSubject::new(bridge.config.acp_prefix_ref()),
+        &global::AuthenticateSubject::new(bridge.config.acp_prefix_ref()),
         &args,
         bridge.config.operation_timeout,
     )
diff --git a/rsworkspace/crates/acp-nats/src/agent/bridge.rs b/rsworkspace/crates/acp-nats/src/agent/bridge.rs
@@ -3,7 +3,7 @@ use std::cell::RefCell;
 use crate::config::Config;
 use crate::nats::{
     self, ExtSessionReady, FlushClient, FlushPolicy, PublishClient, PublishOptions, RequestClient, RetryPolicy,
-    SubscribeClient, session,
+    SubscribeClient, responses,
 };
 use crate::pending_prompt_waiters::PendingSessionPromptResponseWaiters;
 use crate::telemetry::metrics::Metrics;
@@ -111,7 +111,7 @@ async fn publish_session_ready<N: PublishClient + FlushClient>(
             return;
         }
     };
-    let subject = session::agent::ExtReadySubject::new(prefix, &acp_session_id);
+    let subject = responses::ExtReadySubject::new(prefix, &acp_session_id);
     info!(session_id = %session_id, subject = %subject, "Publishing session.ready");
 
     let message = ExtSessionReady::new(session_id.clone());
diff --git a/rsworkspace/crates/acp-nats/src/agent/cancel.rs b/rsworkspace/crates/acp-nats/src/agent/cancel.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{self, FlushClient, PublishClient, session};
+use crate::nats::{self, FlushClient, PublishClient, commands, responses};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{CancelNotification, Error, ErrorCode, Result};
 use tracing::{info, instrument, warn};
@@ -32,7 +32,7 @@ pub async fn handle<N: PublishClient + FlushClient, C: GetElapsed, J>(
     })?;
 
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::CancelSubject::new(prefix, &session_id);
+    let subject = commands::CancelSubject::new(prefix, &session_id);
 
     let publish_result = nats::publish(
         bridge.nats(),
@@ -53,7 +53,7 @@ pub async fn handle<N: PublishClient + FlushClient, C: GetElapsed, J>(
         bridge.metrics.record_error("cancel", "cancel_publish_failed");
     }
 
-    let cancelled_subject = session::agent::CancelledSubject::new(prefix, &session_id);
+    let cancelled_subject = responses::CancelledSubject::new(prefix, &session_id);
     if let Err(e) = bridge
         .nats()
         .publish_with_headers(cancelled_subject, async_nats::HeaderMap::new(), bytes::Bytes::new())
diff --git a/rsworkspace/crates/acp-nats/src/agent/close_session.rs b/rsworkspace/crates/acp-nats/src/agent/close_session.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{CloseSessionRequest, CloseSessionResponse, Error, ErrorCode, Result};
 use tracing::{info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::CloseSubject::new(prefix, &session_id);
+    let subject = commands::CloseSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<CloseSessionRequest, CloseSessionResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/agent/ext_method.rs b/rsworkspace/crates/acp-nats/src/agent/ext_method.rs
@@ -1,7 +1,7 @@
 use super::Bridge;
 use crate::error::map_nats_error;
 use crate::ext_method_name::ExtMethodName;
-use crate::nats::{self, RequestClient, agent};
+use crate::nats::{self, RequestClient, global};
 use agent_client_protocol::{Error, ErrorCode, ExtRequest, ExtResponse, Result};
 use tracing::{info, instrument};
 use trogon_std::time::GetElapsed;
@@ -28,7 +28,7 @@ pub async fn handle<N: RequestClient, C: GetElapsed, J>(
     })?;
 
     let nats = bridge.nats();
-    let subject = agent::ExtSubject::new(bridge.config.acp_prefix_ref(), &method_name);
+    let subject = global::ExtSubject::new(bridge.config.acp_prefix_ref(), &method_name);
 
     let result = nats::request_with_timeout::<N, ExtRequest, ExtResponse>(
         nats,
diff --git a/rsworkspace/crates/acp-nats/src/agent/ext_notification.rs b/rsworkspace/crates/acp-nats/src/agent/ext_notification.rs
@@ -1,6 +1,6 @@
 use super::Bridge;
 use crate::ext_method_name::ExtMethodName;
-use crate::nats::{self, FlushClient, PublishClient, agent};
+use crate::nats::{self, FlushClient, PublishClient, global};
 use agent_client_protocol::{Error, ErrorCode, ExtNotification, Result};
 use tracing::{info, instrument, warn};
 use trogon_std::time::GetElapsed;
@@ -31,7 +31,7 @@ pub async fn handle<N: PublishClient + FlushClient, C: GetElapsed, J>(
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid method name: {}", e))
     })?;
 
-    let subject = agent::ExtNotifySubject::new(bridge.config.acp_prefix_ref(), &method_name);
+    let subject = global::ExtNotifySubject::new(bridge.config.acp_prefix_ref(), &method_name);
 
     let publish_result = nats::publish(
         bridge.nats(),
diff --git a/rsworkspace/crates/acp-nats/src/agent/fork_session.rs b/rsworkspace/crates/acp-nats/src/agent/fork_session.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{Error, ErrorCode, ForkSessionRequest, ForkSessionResponse, Result};
 use tracing::{Span, info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::ForkSubject::new(prefix, &session_id);
+    let subject = commands::ForkSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<ForkSessionRequest, ForkSessionResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/agent/initialize.rs b/rsworkspace/crates/acp-nats/src/agent/initialize.rs
@@ -1,6 +1,6 @@
 use super::Bridge;
 use crate::error::map_nats_error;
-use crate::nats::{self, RequestClient, agent};
+use crate::nats::{self, RequestClient, global};
 use agent_client_protocol::{InitializeRequest, InitializeResponse, Result};
 use tracing::{info, instrument};
 use trogon_std::time::GetElapsed;
@@ -21,7 +21,7 @@ pub async fn handle<N: RequestClient, C: GetElapsed, J>(
     info!(client = %client_name, "Initialize request");
 
     let nats = bridge.nats();
-    let subject = agent::InitializeSubject::new(bridge.config.acp_prefix_ref());
+    let subject = global::InitializeSubject::new(bridge.config.acp_prefix_ref());
 
     let result = nats::request_with_timeout::<N, InitializeRequest, InitializeResponse>(
         nats,
diff --git a/rsworkspace/crates/acp-nats/src/agent/list_sessions.rs b/rsworkspace/crates/acp-nats/src/agent/list_sessions.rs
@@ -1,6 +1,6 @@
 use super::Bridge;
 use crate::error::map_nats_error;
-use crate::nats::{self, RequestClient, agent};
+use crate::nats::{self, RequestClient, global};
 use agent_client_protocol::{ListSessionsRequest, ListSessionsResponse, Result};
 use tracing::{info, instrument};
 use trogon_std::time::GetElapsed;
@@ -15,7 +15,7 @@ pub async fn handle<N: RequestClient, C: GetElapsed, J>(
     info!("List sessions request");
 
     let nats = bridge.nats();
-    let subject = agent::SessionListSubject::new(bridge.config.acp_prefix_ref());
+    let subject = global::SessionListSubject::new(bridge.config.acp_prefix_ref());
 
     let result = nats::request_with_timeout::<N, ListSessionsRequest, ListSessionsResponse>(
         nats,
diff --git a/rsworkspace/crates/acp-nats/src/agent/load_session.rs b/rsworkspace/crates/acp-nats/src/agent/load_session.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{Error, ErrorCode, LoadSessionRequest, LoadSessionResponse, Result};
 use tracing::{info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::LoadSubject::new(prefix, &session_id);
+    let subject = commands::LoadSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<LoadSessionRequest, LoadSessionResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/agent/logout.rs b/rsworkspace/crates/acp-nats/src/agent/logout.rs
@@ -1,6 +1,6 @@
 use super::Bridge;
 use crate::error::map_nats_error;
-use crate::nats::{self, RequestClient, agent};
+use crate::nats::{self, RequestClient, global};
 use agent_client_protocol::{LogoutRequest, LogoutResponse, Result};
 use tracing::{info, instrument};
 use trogon_std::time::GetElapsed;
@@ -17,7 +17,7 @@ pub async fn handle<N: RequestClient, C: GetElapsed, J>(
 
     let result = nats::request_with_timeout::<N, LogoutRequest, LogoutResponse>(
         nats,
-        &agent::LogoutSubject::new(bridge.config.acp_prefix_ref()),
+        &global::LogoutSubject::new(bridge.config.acp_prefix_ref()),
         &args,
         bridge.config.operation_timeout,
     )
diff --git a/rsworkspace/crates/acp-nats/src/agent/new_session.rs b/rsworkspace/crates/acp-nats/src/agent/new_session.rs
@@ -1,6 +1,6 @@
 use super::Bridge;
 use crate::error::map_nats_error;
-use crate::nats::{self, FlushClient, PublishClient, RequestClient, agent};
+use crate::nats::{self, FlushClient, PublishClient, RequestClient, global};
 use agent_client_protocol::{NewSessionRequest, NewSessionResponse, Result};
 use tracing::{Span, info, instrument};
 use trogon_std::time::GetElapsed;
@@ -19,7 +19,7 @@ pub async fn handle<N: RequestClient + PublishClient + FlushClient, C: GetElapse
     info!(cwd = ?args.cwd, mcp_servers = args.mcp_servers.len(), "New session request");
 
     let nats = bridge.nats();
-    let subject = agent::SessionNewSubject::new(bridge.config.acp_prefix_ref());
+    let subject = global::SessionNewSubject::new(bridge.config.acp_prefix_ref());
 
     let result = nats::request_with_timeout::<N, NewSessionRequest, NewSessionResponse>(
         nats,
diff --git a/rsworkspace/crates/acp-nats/src/agent/prompt.rs b/rsworkspace/crates/acp-nats/src/agent/prompt.rs
@@ -13,7 +13,7 @@ use trogon_std::JsonSerialize;
 use crate::agent::Bridge;
 use crate::constants::SESSION_ID_HEADER;
 use crate::jetstream::{consumers, streams};
-use crate::nats::{FlushClient, PublishClient, RequestClient, SubscribeClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, SubscribeClient, commands, responses};
 use crate::req_id::ReqId;
 use crate::session_id::AcpSessionId;
 
@@ -113,7 +113,7 @@ where
     // Cancel still uses core NATS — it's a fire-and-forget signal, not persisted.
     let mut cancel_sub = bridge
         .nats
-        .subscribe(session::agent::CancelledSubject::new(prefix, session_id))
+        .subscribe(responses::CancelledSubject::new(prefix, session_id))
         .await
         .map_err(|e| Error::new(ErrorCode::InternalError.into(), format!("subscribe cancelled: {e}")))?;
 
@@ -126,7 +126,7 @@ where
     headers.insert(REQ_ID_HEADER, req_id.as_str());
     headers.insert(SESSION_ID_HEADER, session_id.as_str());
 
-    let prompt_subject = session::agent::PromptSubject::new(prefix, session_id);
+    let prompt_subject = commands::PromptSubject::new(prefix, session_id);
     js.publish_with_headers(prompt_subject, headers, Bytes::from(payload_bytes))
         .await
         .map_err(|e| Error::new(ErrorCode::InternalError.into(), format!("js publish: {e}")))?
diff --git a/rsworkspace/crates/acp-nats/src/agent/resume_session.rs b/rsworkspace/crates/acp-nats/src/agent/resume_session.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{Error, ErrorCode, Result, ResumeSessionRequest, ResumeSessionResponse};
 use tracing::{info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::ResumeSubject::new(prefix, &session_id);
+    let subject = commands::ResumeSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<ResumeSessionRequest, ResumeSessionResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/agent/set_session_config_option.rs b/rsworkspace/crates/acp-nats/src/agent/set_session_config_option.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{Error, ErrorCode, Result, SetSessionConfigOptionRequest, SetSessionConfigOptionResponse};
 use tracing::{info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::SetConfigOptionSubject::new(prefix, &session_id);
+    let subject = commands::SetConfigOptionSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<SetSessionConfigOptionRequest, SetSessionConfigOptionResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/agent/set_session_mode.rs b/rsworkspace/crates/acp-nats/src/agent/set_session_mode.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{Error, ErrorCode, Result, SetSessionModeRequest, SetSessionModeResponse};
 use tracing::{info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::SetModeSubject::new(prefix, &session_id);
+    let subject = commands::SetModeSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<SetSessionModeRequest, SetSessionModeResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/agent/set_session_model.rs b/rsworkspace/crates/acp-nats/src/agent/set_session_model.rs
@@ -1,5 +1,5 @@
 use super::Bridge;
-use crate::nats::{FlushClient, PublishClient, RequestClient, session};
+use crate::nats::{FlushClient, PublishClient, RequestClient, commands};
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{Error, ErrorCode, Result, SetSessionModelRequest, SetSessionModelResponse};
 use tracing::{info, instrument};
@@ -31,7 +31,7 @@ where
         Error::new(ErrorCode::InvalidParams.into(), format!("Invalid session ID: {}", e))
     })?;
     let prefix = bridge.config.acp_prefix_ref();
-    let subject = session::agent::SetModelSubject::new(prefix, &session_id);
+    let subject = commands::SetModelSubject::new(prefix, &session_id);
 
     let result = bridge
         .session_request::<SetSessionModelRequest, SetSessionModelResponse>(&subject, &args, &session_id)
diff --git a/rsworkspace/crates/acp-nats/src/client/mod.rs b/rsworkspace/crates/acp-nats/src/client/mod.rs
@@ -60,7 +60,7 @@ pub async fn run<
     bridge: Rc<Bridge<N, C, J>>,
     serializer: S,
 ) {
-    let wildcard = crate::nats::session::wildcards::AllClientSubject::new(bridge.config.acp_prefix_ref());
+    let wildcard = crate::nats::subscriptions::AllClientSubject::new(bridge.config.acp_prefix_ref());
     info!("Starting client proxy - subscribing to {}", wildcard);
 
     let mut subscriber = match nats.subscribe(wildcard).await {
diff --git a/rsworkspace/crates/acp-nats/src/client_proxy.rs b/rsworkspace/crates/acp-nats/src/client_proxy.rs
@@ -1,5 +1,5 @@
 use crate::acp_prefix::AcpPrefix;
-use crate::nats::session;
+use crate::nats::client_ops;
 use crate::session_id::AcpSessionId;
 use agent_client_protocol::{
     Client, CreateTerminalRequest, CreateTerminalResponse, Error, ErrorCode, KillTerminalRequest, KillTerminalResponse,
@@ -66,47 +66,47 @@ impl<N: RequestClient + PublishClient + FlushClient> NatsClientProxy<N> {
 #[async_trait::async_trait(?Send)]
 impl<N: RequestClient + PublishClient + FlushClient> Client for NatsClientProxy<N> {
     async fn request_permission(&self, args: RequestPermissionRequest) -> Result<RequestPermissionResponse> {
-        let s = session::client::SessionRequestPermissionSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::SessionRequestPermissionSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn session_notification(&self, args: SessionNotification) -> Result<()> {
-        let s = session::client::SessionUpdateSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::SessionUpdateSubject::new(self.prefix(), self.session_id());
         self.notify(&s, &args).await
     }
 
     async fn read_text_file(&self, args: ReadTextFileRequest) -> Result<ReadTextFileResponse> {
-        let s = session::client::FsReadTextFileSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::FsReadTextFileSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn write_text_file(&self, args: WriteTextFileRequest) -> Result<WriteTextFileResponse> {
-        let s = session::client::FsWriteTextFileSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::FsWriteTextFileSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn create_terminal(&self, args: CreateTerminalRequest) -> Result<CreateTerminalResponse> {
-        let s = session::client::TerminalCreateSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::TerminalCreateSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn terminal_output(&self, args: TerminalOutputRequest) -> Result<TerminalOutputResponse> {
-        let s = session::client::TerminalOutputSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::TerminalOutputSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn release_terminal(&self, args: ReleaseTerminalRequest) -> Result<ReleaseTerminalResponse> {
-        let s = session::client::TerminalReleaseSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::TerminalReleaseSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn wait_for_terminal_exit(&self, args: WaitForTerminalExitRequest) -> Result<WaitForTerminalExitResponse> {
-        let s = session::client::TerminalWaitForExitSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::TerminalWaitForExitSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 
     async fn kill_terminal(&self, args: KillTerminalRequest) -> Result<KillTerminalResponse> {
-        let s = session::client::TerminalKillSubject::new(self.prefix(), self.session_id());
+        let s = client_ops::TerminalKillSubject::new(self.prefix(), self.session_id());
         self.request(&s, &args).await
     }
 }
diff --git a/rsworkspace/crates/acp-nats/src/lib.rs b/rsworkspace/crates/acp-nats/src/lib.rs
@@ -24,7 +24,7 @@ pub use client_proxy::NatsClientProxy;
 pub use config::{Config, DEFAULT_ACP_PREFIX, ENV_ACP_PREFIX, apply_timeout_overrides, nats_connect_timeout};
 pub use error::AGENT_UNAVAILABLE;
 pub use ext_method_name::ExtMethodName;
-pub use nats::session::agent::{PromptResponseSubject, ResponseSubject, UpdateSubject};
+pub use nats::responses::{PromptResponseSubject, ResponseSubject, UpdateSubject};
 pub use nats::{FlushClient, PublishClient, RequestClient, SubscribeClient};
 pub use req_id::ReqId;
 pub use session_id::AcpSessionId;
diff --git a/rsworkspace/crates/acp-nats/src/nats/mod.rs b/rsworkspace/crates/acp-nats/src/nats/mod.rs
diff --git a/rsworkspace/crates/acp-nats/src/nats/subjects/mod.rs b/rsworkspace/crates/acp-nats/src/nats/subjects/mod.rs
diff --git a/rsworkspace/crates/mcp-nats/src/lib.rs b/rsworkspace/crates/mcp-nats/src/lib.rs
diff --git a/rsworkspace/crates/mcp-nats/src/nats/mod.rs b/rsworkspace/crates/mcp-nats/src/nats/mod.rs
diff --git a/rsworkspace/crates/mcp-nats/src/nats/subjects/mod.rs b/rsworkspace/crates/mcp-nats/src/nats/subjects/mod.rs
diff --git a/rsworkspace/crates/mcp-nats/src/transport.rs b/rsworkspace/crates/mcp-nats/src/transport.rs
diff --git a/rsworkspace/crates/trogon-decider/src/testing.rs b/rsworkspace/crates/trogon-decider/src/testing.rs
diff --git a/rsworkspace/crates/trogon-decider/src/testing/private.rs b/rsworkspace/crates/trogon-decider/src/testing/private.rs
diff --git a/rsworkspace/crates/trogon-scheduler/src/processor/execution/checkpoints/codec.rs b/rsworkspace/crates/trogon-scheduler/src/processor/execution/checkpoints/codec.rs
diff --git a/rsworkspace/crates/trogon-scheduler/src/processor/execution/checkpoints/codec/twin.rs b/rsworkspace/crates/trogon-scheduler/src/processor/execution/checkpoints/codec/twin.rs
