fix: resolve factory integration test failures

Fix 3 failing tests in factory_integration_tests:

1. pool_tests::test_pool_warm_agents
   - Use different roles (Developer, Tester) to ensure separate agents
   - Previous test reused same agent due to warm pool

2. workspace_tests::test_workspace_isolation_path_validation
   - Create file before checking path allowance
   - is_path_allowed() uses canonicalize() which requires existing path

3. workspace_tests::test_workspace_list_and_cleanup
   - Fix list_workspaces() parsing logic for role-uuid format
   - Role may contain dashes (e.g., 'agent-0'), need to properly parse UUID
   - UUID has 5 dash-separated groups, use rsplitn(6, '-') to extract correctly

All 22 factory_integration_tests now pass.

Author: louisdevzz

src/factory/workspace/manager.rs

@@ -182,10 +182,20 @@ impl WorkspaceManager {
                 if path.is_dir() {
                     if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
                         // Parse workspace directory name (format: "role-uuid")
-                        if let Some((role, uuid_str)) = name.rsplit_once('-') {
-                            if let Ok(uuid) = Uuid::parse_str(uuid_str) {
+                        // UUID has 5 groups separated by dashes, so we need to find
+                        // where the UUID starts (after the 4th dash from the right)
+                        let parts: Vec<&str> = name.rsplitn(6, '-').collect();
+                        if parts.len() >= 5 {
+                            // Reconstruct UUID from last 5 parts (in reverse order due to rsplitn)
+                            let uuid_parts: Vec<&str> = parts[..5].iter().rev().copied().collect();
+                            let uuid_str = uuid_parts.join("-");
+                            if let Ok(uuid) = Uuid::parse_str(&uuid_str) {
+                                // Role is everything before the UUID
+                                let role_parts: Vec<&str> =
+                                    parts[5..].iter().rev().copied().collect();
+                                let role = role_parts.join("-");
                                 workspaces.push(WorkspaceId {
-                                    agent_role: role.to_string(),
+                                    agent_role: role,
                                     agent_uuid: uuid,
                                 });
                             }

tests/factory/pool_tests.rs

@@ -237,15 +237,17 @@ async fn test_pool_warm_agents() {
     let pool = AgentPool::with_config(workspace_manager, config);
 
     // Acquire and release to create warm agents
-    let agent_config = AgentConfig::for_role(AgentRole::Developer);
+    // Use different roles to ensure we get separate agents
+    let agent_config1 = AgentConfig::for_role(AgentRole::Developer);
     let id1 = pool
-        .acquire_agent(AgentRole::Developer, agent_config.clone())
+        .acquire_agent(AgentRole::Developer, agent_config1)
         .await
         .unwrap();
     pool.release_agent(id1).unwrap();
 
+    let agent_config2 = AgentConfig::for_role(AgentRole::Tester);
     let id2 = pool
-        .acquire_agent(AgentRole::Developer, agent_config)
+        .acquire_agent(AgentRole::Tester, agent_config2)
         .await
         .unwrap();
     pool.release_agent(id2).unwrap();

tests/factory/workspace_tests.rs

@@ -56,6 +56,9 @@ async fn test_workspace_isolation_path_validation() {
 
     // Valid paths within workspace should be allowed
     let valid_path = workspace.paths.sandbox.join("project/src/main.rs");
+    // Create the file so canonicalize() works
+    std::fs::create_dir_all(valid_path.parent().unwrap()).unwrap();
+    std::fs::write(&valid_path, "test content").unwrap();
     assert!(isolation.is_path_allowed(&valid_path));
 
     // Invalid path trying to escape sandbox - this might not exist so it returns false