@team-agent/installer 0.1.4 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",

package/src/team_agent/runtime.py

@@ -35,7 +35,15 @@ from team_agent.providers import ResumeUnavailable, get_adapter, shell_command_f
 from team_agent.routing import route_task
 from team_agent.simple_yaml import dumps
 from team_agent.spec import load_spec, validate_result_envelope, workspace_from_spec
-from team_agent.state import load_runtime_state, runtime_state_path, save_runtime_state, write_team_state
+from team_agent.state import (
+    SESSION_CAPTURE_FIELDS,
+    SESSION_STATE_FIELDS,
+    load_runtime_state,
+    normalize_agent_session_state,
+    runtime_state_path,
+    save_runtime_state,
+    write_team_state,
+)
 from team_agent.task_graph import ready_tasks, update_task_status
 from team_agent.task_graph import TASK_STATUSES
 
@@ -520,10 +528,7 @@ def _load_snapshot_state(path: Path) -> dict[str, Any] | None:
         state = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
         return None
-    for agent_state in state.get("agents", {}).values():
-        if isinstance(agent_state, dict):
-            for field in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence", "spawn_cwd"]:
-                agent_state.setdefault(field, None)
+    normalize_agent_session_state(state)
     return state
 
 
@@ -1570,8 +1575,7 @@ def _capture_agent_session(
     result = adapter.capture_session_id(agent_id, spawn_context, timeout_s=timeout_s)
     if not isinstance(result, dict) or not result.get("session_id"):
         return None
-    for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence", "spawn_cwd"]:
-        agent_state[key] = result.get(key)
+    _copy_session_metadata(agent_state, result)
     agent_state.pop("_pending_session_id", None)
     event_log.write(
         "session.captured",
@@ -1585,6 +1589,16 @@ def _capture_agent_session(
     return result
 
 
+def _copy_session_metadata(target: dict[str, Any], source: dict[str, Any]) -> None:
+    for key in SESSION_STATE_FIELDS:
+        target[key] = source.get(key)
+
+
+def _clear_session_capture_fields(target: dict[str, Any]) -> None:
+    for key in SESSION_CAPTURE_FIELDS:
+        target[key] = None
+
+
 def _attach_profile_resume_root(workspace: Path, command_agent: dict[str, Any], previous: dict[str, Any]) -> dict[str, Any]:
     profile_launch = command_agent.get("_provider_profile") or prepare_agent_profile_launch(workspace, command_agent)
     if not profile_launch:
@@ -1631,8 +1645,7 @@ def _prepare_resume_state(
     if not repaired:
         repaired = adapter.recover_session_id(agent_id, prepared, workspace, exclude_session_ids or set())
     if repaired:
-        for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence", "spawn_cwd"]:
-            prepared[key] = repaired.get(key)
+        _copy_session_metadata(prepared, repaired)
         event_log.write(
             "resume.session_repaired",
             agent_id=agent_id,
@@ -1657,8 +1670,7 @@ def _prepare_resume_state(
             f"Cannot resume agent {agent_id}: stored session {session_id} is not available. "
             "Use --allow-fresh only if losing that worker context is acceptable."
         )
-    for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence"]:
-        prepared[key] = None
+    _clear_session_capture_fields(prepared)
     event_log.write(
         "resume.session_unavailable",
         agent_id=agent_id,
@@ -1972,8 +1984,7 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
         if profile_launch.get("claude_projects_root"):
             agent_state["claude_projects_root"] = profile_launch["claude_projects_root"]
         if restart_mode == "fresh":
-            for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence"]:
-                agent_state[key] = None
+            _clear_session_capture_fields(agent_state)
             if command_agent.get("_session_id"):
                 agent_state["_pending_session_id"] = command_agent["_session_id"]
             _capture_agent_session(
@@ -2231,8 +2242,7 @@ def _start_agent_unlocked(workspace: Path, agent_id: str, force: bool, open_disp
     if profile_launch.get("claude_projects_root"):
         agent_state["claude_projects_root"] = profile_launch["claude_projects_root"]
     if start_mode == "fresh":
-        for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence"]:
-            agent_state[key] = None
+        _clear_session_capture_fields(agent_state)
         if command_agent.get("_session_id"):
             agent_state["_pending_session_id"] = command_agent["_session_id"]
         _capture_agent_session(workspace, agent_id, agent_state, event_log, timeout_s=1.5, exclude_session_ids=known_session_ids)

package/src/team_agent/state.py

@@ -10,12 +10,15 @@ from team_agent.paths import runtime_dir
 from team_agent.simple_yaml import dumps
 
 
-SESSION_STATE_FIELDS = [
+SESSION_CAPTURE_FIELDS = [
     "session_id",
     "rollout_path",
     "captured_at",
     "captured_via",
     "attribution_confidence",
+]
+SESSION_STATE_FIELDS = [
+    *SESSION_CAPTURE_FIELDS,
     "spawn_cwd",
 ]
 
@@ -24,15 +27,22 @@ def runtime_state_path(workspace: Path) -> Path:
     return runtime_dir(workspace) / "state.json"
 
 
+def normalize_agent_session_state(state: dict[str, Any]) -> None:
+    agents = state.get("agents", {})
+    if not isinstance(agents, dict):
+        return
+    for agent_state in agents.values():
+        if isinstance(agent_state, dict):
+            for field in SESSION_STATE_FIELDS:
+                agent_state.setdefault(field, None)
+
+
 def load_runtime_state(workspace: Path) -> dict[str, Any]:
     path = runtime_state_path(workspace)
     if not path.exists():
         return {"agents": {}, "tasks": [], "session_name": None}
     state = json.loads(path.read_text(encoding="utf-8"))
-    for agent_state in state.get("agents", {}).values():
-        if isinstance(agent_state, dict):
-            for field in SESSION_STATE_FIELDS:
-                agent_state.setdefault(field, None)
+    normalize_agent_session_state(state)
     return state
 
 

package/tests/run_tests.py

@@ -701,6 +701,7 @@ class RuntimeTests(unittest.TestCase):
             spec_path.write_text(dumps(spec), encoding="utf-8")
             with (
                 patch("team_agent.runtime.shutil_which", return_value="/usr/bin/tmux"),
+                patch("team_agent.providers.shutil.which", return_value="/usr/bin/codex"),
                 patch("team_agent.runtime._tmux_session_exists", return_value=False),
                 patch("team_agent.runtime._tmux_current_client_pane_info", return_value=None),
                 patch("team_agent.runtime._tmux_list_panes", return_value=[]),
@@ -709,6 +710,21 @@ class RuntimeTests(unittest.TestCase):
                 runtime.launch(spec_path, auto_approve=True)
             self.assertIn("could not locate a tmux-managed leader pane", str(ctx.exception))
 
+    def test_launch_blocks_missing_provider_command(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-provider-missing-") as tmp:
+            workspace = Path(tmp)
+            spec = _fake_spec(workspace)
+            spec["agents"][0]["provider"] = "codex"
+            spec_path = workspace / "team.spec.yaml"
+            spec_path.write_text(dumps(spec), encoding="utf-8")
+            with (
+                patch("team_agent.runtime.shutil_which", return_value="/usr/bin/tmux"),
+                patch("team_agent.providers.shutil.which", return_value=None),
+                self.assertRaises(TeamAgentRuntimeError) as ctx,
+            ):
+                runtime.launch(spec_path, auto_approve=True)
+            self.assertIn("Provider codex command 'codex' not found", str(ctx.exception))
+
     def test_worker_to_leader_direct_injection_uses_standard_payload_and_does_not_route_task(self) -> None:
         if not shutil.which("tmux"):
             self.skipTest("tmux not installed")
@@ -1310,7 +1326,8 @@ Implement bounded tasks and report result_envelope_v1.
             )
             compiled = compile_team(team, workspace / "team.spec.yaml")["spec"]
             self.assertIsNone(compiled["agents"][0]["model"])
-            preflight = runtime.preflight(team)
+            with patch("team_agent.runtime.shutil_which", return_value="/usr/bin/tmux"):
+                preflight = runtime.preflight(team)
             self.assertTrue(preflight["ok"])
             profiles = next(check for check in preflight["checks"] if check["name"] == "profiles")
             implementer = next(item for item in profiles["checks"] if item["agent_id"] == "implementer")
@@ -3126,7 +3143,11 @@ Handle fake tasks.
             cwd = os.getcwd()
             os.chdir(workspace)
             try:
-                with self.assertRaises(runtime.RuntimeError) as ctx:
+                with (
+                    patch("team_agent.runtime.shutil_which", return_value="/usr/bin/tmux"),
+                    patch("team_agent.runtime._model_checks_for_agents", return_value=[]),
+                    self.assertRaises(runtime.RuntimeError) as ctx,
+                ):
                     runtime.quick_start(team)
             finally:
                 os.chdir(cwd)
@@ -3137,7 +3158,10 @@ Handle fake tasks.
             workspace = Path(tmp)
             state = {
                 "session_name": "team-old",
-                "agents": {"fake_impl": {"status": "running", "provider": "fake", "window": "fake_impl"}},
+                "agents": {
+                    "fake_impl": {"status": "running", "provider": "fake", "window": "fake_impl"},
+                    "legacy_bad": "untouched",
+                },
                 "tasks": [],
             }
             save_runtime_state(workspace, state)
@@ -3146,6 +3170,98 @@ Handle fake tasks.
             for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence", "spawn_cwd"]:
                 self.assertIn(key, agent)
                 self.assertIsNone(agent[key])
+            self.assertEqual(loaded["agents"]["legacy_bad"], "untouched")
+
+    def test_runtime_state_missing_file_default_is_literal(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-missing-state-") as tmp:
+            self.assertEqual(load_runtime_state(Path(tmp)), {"agents": {}, "tasks": [], "session_name": None})
+
+    def test_snapshot_state_session_fields_are_backward_compatible(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-old-snapshot-") as tmp:
+            state_path = Path(tmp) / "state.json"
+            state_path.write_text(
+                json.dumps(
+                    {
+                        "session_name": "team-old",
+                        "agents": {
+                            "fake_impl": {"status": "stopped", "provider": "fake", "window": "fake_impl"},
+                            "legacy_bad": None,
+                        },
+                        "tasks": [],
+                    }
+                ),
+                encoding="utf-8",
+            )
+            loaded = runtime._load_snapshot_state(state_path)
+            self.assertIsNotNone(loaded)
+            agent = loaded["agents"]["fake_impl"]
+            for key in ["session_id", "rollout_path", "captured_at", "captured_via", "attribution_confidence", "spawn_cwd"]:
+                self.assertIn(key, agent)
+                self.assertIsNone(agent[key])
+            self.assertIsNone(loaded["agents"]["legacy_bad"])
+
+    def test_snapshot_state_malformed_json_returns_none(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-bad-snapshot-") as tmp:
+            state_path = Path(tmp) / "state.json"
+            state_path.write_text("{bad json", encoding="utf-8")
+            self.assertIsNone(runtime._load_snapshot_state(state_path))
+
+    def test_session_state_normalization_ignores_non_dict_agents_container(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-odd-agents-") as tmp:
+            workspace = Path(tmp)
+            state_path = runtime.runtime_state_path(workspace)
+            state_path.parent.mkdir(parents=True)
+            state_path.write_text(json.dumps({"session_name": "team-old", "agents": "legacy-bad", "tasks": []}), encoding="utf-8")
+
+            loaded = load_runtime_state(workspace)
+            self.assertEqual(loaded["agents"], "legacy-bad")
+
+            snapshot = runtime._load_snapshot_state(state_path)
+            self.assertIsNotNone(snapshot)
+            self.assertEqual(snapshot["agents"], "legacy-bad")
+
+    def test_copy_session_metadata_copies_known_fields_only(self) -> None:
+        full_source = {
+            "session_id": "session-123",
+            "rollout_path": "rollout.jsonl",
+            "captured_at": "2026-05-16T00:00:00+00:00",
+            "captured_via": "fs_watch",
+            "attribution_confidence": "high",
+            "spawn_cwd": "/tmp/workspace",
+            "extra": "ignored",
+        }
+        target = {"preexisting": "kept"}
+
+        runtime._copy_session_metadata(target, full_source)
+
+        for key in runtime.SESSION_STATE_FIELDS:
+            self.assertEqual(target[key], full_source[key])
+        self.assertEqual(target["preexisting"], "kept")
+        self.assertNotIn("extra", target)
+
+        missing_source = {"session_id": "session-456"}
+        runtime._copy_session_metadata(target, missing_source)
+
+        self.assertEqual(target["session_id"], "session-456")
+        for key in runtime.SESSION_STATE_FIELDS:
+            if key != "session_id":
+                self.assertIsNone(target[key])
+
+    def test_clear_session_capture_fields_preserves_spawn_cwd(self) -> None:
+        target = {
+            "session_id": "session-123",
+            "rollout_path": "rollout.jsonl",
+            "captured_at": "2026-05-16T00:00:00+00:00",
+            "captured_via": "fs_watch",
+            "attribution_confidence": "high",
+            "spawn_cwd": "/tmp/workspace",
+        }
+
+        runtime._clear_session_capture_fields(target)
+
+        for key in runtime.SESSION_CAPTURE_FIELDS:
+            self.assertIsNone(target[key])
+        self.assertEqual(target["spawn_cwd"], "/tmp/workspace")
 
     def test_claude_adapter_predetermines_session_id_and_resume_command(self) -> None:
         adapter = get_adapter("claude_code")
@@ -3249,6 +3365,65 @@ Handle fake tasks.
             self.assertTrue(any(e["event"] == "resume.session_unverified" for e in events))
             self.assertTrue(any(e["event"] == "resume.session_repaired" for e in events))
 
+    def test_prepare_resume_state_copies_adapter_repaired_session_metadata(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-adapter-repair-") as tmp:
+            workspace = Path(tmp)
+            event_log = runtime.EventLog(workspace)
+            adapter = Mock()
+            adapter.session_is_resumable.return_value = False
+            adapter.recover_session_id.return_value = {
+                "session_id": "repaired-session",
+                "rollout_path": "repaired.jsonl",
+                "captured_at": "2026-05-16T00:00:00+00:00",
+                "captured_via": "fs_repair",
+                "attribution_confidence": "high",
+                "spawn_cwd": str(workspace / "repaired-cwd"),
+            }
+            previous = {
+                "status": "stopped",
+                "provider": "claude_code",
+                "spawn_cwd": str(workspace / "old-cwd"),
+            }
+
+            repaired = runtime._prepare_resume_state(workspace, "analyst", previous, adapter, event_log)
+
+            self.assertEqual(repaired["session_id"], "repaired-session")
+            self.assertEqual(repaired["rollout_path"], "repaired.jsonl")
+            self.assertEqual(repaired["captured_at"], "2026-05-16T00:00:00+00:00")
+            self.assertEqual(repaired["captured_via"], "fs_repair")
+            self.assertEqual(repaired["attribution_confidence"], "high")
+            self.assertEqual(repaired["spawn_cwd"], str(workspace / "repaired-cwd"))
+
+    def test_prepare_resume_state_allow_fresh_clears_capture_fields_and_preserves_spawn_cwd(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="team-agent-resume-allow-fresh-") as tmp:
+            workspace = Path(tmp)
+            adapter = Mock()
+            adapter.session_is_resumable.return_value = False
+            adapter.recover_session_id.return_value = None
+            previous = {
+                "status": "stopped",
+                "provider": "claude_code",
+                "session_id": "stale-session",
+                "rollout_path": "stale.jsonl",
+                "captured_at": "2026-05-16T00:00:00+00:00",
+                "captured_via": "fs_watch",
+                "attribution_confidence": "high",
+                "spawn_cwd": str(workspace / "old-cwd"),
+            }
+
+            prepared = runtime._prepare_resume_state(
+                workspace,
+                "analyst",
+                previous,
+                adapter,
+                runtime.EventLog(workspace),
+                allow_fresh_on_resume_failure=True,
+            )
+
+            for key in runtime.SESSION_CAPTURE_FIELDS:
+                self.assertIsNone(prepared[key])
+            self.assertEqual(prepared["spawn_cwd"], str(workspace / "old-cwd"))
+
     def test_prepare_resume_state_repairs_claude_session_from_pending_isolated_id(self) -> None:
         adapter = get_adapter("claude_code")
         with tempfile.TemporaryDirectory(prefix="team-agent-claude-pending-repair-") as tmp:
@@ -3318,12 +3493,19 @@ Handle fake tasks.
                 "spawn_cwd": str(workspace),
                 "spawned_at": "2026-05-16T00:00:00+00:00",
                 "claude_projects_root": str(projects_root),
+                "_pending_session_id": "pending-session",
             }
             with patch("team_agent.runtime.get_adapter", return_value=adapter):
                 result = runtime._capture_agent_session(workspace, "analyst", agent_state, runtime.EventLog(workspace), timeout_s=0)
 
             self.assertEqual(result["session_id"], "session-123")
             self.assertEqual(seen["claude_projects_root"], str(projects_root))
+            for key in runtime.SESSION_STATE_FIELDS:
+                self.assertEqual(agent_state[key], result[key])
+            self.assertNotIn("_pending_session_id", agent_state)
+            event = _events(workspace)[-1]
+            self.assertEqual(event["event"], "session.captured")
+            self.assertEqual(event["session_id"], "session-123")
 
     def test_startup_verify_rejects_window_that_disappears_immediately(self) -> None:
         with tempfile.TemporaryDirectory(prefix="team-agent-startup-stability-") as tmp:
@@ -3551,16 +3733,7 @@ Handle fake tasks.
             save_runtime_state(workspace, state)
 
             started_windows: set[str] = set()
-
-            def fake_run_cmd(args: list[str], timeout: int = 20):
-                proc = Mock(returncode=1 if args[:2] == ["tmux", "has-session"] else 0, stdout="", stderr="")
-                if args[:3] == ["tmux", "new-session", "-d"]:
-                    started_windows.add(args[6])
-                elif args[:2] == ["tmux", "new-window"]:
-                    started_windows.add(args[5])
-                elif args[:3] == ["tmux", "list-windows", "-t"]:
-                    proc.stdout = "\n".join(sorted(started_windows))
-                return proc
+            fake_run_cmd = _make_fake_tmux_window_run_cmd(started_windows)
 
             with patch("team_agent.runtime.run_cmd", side_effect=fake_run_cmd), patch(
                 "team_agent.runtime.start_coordinator", return_value={"ok": True, "pid": 321, "status": "started"}
@@ -3578,6 +3751,10 @@ Handle fake tasks.
             ):
                 fresh = runtime.restart(workspace)
             self.assertEqual(fresh["agents"][0]["restart_mode"], "fresh")
+            fresh_agent = load_runtime_state(workspace)["agents"]["fake_impl"]
+            for key in runtime.SESSION_CAPTURE_FIELDS:
+                self.assertIsNone(fresh_agent[key])
+            self.assertEqual(fresh_agent["spawn_cwd"], str(workspace))
             self.assertTrue(any(e["event"] == "restart.fresh_spawn" for e in _events(workspace)))
 
     def test_restart_requires_team_selector_when_multiple_snapshots_exist(self) -> None:
@@ -3616,16 +3793,7 @@ Handle fake tasks.
             self.assertIn("team-beta", str(ctx.exception))
 
             started_windows: set[str] = set()
-
-            def fake_run_cmd(args: list[str], timeout: int = 20):
-                proc = Mock(returncode=1 if args[:2] == ["tmux", "has-session"] else 0, stdout="", stderr="")
-                if args[:3] == ["tmux", "new-session", "-d"]:
-                    started_windows.add(args[6])
-                elif args[:2] == ["tmux", "new-window"]:
-                    started_windows.add(args[5])
-                elif args[:3] == ["tmux", "list-windows", "-t"]:
-                    proc.stdout = "\n".join(sorted(started_windows))
-                return proc
+            fake_run_cmd = _make_fake_tmux_window_run_cmd(started_windows)
 
             with patch("team_agent.runtime.run_cmd", side_effect=fake_run_cmd), patch(
                 "team_agent.runtime.start_coordinator", return_value={"ok": True, "pid": 321, "status": "started"}
@@ -3663,16 +3831,7 @@ Handle fake tasks.
             )
             started_windows: set[str] = set()
             display_snapshots: list[set[str]] = []
-
-            def fake_run_cmd(args: list[str], timeout: int = 20):
-                proc = Mock(returncode=1 if args[:2] == ["tmux", "has-session"] else 0, stdout="", stderr="")
-                if args[:3] == ["tmux", "new-session", "-d"]:
-                    started_windows.add(args[6])
-                elif args[:2] == ["tmux", "new-window"]:
-                    started_windows.add(args[5])
-                elif args[:3] == ["tmux", "list-windows", "-t"]:
-                    proc.stdout = "\n".join(sorted(started_windows))
-                return proc
+            fake_run_cmd = _make_fake_tmux_window_run_cmd(started_windows)
 
             def fake_open_display(workspace_arg, session_name, window_name, agent, event_log):
                 display_snapshots.append(set(started_windows))
@@ -3892,6 +4051,10 @@ Handle fake tasks.
             self.assertTrue(result["ok"])
             self.assertEqual(result["start_mode"], "fresh")
             self.assertEqual(start_modes, ["resumed", "fresh"])
+            agent_state = load_runtime_state(workspace)["agents"]["fake_impl"]
+            for key in runtime.SESSION_CAPTURE_FIELDS:
+                self.assertIsNone(agent_state[key])
+            self.assertEqual(agent_state["spawn_cwd"], str(workspace))
             events = _events(workspace)
             self.assertTrue(any(e["event"] == "start_agent.window_missing_after_start" for e in events))
             self.assertTrue(any(e["event"] == "start_agent.resume_window_missing_fallback_fresh" for e in events))
@@ -5300,6 +5463,20 @@ def _fake_spec(workspace: Path) -> dict:
     return spec
 
 
+def _make_fake_tmux_window_run_cmd(started_windows: set[str]):
+    def fake_run_cmd(args: list[str], timeout: int = 20):
+        proc = Mock(returncode=1 if args[:2] == ["tmux", "has-session"] else 0, stdout="", stderr="")
+        if args[:3] == ["tmux", "new-session", "-d"]:
+            started_windows.add(args[6])
+        elif args[:2] == ["tmux", "new-window"]:
+            started_windows.add(args[5])
+        elif args[:3] == ["tmux", "list-windows", "-t"]:
+            proc.stdout = "\n".join(sorted(started_windows))
+        return proc
+
+    return fake_run_cmd
+
+
 def _write_doc_team(workspace: Path) -> Path:
     team = workspace / ".team" / "current"
     (team / "agents").mkdir(parents=True, exist_ok=True)