refactor: improve kill daemon decision logic for interactive prompts

Author: aeroxy

src/commands/memory.rs

@@ -706,15 +706,28 @@ fn snapshots_share_no_node_ids(
         return false;
     }
     // Overlap check is intentionally class-agnostic: an object can change
-    // class name across snapshots, but its ID cannot.
-    let base_nodes_count: usize = base.values().map(|a| a.nodes.len()).sum();
-    let mut base_ids: std::collections::HashSet<u64> =
-        std::collections::HashSet::with_capacity(base_nodes_count);
-    base_ids.extend(base.values().flat_map(|a| a.nodes.keys().copied()));
-    !current
-        .values()
-        .flat_map(|a| a.nodes.keys())
-        .any(|id| base_ids.contains(id))
+    // class name across snapshots, but its ID cannot. Build the HashSet from
+    // whichever side has fewer IDs, then scan the other — this bounds the
+    // peak allocation to the smaller set for large snapshots.
+    let base_count: usize = base.values().map(|a| a.nodes.len()).sum();
+    let current_count: usize = current.values().map(|a| a.nodes.len()).sum();
+    if base_count <= current_count {
+        let mut ids: std::collections::HashSet<u64> =
+            std::collections::HashSet::with_capacity(base_count);
+        ids.extend(base.values().flat_map(|a| a.nodes.keys().copied()));
+        !current
+            .values()
+            .flat_map(|a| a.nodes.keys())
+            .any(|id| ids.contains(id))
+    } else {
+        let mut ids: std::collections::HashSet<u64> =
+            std::collections::HashSet::with_capacity(current_count);
+        ids.extend(current.values().flat_map(|a| a.nodes.keys().copied()));
+        !base
+            .values()
+            .flat_map(|a| a.nodes.keys())
+            .any(|id| ids.contains(id))
+    }
 }
 
 /// Offline implementation of `compare-heapsnapshots`. Parses both files,

src/lib.rs

@@ -485,10 +485,10 @@ enum KillDaemonDecision {
     RefuseNonInteractive,
 }
 
-fn kill_daemon_decision(force: bool, is_tty: bool) -> KillDaemonDecision {
+fn kill_daemon_decision(force: bool, can_prompt: bool) -> KillDaemonDecision {
     if force {
         KillDaemonDecision::Proceed
-    } else if is_tty {
+    } else if can_prompt {
         KillDaemonDecision::PromptUser
     } else {
         KillDaemonDecision::RefuseNonInteractive
@@ -882,7 +882,11 @@ pub async fn run() -> Result<()> {
     // field.
     if let Commands::KillDaemon { force } = &cli.command {
         use std::io::IsTerminal;
-        match kill_daemon_decision(*force, std::io::stdin().is_terminal()) {
+        // A prompt is only useful if the user can both type (stdin) and see it
+        // (stderr). If stderr is not a TTY (e.g. `2>file`) while stdin still is,
+        // prompting would block silently — treat that as non-interactive.
+        let can_prompt = std::io::stdin().is_terminal() && std::io::stderr().is_terminal();
+        match kill_daemon_decision(*force, can_prompt) {
             KillDaemonDecision::RefuseNonInteractive => {
                 return Err(error::CliError::new(
                     error::ErrorCode::InvalidInput,
@@ -1480,7 +1484,8 @@ mod tests {
     }
 
     #[test]
-    fn test_kill_daemon_decision_tty_prompts() {
+    fn test_kill_daemon_decision_can_prompt_prompts() {
+        // Both stdin and stderr are terminals: ask the human.
         assert_eq!(
             kill_daemon_decision(false, true),
             KillDaemonDecision::PromptUser