feature: ability to stop container (#310)

* stop container feature

* pr update

* fix: stop session bugs and status reporting

- Fix Stopped sessions being miscounted as idle in `aoe status`
- Add `stopped` field to StatusCounts/StatusJson and include in all output
- Fix TUI StopSession action setting Stopped status even when stop() fails
- Persist Stopped status to disk in both CLI and TUI so it survives restarts
- Add HomeView::save() for TUI-side persistence
- Revert STATUS_REFRESH_INTERVAL to 500ms (no need to double poll frequency)
- Clean up std::collections::HashMap usage with proper imports
- Document projects/ sentinel heuristic in container_config sync logic

Co-Authored-By: Claude Opus 4.6 <[email protected]>

* fix: filter batch_running_states by exact prefix match

Docker's --filter name= does substring matching, which could match
unrelated containers whose names contain "aoe-sandbox-". Add a
starts_with post-filter to ensure only exact prefix matches are included.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

* stopp

---------

Co-authored-by: Claude Opus 4.6 <[email protected]>

Author: njbrake

.claude/skills/review-pr/SKILL.md

@@ -122,16 +122,36 @@ async fn start_session(profile: &str, args: SessionIdArgs) -> Result<()> {
 
 async fn stop_session(profile: &str, args: SessionIdArgs) -> Result<()> {
     let storage = Storage::new(profile)?;
-    let (instances, _) = storage.load_with_groups()?;
+    let (mut instances, groups) = storage.load_with_groups()?;
 
     let inst = super::resolve_session(&args.identifier, &instances)?;
+    let session_id = inst.id.clone();
+    let title = inst.title.clone();
     let tmux_session = crate::tmux::Session::new(&inst.id, &inst.title)?;
+    let was_running = tmux_session.exists();
+    let had_container = inst.is_sandboxed()
+        && crate::containers::DockerContainer::from_session_id(&inst.id)
+            .is_running()
+            .unwrap_or(false);
+
+    if !was_running && !had_container {
+        println!("Session is not running: {}", title);
+        return Ok(());
+    }
+
+    inst.stop()?;
+
+    // Persist Stopped status to disk so it survives TUI restarts
+    if let Some(stored) = instances.iter_mut().find(|i| i.id == session_id) {
+        stored.status = crate::session::Status::Stopped;
+    }
+    let group_tree = crate::session::GroupTree::new_with_groups(&instances, &groups);
+    storage.save_with_groups(&instances, &group_tree)?;
 
-    if tmux_session.exists() {
-        tmux_session.kill()?;
-        println!("✓ Stopped session: {}", inst.title);
+    if had_container {
+        println!("✓ Stopped session and container: {}", title);
     } else {
-        println!("Session is not running: {}", inst.title);
+        println!("✓ Stopped session: {}", title);
     }
 
     Ok(())

src/cli/session.rs

@@ -26,6 +26,7 @@ struct StatusCounts {
     running: usize,
     waiting: usize,
     idle: usize,
+    stopped: usize,
     error: usize,
     total: usize,
 }
@@ -35,6 +36,7 @@ struct StatusJson {
     waiting: usize,
     running: usize,
     idle: usize,
+    stopped: usize,
     error: usize,
     total: usize,
 }
@@ -45,7 +47,9 @@ pub async fn run(profile: &str, args: StatusArgs) -> Result<()> {
 
     if instances.is_empty() {
         if args.json {
-            println!(r#"{{"waiting": 0, "running": 0, "idle": 0, "error": 0, "total": 0}}"#);
+            println!(
+                r#"{{"waiting": 0, "running": 0, "idle": 0, "stopped": 0, "error": 0, "total": 0}}"#
+            );
         } else if args.quiet {
             println!("0");
         } else {
@@ -69,6 +73,7 @@ pub async fn run(profile: &str, args: StatusArgs) -> Result<()> {
             waiting: counts.waiting,
             running: counts.running,
             idle: counts.idle,
+            stopped: counts.stopped,
             error: counts.error,
             total: counts.total,
         };
@@ -79,12 +84,18 @@ pub async fn run(profile: &str, args: StatusArgs) -> Result<()> {
         print_status_group("WAITING", "◐", Status::Waiting, &instances);
         print_status_group("RUNNING", "●", Status::Running, &instances);
         print_status_group("IDLE", "○", Status::Idle, &instances);
+        print_status_group("STOPPED", "■", Status::Stopped, &instances);
         print_status_group("ERROR", "✕", Status::Error, &instances);
         println!(
             "Total: {} sessions in profile '{}'",
             counts.total,
             storage.profile()
         );
+    } else if counts.stopped > 0 {
+        println!(
+            "{} waiting • {} running • {} idle • {} stopped",
+            counts.waiting, counts.running, counts.idle, counts.stopped
+        );
     } else {
         println!(
             "{} waiting • {} running • {} idle",
@@ -107,6 +118,7 @@ fn count_by_status(instances: &[crate::session::Instance]) -> StatusCounts {
             Status::Running => counts.running += 1,
             Status::Waiting => counts.waiting += 1,
             Status::Idle => counts.idle += 1,
+            Status::Stopped => counts.stopped += 1,
             Status::Error => counts.error += 1,
             Status::Starting => counts.idle += 1,
             Status::Deleting => {}

src/cli/status.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use super::container_interface::{ContainerConfig, ContainerRuntimeInterface};
 use super::error::{DockerError, Result};
 use super::runtime_base::RuntimeBase;
@@ -107,6 +109,10 @@ impl ContainerRuntimeInterface for AppleContainer {
     fn exec(&self, name: &str, cmd: &[&str]) -> Result<std::process::Output> {
         self.base.exec(name, cmd)
     }
+
+    fn batch_running_states(&self, _prefix: &str) -> HashMap<String, bool> {
+        HashMap::new()
+    }
 }
 
 #[cfg(test)]

src/containers/apple_container.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use super::error::Result;
 use enum_dispatch::enum_dispatch;
 
@@ -58,4 +60,8 @@ pub trait ContainerRuntimeInterface {
     fn exec_command(&self, name: &str, options: Option<&str>) -> String;
 
     fn exec(&self, name: &str, cmd: &[&str]) -> Result<std::process::Output>;
+
+    /// Check running state of all containers matching a name prefix in a single call.
+    /// Returns a map of container name -> is_running.
+    fn batch_running_states(&self, prefix: &str) -> HashMap<String, bool>;
 }

src/containers/container_interface.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use super::container_interface::{ContainerConfig, ContainerRuntimeInterface};
 use super::error::{DockerError, Result};
 use super::runtime_base::RuntimeBase;
@@ -106,6 +108,42 @@ impl ContainerRuntimeInterface for Docker {
     fn exec(&self, name: &str, cmd: &[&str]) -> Result<std::process::Output> {
         self.base.exec(name, cmd)
     }
+
+    fn batch_running_states(&self, prefix: &str) -> HashMap<String, bool> {
+        let output = self
+            .base
+            .command()
+            .args([
+                "ps",
+                "-a",
+                "--filter",
+                &format!("name={}", prefix),
+                "--format",
+                "{{.Names}}\t{{.State}}",
+            ])
+            .output();
+
+        let output = match output {
+            Ok(o) if o.status.success() => o,
+            _ => return HashMap::new(),
+        };
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        stdout
+            .lines()
+            .filter_map(|line| {
+                let mut parts = line.splitn(2, '\t');
+                let name = parts.next()?.trim();
+                let state = parts.next()?.trim();
+                // Docker's --filter name= does substring matching, so
+                // post-filter to ensure we only include exact prefix matches.
+                if name.is_empty() || !name.starts_with(prefix) {
+                    return None;
+                }
+                Some((name.to_string(), state == "running"))
+            })
+            .collect()
+    }
 }
 
 #[cfg(test)]

src/containers/docker.rs

@@ -4,6 +4,8 @@ mod docker;
 pub mod error;
 pub(crate) mod runtime_base;
 
+use std::collections::HashMap;
+
 use crate::cli::truncate_id;
 use crate::session::{Config, ContainerRuntimeName};
 use apple_container::AppleContainer;
@@ -47,6 +49,12 @@ pub fn get_container_runtime() -> ContainerRuntime {
     }
 }
 
+/// Check running state of all aoe sandbox containers in a single subprocess call.
+/// Returns a map of container name -> is_running.
+pub fn batch_container_health() -> HashMap<String, bool> {
+    get_container_runtime().batch_running_states("aoe-sandbox-")
+}
+
 pub struct DockerContainer {
     pub name: String,
     pub image: String,