chore: sync workspace changes

engine/packages/sandbox-daemon/tests/agents.rs

@@ -1,7 +1,11 @@
 use std::collections::HashMap;
 
-use sandbox_daemon_core::agents::{AgentId, AgentManager, InstallOptions, SpawnOptions};
-use sandbox_daemon_core::credentials::{extract_all_credentials, CredentialExtractionOptions};
+use sandbox_daemon_agent_management::agents::{
+    AgentError, AgentId, AgentManager, InstallOptions, SpawnOptions,
+};
+use sandbox_daemon_agent_management::credentials::{
+    extract_all_credentials, CredentialExtractionOptions,
+};
 
 fn build_env() -> HashMap<String, String> {
     let options = CredentialExtractionOptions::new();
@@ -21,6 +25,10 @@ fn amp_configured() -> bool {
     home.join(".amp").join("config.json").exists()
 }
 
+fn prompt_ok(label: &str) -> String {
+    format!("Respond with exactly the text {label} and nothing else.")
+}
+
 #[test]
 fn test_agents_install_version_spawn() -> Result<(), Box<dyn std::error::Error>> {
     let temp_dir = tempfile::tempdir()?;
@@ -32,11 +40,19 @@ fn test_agents_install_version_spawn() -> Result<(), Box<dyn std::error::Error>>
     for agent in agents {
         let install = manager.install(agent, InstallOptions::default())?;
         assert!(install.path.exists(), "expected install for {agent}");
+        assert!(manager.is_installed(agent), "expected is_installed for {agent}");
+        manager.install(
+            agent,
+            InstallOptions {
+                reinstall: true,
+                version: None,
+            },
+        )?;
         let version = manager.version(agent)?;
         assert!(version.is_some(), "expected version for {agent}");
 
         if agent != AgentId::Amp || amp_configured() {
-            let mut spawn = SpawnOptions::new("Respond with exactly the text OK and nothing else.");
+            let mut spawn = SpawnOptions::new(prompt_ok("OK"));
             spawn.env = env.clone();
             let result = manager.spawn(agent, spawn)?;
             assert!(
@@ -44,8 +60,53 @@ fn test_agents_install_version_spawn() -> Result<(), Box<dyn std::error::Error>>
                 "spawn failed for {agent}: {}",
                 result.stderr
             );
-            let output = format!("{}{}", result.stdout, result.stderr);
+            assert!(
+                !result.events.is_empty(),
+                "expected events for {agent} but got none"
+            );
+            assert!(
+                result.session_id.is_some(),
+                "expected session id for {agent}"
+            );
+            let combined = format!("{}{}", result.stdout, result.stderr);
+            let output = result.result.clone().unwrap_or(combined);
             assert!(output.contains("OK"), "expected OK for {agent}, got: {output}");
+
+            if agent == AgentId::Claude || agent == AgentId::Opencode || (agent == AgentId::Amp && amp_configured()) {
+                let mut resume = SpawnOptions::new(prompt_ok("OK2"));
+                resume.env = env.clone();
+                resume.session_id = result.session_id.clone();
+                let resumed = manager.spawn(agent, resume)?;
+                assert!(
+                    resumed.status.success(),
+                    "resume spawn failed for {agent}: {}",
+                    resumed.stderr
+                );
+                let combined = format!("{}{}", resumed.stdout, resumed.stderr);
+                let output = resumed.result.clone().unwrap_or(combined);
+                assert!(output.contains("OK2"), "expected OK2 for {agent}, got: {output}");
+            } else if agent == AgentId::Codex {
+                let mut resume = SpawnOptions::new(prompt_ok("OK2"));
+                resume.env = env.clone();
+                resume.session_id = result.session_id.clone();
+                let err = manager.spawn(agent, resume).expect_err("expected resume error for codex");
+                assert!(matches!(err, AgentError::ResumeUnsupported { .. }));
+            }
+
+            if agent == AgentId::Claude || agent == AgentId::Codex {
+                let mut plan = SpawnOptions::new(prompt_ok("OK3"));
+                plan.env = env.clone();
+                plan.permission_mode = Some("plan".to_string());
+                let planned = manager.spawn(agent, plan)?;
+                assert!(
+                    planned.status.success(),
+                    "plan spawn failed for {agent}: {}",
+                    planned.stderr
+                );
+                let combined = format!("{}{}", planned.stdout, planned.stderr);
+                let output = planned.result.clone().unwrap_or(combined);
+                assert!(output.contains("OK3"), "expected OK3 for {agent}, got: {output}");
+            }
         }
     }