feat(cli): use wait flag for sandbox deletion

Signed-off-by: Evan Lezar <elezar@nvidia.com>

Author: elezar

.agents/skills/openshell-cli/SKILL.md

@@ -359,15 +359,15 @@ openshell logs my-sandbox --since 5m
 openshell sandbox delete my-sandbox
 openshell sandbox delete sandbox-1 sandbox-2 sandbox-3   # Multiple at once
 openshell sandbox delete --all
-openshell sandbox delete my-sandbox --no-wait            # Async acknowledgment only
+openshell sandbox delete my-sandbox --wait=false         # Async acknowledgment only
 ```
 
 Delete waits for terminal absence by default, so a following workspace delete
-can run immediately. Use `--no-wait` only when the caller does not depend on
+can run immediately. Use `--wait=false` only when the caller does not depend on
 cleanup completion. Override the default 300-second per-sandbox lifecycle
 timeout with a positive `--timeout <seconds>` value or
 `OPENSHELL_LIFECYCLE_TIMEOUT`; a timeout reports an error while gateway
-deletion continues asynchronously.
+deletion continues asynchronously. The timeout is ignored when `--wait=false`.
 
 ### Stop and start sandboxes
 

.agents/skills/openshell-cli/cli-reference.md

@@ -276,7 +276,7 @@ port forwards and waits for terminal absence by default.
 | Flag | Default | Description |
 |------|---------|-------------|
 | `--all` | false | Delete every sandbox in the selected workspace |
-| `--no-wait` | false | Return after the gateway accepts deletion |
+| `--wait <true\|false>` | true | Wait for terminal deletion; `false` returns after gateway acknowledgement |
 | `--timeout <SECONDS>` | 300 | Positive per-sandbox terminal deletion wait timeout |
 
 ### `openshell sandbox stop [name]`

crates/openshell-cli/src/main.rs

@@ -1544,9 +1544,17 @@ enum SandboxCommands {
         #[arg(long, conflicts_with = "names")]
         all: bool,
 
-        /// Return after the gateway accepts the deletion request.
-        #[arg(long, conflicts_with = "timeout")]
-        no_wait: bool,
+        /// Wait for each sandbox to reach terminal deletion.
+        ///
+        /// Pass `--wait=false` to return after the gateway accepts deletion.
+        #[arg(
+            long,
+            default_value_t = true,
+            default_missing_value = "true",
+            num_args = 0..=1,
+            action = clap::ArgAction::Set,
+        )]
+        wait: bool,
 
         /// Positive seconds to wait for each sandbox to reach terminal deletion.
         #[arg(long, value_name = "SECONDS", value_parser = clap::value_parser!(u64).range(1..))]
@@ -3217,7 +3225,7 @@ async fn run_async() -> Result<()> {
                         SandboxCommands::Delete {
                             names,
                             all,
-                            no_wait,
+                            wait,
                             timeout,
                         } => {
                             run::sandbox_delete(
@@ -3228,7 +3236,7 @@ async fn run_async() -> Result<()> {
                                 &tls,
                                 &ctx.name,
                                 run::SandboxDeleteOptions {
-                                    no_wait,
+                                    wait,
                                     timeout: timeout.map(Duration::from_secs),
                                 },
                             )
@@ -4583,26 +4591,37 @@ mod tests {
     }
 
     #[test]
-    fn sandbox_delete_waits_by_default_and_accepts_async_options() {
+    fn sandbox_delete_waits_by_default_and_accepts_wait_options() {
         let default_delete = Cli::try_parse_from(["openshell", "sandbox", "delete", "demo"])
             .expect("sandbox delete should parse");
         assert!(matches!(
             default_delete.command,
             Some(Commands::Sandbox {
                 command: Some(SandboxCommands::Delete {
-                    no_wait: false,
+                    wait: true,
                     timeout: None,
                     ..
                 })
             })
         ));
 
-        let no_wait = Cli::try_parse_from(["openshell", "sandbox", "delete", "demo", "--no-wait"])
-            .expect("sandbox delete --no-wait should parse");
+        let async_delete =
+            Cli::try_parse_from(["openshell", "sandbox", "delete", "demo", "--wait=false"])
+                .expect("sandbox delete --wait=false should parse");
         assert!(matches!(
-            no_wait.command,
+            async_delete.command,
             Some(Commands::Sandbox {
-                command: Some(SandboxCommands::Delete { no_wait: true, .. })
+                command: Some(SandboxCommands::Delete { wait: false, .. })
+            })
+        ));
+
+        let explicit_wait =
+            Cli::try_parse_from(["openshell", "sandbox", "delete", "demo", "--wait"])
+                .expect("sandbox delete --wait should parse");
+        assert!(matches!(
+            explicit_wait.command,
+            Some(Commands::Sandbox {
+                command: Some(SandboxCommands::Delete { wait: true, .. })
             })
         ));
 
@@ -4613,26 +4632,33 @@ mod tests {
             timeout.command,
             Some(Commands::Sandbox {
                 command: Some(SandboxCommands::Delete {
-                    no_wait: false,
+                    wait: true,
                     timeout: Some(42),
                     ..
                 })
             })
         ));
 
-        assert!(
-            Cli::try_parse_from([
-                "openshell",
-                "sandbox",
-                "delete",
-                "demo",
-                "--no-wait",
-                "--timeout",
-                "42",
-            ])
-            .is_err(),
-            "--no-wait and --timeout should conflict"
-        );
+        let asynchronous = Cli::try_parse_from([
+            "openshell",
+            "sandbox",
+            "delete",
+            "demo",
+            "--wait=false",
+            "--timeout",
+            "42",
+        ])
+        .expect("--wait=false should override the timeout");
+        assert!(matches!(
+            asynchronous.command,
+            Some(Commands::Sandbox {
+                command: Some(SandboxCommands::Delete {
+                    wait: false,
+                    timeout: Some(42),
+                    ..
+                })
+            })
+        ));
         assert!(
             Cli::try_parse_from(["openshell", "sandbox", "delete", "demo", "--timeout", "0",])
                 .is_err(),

crates/openshell-cli/src/run.rs

@@ -2454,14 +2454,23 @@ fn format_provider_attachment_table(providers: &[Provider], color: bool) -> Stri
 }
 
 /// Controls whether sandbox deletion waits for durable absence.
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy)]
 pub struct SandboxDeleteOptions {
-    /// Return after the gateway acknowledges an asynchronous delete.
-    pub no_wait: bool,
+    /// Wait for terminal absence after deletion is acknowledged.
+    pub wait: bool,
     /// Override the per-sandbox lifecycle timeout. The environment/default applies when unset.
     pub timeout: Option<Duration>,
 }
 
+impl Default for SandboxDeleteOptions {
+    fn default() -> Self {
+        Self {
+            wait: true,
+            timeout: None,
+        }
+    }
+}
+
 /// Delete a sandbox by name, or all sandboxes when `all` is true.
 pub async fn sandbox_delete(
     server: &str,
@@ -2529,7 +2538,7 @@ pub async fn sandbox_delete(
         let deletion_pending = response.into_inner().deleted;
         clear_last_sandbox_if_matches(gateway, workspace, name);
 
-        if options.no_wait && deletion_pending {
+        if !options.wait && deletion_pending {
             println!(
                 "{} Deletion requested for sandbox {name}",
                 "✓".green().bold()

crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs

@@ -1251,7 +1251,7 @@ async fn sandbox_delete_waits_for_terminal_absence() {
         &test_tls(&server),
         "openshell",
         run::SandboxDeleteOptions {
-            no_wait: false,
+            wait: true,
             timeout: Some(Duration::from_secs(2)),
         },
     )
@@ -1269,7 +1269,7 @@ async fn sandbox_delete_waits_for_terminal_absence() {
 }
 
 #[tokio::test]
-async fn sandbox_delete_no_wait_returns_without_polling() {
+async fn sandbox_delete_wait_false_returns_without_polling() {
     let server = run_server().await;
     let xdg_dir = tempfile::tempdir().unwrap();
     let fake_ssh_dir = tempfile::tempdir().unwrap();
@@ -1288,12 +1288,12 @@ async fn sandbox_delete_no_wait_returns_without_polling() {
         &test_tls(&server),
         "openshell",
         run::SandboxDeleteOptions {
-            no_wait: true,
-            timeout: None,
+            wait: false,
+            timeout: Some(Duration::from_secs(1)),
         },
     )
     .await
-    .expect("--no-wait behavior should return after acknowledgment");
+    .expect("--wait=false behavior should return after acknowledgment");
 
     assert_eq!(
         server
@@ -1325,7 +1325,7 @@ async fn sandbox_delete_reports_timeout_and_unexpected_lookup_errors() {
         &test_tls(&server),
         "openshell",
         run::SandboxDeleteOptions {
-            no_wait: false,
+            wait: true,
             timeout: Some(Duration::from_millis(150)),
         },
     )
@@ -1350,7 +1350,7 @@ async fn sandbox_delete_reports_timeout_and_unexpected_lookup_errors() {
         &test_tls(&server),
         "openshell",
         run::SandboxDeleteOptions {
-            no_wait: false,
+            wait: true,
             timeout: Some(Duration::from_secs(1)),
         },
     )

docs/sandboxes/manage-sandboxes.mdx

@@ -534,11 +534,12 @@ openshell sandbox delete my-sandbox
 
 The CLI waits until the sandbox is durably absent before it reports success, so
 you can safely compose deletion with operations such as workspace deletion. Use
-`--no-wait` to return after the gateway accepts the asynchronous request. Set
-`--timeout <seconds>` with a positive value to override the terminal wait
+`--wait=false` to return after the gateway accepts the asynchronous request.
+Set `--timeout <seconds>` with a positive value to override the terminal wait
 timeout for each sandbox; otherwise the CLI uses
 `OPENSHELL_LIFECYCLE_TIMEOUT`, which defaults to 300 seconds. A timeout returns
-an error while deletion continues asynchronously.
+an error while deletion continues asynchronously. The timeout is ignored when
+`--wait=false`.
 
 ## Sandbox Lifecycle