chore(acp): apply chaodu-agent NITs from PR #760

- pool.liveness_check_secs: hoist the recv-loop poll cadence out of a
  hard-coded const onto PoolConfig so deployments can tune it. Default
  remains 30s.
- adapter: change hard-timeout error message from ({}m) to ({}s) so
  non-multiple-of-60 ceilings render correctly (e.g. 90s → "(90s)").
- acp/connection: emit a tracing::trace! line when an id-bearing message
  arrives whose pending entry was already abandoned. Behaviour is
  unchanged — the adapter recv loop still filters by request_id; this
  just makes the stale-response path observable at trace level.

cargo check + cargo clippy -- -D warnings + cargo test --bin openab all
clean (238 passed).

Author: brettchien

config.toml.example

@@ -106,6 +106,8 @@ max_sessions = 10
 session_ttl_hours = 24
 # Hard ceiling (sec) per prompt; see #732. Default: 1800 (30 min).
 # prompt_hard_timeout_secs = 1800
+# Liveness-check cadence (sec) for the recv loop; see #732. Default: 30.
+# liveness_check_secs = 30
 
 [markdown]
 tables = "code"  # "code" (default) | "bullets" | "off"

src/acp/connection.rs

@@ -10,7 +10,7 @@ use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, ChildStdin};
 use tokio::sync::{mpsc, oneshot, Mutex};
 use tokio::task::JoinHandle;
-use tracing::{debug, error, info};
+use tracing::{debug, error, info, trace};
 
 /// Pick the most permissive selectable permission option from ACP options.
 fn pick_best_option(options: &[Value]) -> Option<String> {
@@ -319,6 +319,10 @@ impl AcpConnection {
                             let _ = tx.send(msg);
                             continue;
                         }
+                        // Stale id (#732): pending was already abandoned. Falls through
+                        // to subscriber forwarding; the adapter recv loop filters by
+                        // request_id so it can't leak into the next prompt.
+                        trace!(request_id = id, "stale id-bearing message after abandon");
                     }
 
                     // Notification → forward to subscriber

src/adapter.rs

@@ -153,16 +153,15 @@ pub trait ChatAdapter: Send + Sync + 'static {
 
 // --- AdapterRouter ---
 
-/// Polling cadence for the recv-loop liveness check (#732).
-const LIVENESS_CHECK_INTERVAL: std::time::Duration = std::time::Duration::from_secs(30);
-
 /// Shared logic for routing messages to ACP agents, managing sessions,
 /// streaming edits, and controlling reactions. Platform-independent.
 pub struct AdapterRouter {
     pool: Arc<SessionPool>,
     reactions_config: ReactionsConfig,
     table_mode: TableMode,
     prompt_hard_timeout: std::time::Duration,
+    /// Polling cadence for the recv-loop liveness check (#732).
+    liveness_check_interval: std::time::Duration,
 }
 
 impl AdapterRouter {
@@ -171,12 +170,14 @@ impl AdapterRouter {
         reactions_config: ReactionsConfig,
         table_mode: TableMode,
         prompt_hard_timeout_secs: u64,
+        liveness_check_secs: u64,
     ) -> Self {
         Self {
             pool,
             reactions_config,
             table_mode,
             prompt_hard_timeout: std::time::Duration::from_secs(prompt_hard_timeout_secs),
+            liveness_check_interval: std::time::Duration::from_secs(liveness_check_secs),
         }
     }
 
@@ -342,6 +343,7 @@ impl AdapterRouter {
         let table_mode = self.table_mode;
         let tool_display = self.reactions_config.tool_display;
         let prompt_hard_timeout = self.prompt_hard_timeout;
+        let liveness_check_interval = self.liveness_check_interval;
 
         self.pool
             .with_connection(thread_key, |conn| {
@@ -415,16 +417,16 @@ impl AdapterRouter {
                                 // Reader saw EOF and already drained pending; nothing to abandon.
                                 None => break,
                             },
-                            _ = tokio::time::sleep(LIVENESS_CHECK_INTERVAL) => {
+                            _ = tokio::time::sleep(liveness_check_interval) => {
                                 if !conn.alive() {
                                     response_error = Some("Agent process died".into());
                                     conn.abandon_request(request_id).await;
                                     break;
                                 }
                                 if prompt_start.elapsed() > prompt_hard_timeout {
                                     response_error = Some(format!(
-                                        "Agent exceeded hard timeout ({}m)",
-                                        prompt_hard_timeout.as_secs() / 60,
+                                        "Agent exceeded hard timeout ({}s)",
+                                        prompt_hard_timeout.as_secs(),
                                     ));
                                     conn.abandon_request(request_id).await;
                                     break;

src/config.rs

@@ -319,6 +319,11 @@ pub struct PoolConfig {
     /// next prompt's subscriber.
     #[serde(default = "default_prompt_hard_timeout_secs")]
     pub prompt_hard_timeout_secs: u64,
+    /// Polling cadence (seconds) for the recv-loop liveness check (#732).
+    /// Lower = faster reaction to a dead agent / hard ceiling at the cost of
+    /// more wakeups while the agent is streaming normally.
+    #[serde(default = "default_liveness_check_secs")]
+    pub liveness_check_secs: u64,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -443,6 +448,9 @@ fn default_ttl_hours() -> u64 {
 pub(crate) fn default_prompt_hard_timeout_secs() -> u64 {
     30 * 60
 }
+pub(crate) fn default_liveness_check_secs() -> u64 {
+    30
+}
 fn default_true() -> bool {
     true
 }
@@ -491,6 +499,7 @@ impl Default for PoolConfig {
             max_sessions: default_max_sessions(),
             session_ttl_hours: default_ttl_hours(),
             prompt_hard_timeout_secs: default_prompt_hard_timeout_secs(),
+            liveness_check_secs: default_liveness_check_secs(),
         }
     }
 }

src/dispatch.rs

@@ -1073,6 +1073,7 @@ mod tests {
             crate::config::ReactionsConfig::default(),
             crate::markdown::TableMode::Off,
             crate::config::default_prompt_hard_timeout_secs(),
+            crate::config::default_liveness_check_secs(),
         ));
         Dispatcher::with_idle_timeout(router, 10, 24_000, grouping, DEFAULT_CONSUMER_IDLE_TIMEOUT)
     }

src/main.rs

@@ -148,6 +148,7 @@ async fn main() -> anyhow::Result<()> {
         cfg.reactions,
         cfg.markdown.tables,
         cfg.pool.prompt_hard_timeout_secs,
+        cfg.pool.liveness_check_secs,
     ));
 
     // Shutdown signal for Slack adapter