@team-agent/installer 0.2.3 → 0.2.5

package/src/team_agent/provider_state/registry.py

@@ -0,0 +1,118 @@
+"""Per-CLI idle/turn-state registry — PURE INFRA DATA (Gap 32 C7).
+
+This module is data only: session-file locations, turn-lifecycle marker
+descriptions, and per-CLI error white/black lists. It carries no predicate,
+abnormal, or wake logic. Adding a new provider is one entry here plus one
+reader module under ``provider_state/``; the neutral layers never change.
+
+The registry is shipped with the runtime as infra data — it is NOT
+user-mandatory configuration and is never loaded from a workspace.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Each entry is consumed by the matching provider reader. The neutral
+# idle_predicate / abnormal_track / wake modules never read provider names.
+_PROVIDER_REGISTRY: dict[str, dict[str, Any]] = {
+    "claude": {
+        "kind": "claude",
+        "reader_module": "team_agent.provider_state.claude",
+        "source": "infra",
+        "file_location": {
+            "root": "~/.claude/projects",
+            "layout": "<cwd-slug>/<session_id>.jsonl",
+            "format": "transcript-jsonl",
+        },
+        "event_types": {
+            "turn_open": "assistant message.stop_reason == tool_use",
+            "turn_complete": "assistant message.stop_reason == end_turn",
+            "interrupted": "user text == [Request interrupted by user]",
+            "tool_error": "user tool_result is_error == true",
+            "api_error": "system subtype == api_error and level == error",
+        },
+        "metadata_ignore": [
+            "stop_hook_summary",
+            "turn_duration",
+            "last-prompt",
+            "ai-title",
+            "permission-mode",
+            "file-history-snapshot",
+            "queue-operation",
+        ],
+        "error_whitelist": [],
+        "error_blacklist": [
+            "api_error",
+            "rate limit",
+            "overloaded",
+            "traceback",
+            "panic",
+        ],
+        "error_lists": {
+            "whitelist": [],
+            "blacklist": ["api_error", "rate limit", "overloaded", "traceback", "panic"],
+        },
+    },
+    "codex": {
+        "kind": "codex",
+        "reader_module": "team_agent.provider_state.codex",
+        "source": "infra",
+        "file_location": {
+            "root": "~/.codex/sessions",
+            "layout": "<YYYY>/<MM>/<DD>/rollout-<stamp>-<session_id>.jsonl",
+            "format": "rollout-jsonl",
+        },
+        "event_types": {
+            "turn_open": "event_msg payload.type == task_started",
+            "turn_complete": "event_msg payload.type == task_complete",
+            "interrupted": "event_msg payload.type == turn_aborted and reason == interrupted",
+            "failed": "app-server turn.status == failed",
+            "approval": "app-server method endswith requestApproval",
+        },
+        "metadata_ignore": [
+            "token_count",
+            "agent_message",
+            "context_compacted",
+            "mcp_tool_call_end",
+            "patch_apply_end",
+            "web_search_end",
+            "thread_goal_updated",
+        ],
+        "error_whitelist": [],
+        "error_blacklist": [
+            "failed",
+            "api error",
+            "rate limit",
+            "overloaded",
+            "traceback",
+            "panic",
+        ],
+        "error_lists": {
+            "whitelist": [],
+            "blacklist": ["failed", "api error", "rate limit", "overloaded", "traceback", "panic"],
+        },
+    },
+}
+
+
+def get_provider_registry(provider: str | None = None) -> Any:
+    """Return the infra registry.
+
+    With no argument, returns a copy of the whole per-CLI registry mapping.
+    With a provider name, returns that provider's entry (or ``None``).
+    """
+    if provider is None:
+        return {name: _copy_entry(entry) for name, entry in _PROVIDER_REGISTRY.items()}
+    entry = _PROVIDER_REGISTRY.get(provider)
+    return _copy_entry(entry) if entry is not None else None
+
+
+def supported_providers() -> list[str]:
+    return sorted(_PROVIDER_REGISTRY)
+
+
+def _copy_entry(entry: dict[str, Any]) -> dict[str, Any]:
+    import copy
+
+    return copy.deepcopy(entry)

package/src/team_agent/restart/orchestration.py

@@ -8,18 +8,19 @@ from typing import Any
 from team_agent.events import EventLog
 from team_agent.message_store import MessageStore
 from team_agent.permissions import resolve_permissions
+from team_agent.display.backend import display_backend_has_worker_views, display_backend_opens_before_leader_rebind, resolve_restart_display_backend
+from team_agent.display.close import close_team_display_backends
+from team_agent.display.rebuild import rebuild_restart_display_after_rebind
 from team_agent.restart.selection import select_restart_state
 from team_agent.restart.snapshot import save_team_runtime_snapshot
 from team_agent.spec import load_spec
 from team_agent.state import (
     check_team_owner,
-    load_runtime_state,
     populate_team_owner_from_env,
     save_runtime_state,
     write_team_state,
 )
 
-
 def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None) -> dict[str, Any]:
     # Lazy-import everything from team_agent.runtime so existing tests that
     # patch runtime.shell_resume_command_for_agent / runtime.run_cmd /
@@ -27,7 +28,6 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
     # at call time. Runtime re-exports the provider helpers, so this also
     # routes through the providers module without binding it directly.
     from team_agent.runtime import (
-        GHOSTTY_DISPLAY_BACKENDS,
         ResumeUnavailable,
         RuntimeError,
         _attach_profile_resume_root,
@@ -35,7 +35,6 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
         _capture_agent_session,
         _clear_session_capture_fields,
         _close_ghostty_display,
-        _close_ghostty_workspace,
         _compile_team_dir_spec,
         _effective_runtime_config,
         _ensure_agent_start_requirements,
@@ -83,7 +82,7 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
         )
         raise RuntimeError(_tmux_session_conflict_error(session_name))
     runtime_cfg = _effective_runtime_config(spec.get("runtime", {}))
-    display_backend = spec.get("runtime", {}).get("display_backend", state.get("display_backend", "none"))
+    display_backend = resolve_restart_display_backend(spec, state, event_log)
     # Stage 7 S5 — Slice 6 lifecycle atomicity contract: compute restart_agents
     # early so we can pre-validate resumability BEFORE any destructive teardown
     # (ghostty close, tmux session creation). Without --allow-fresh, every
@@ -146,7 +145,7 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
             "allow_fresh": bool(allow_fresh),
             "error": _format_atomic_refusal_error(refused),
         }
-    _close_ghostty_workspace(state, event_log)
+    close_team_display_backends(state, event_log)
     for agent_id, agent_state in state.get("agents", {}).items():
         _close_ghostty_display(agent_id, agent_state, event_log)
     state["display_backend"] = display_backend
@@ -330,7 +329,7 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
                 exclude_session_ids=known_session_ids,
                 raise_on_missed=False,
             )
-        if display_backend in GHOSTTY_DISPLAY_BACKENDS:
+        if display_backend_has_worker_views(display_backend):
             display_jobs.append((agent["id"], agent))
         new_agents[agent["id"]] = agent_state
         restarted.append(
@@ -341,7 +340,7 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
                 "display_target": None,
             }
         )
-    display_results = _open_worker_displays(workspace, session_name, display_jobs, event_log, display_backend)
+    display_results = _open_worker_displays(workspace, session_name, display_jobs, event_log, display_backend) if display_backend_opens_before_leader_rebind(display_backend) else {}
     for agent_id, display in display_results.items():
         if agent_id in new_agents:
             new_agents[agent_id]["display"] = display
@@ -367,7 +366,8 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
     write_team_state(workspace, spec, state)
     from team_agent.leader import autobind_leader_receiver_from_env
     leader_provider = str(spec.get("leader", {}).get("provider") or "codex")
-    autobind_leader_receiver_from_env(workspace, leader_provider, source="restart")
+    rebound_receiver = autobind_leader_receiver_from_env(workspace, leader_provider, source="restart")
+    rebuild_restart_display_after_rebind(display_backend, workspace, session_name, spec, event_log, restarted, receiver=rebound_receiver)
     coordinator = start_coordinator(workspace)
     event_log.write("restart.complete", session=session_name, agents=restarted, coordinator=coordinator)
     return {"ok": True, "session_name": session_name, "agents": restarted, "coordinator": coordinator}

package/src/team_agent/runtime.py

@@ -39,10 +39,12 @@ from team_agent.providers import (
     shell_resume_command_for_agent,
 )
 from team_agent.display import (
+    GHOSTTY_DISPLAY_BACKENDS,
     GHOSTTY_WORKSPACE_PANES_PER_WINDOW,
     close_ghostty_display as _close_ghostty_display,
     close_ghostty_workspace as _close_ghostty_workspace,
     close_ghostty_workspace_slot as _close_ghostty_workspace_slot,
+    close_team_display_backends as _close_team_display_backends,
     ghostty_app_exists as _ghostty_app_exists,
     ghostty_attach_args as _ghostty_attach_args,
     ghostty_command as _ghostty_command,
@@ -65,6 +67,7 @@ from team_agent.display import (
     set_ghostty_workspace_pane_title as _set_ghostty_workspace_pane_title,
 )
 from team_agent.leader import (
+    LEADER_OWNERSHIP_LOCK,
     attach_leader,
     attach_leader_to_state as _attach_leader_to_state,
     claim_leader,
@@ -456,7 +459,6 @@ TMUX_PANE_FORMAT = (
     "#{pane_current_path}\t#{session_attached}\t#{pane_in_mode}"
 )
 HEALTH_STATUSES = {"RUNNING", "IDLE", "AWAITING_APPROVAL", "BLOCKED", "ERROR", "DONE"}
-GHOSTTY_DISPLAY_BACKENDS = {"ghostty", "ghostty_window", "ghostty_workspace"}
 DELIVERY_CAPTURE_LINES = 40
 SUBMITTED_DELIVERY_STATUSES = {"injected", "visible", "submitted", "submitted_unverified", "delivered", "acknowledged"}
 TMUX_STDIN_BUFFER_THRESHOLD = 16 * 1024
@@ -480,7 +482,6 @@ def ensure_workspace_dirs(workspace: Path) -> None:
         path.mkdir(parents=True, exist_ok=True)
 
 
-
 def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -> dict[str, Any]:
     from team_agent.state import resolve_team_scoped_state
     state, refusal = resolve_team_scoped_state(workspace, team)
@@ -521,7 +522,7 @@ def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -
             if proc.returncode == 0:
                 log_path.write_text(proc.stdout, encoding="utf-8")
                 captured.append(str(log_path))
-        _close_ghostty_workspace(state, event_log)
+        _close_team_display_backends(state, event_log)
         for agent_id, agent_state in state.get("agents", {}).items():
             _close_ghostty_display(agent_id, agent_state, event_log)
             closed_displays.add(agent_id)
@@ -535,7 +536,7 @@ def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -
             event_log.write("shutdown.kill_session", session=session_name, keep_logs=keep_logs, captured=captured)
     else:
         event_log.write("shutdown.idempotent", session=session_name, reason="session missing")
-        _close_ghostty_workspace(state, event_log)
+        _close_team_display_backends(state, event_log)
     for agent_id, agent_state in state.get("agents", {}).items():
         if agent_id not in closed_displays:
             _close_ghostty_display(agent_id, agent_state, event_log)
@@ -617,7 +618,7 @@ def takeover(workspace: Path, team: str | None = None, confirm: bool = False) ->
             "reason": "no_caller_identity",
             "action": "set TEAM_AGENT_LEADER_PANE_ID/PROVIDER/MACHINE_FINGERPRINT or run from a tmux pane",
         }
-    with _runtime_lock(workspace, "send"):
+    with _runtime_lock(workspace, LEADER_OWNERSHIP_LOCK):
         try:
             team_state = select_runtime_state(workspace, team)
         except RuntimeError as exc:
@@ -628,23 +629,72 @@ def takeover(workspace: Path, team: str | None = None, confirm: bool = False) ->
                 "team": team,
                 "error": str(exc),
             }
-        previous_owner = team_state.get("team_owner")
+        previous_owner = team_state.get("team_owner") if isinstance(team_state.get("team_owner"), dict) else {}
+        previous_receiver = team_state.get("leader_receiver") if isinstance(team_state.get("leader_receiver"), dict) else {}
+        from team_agent.leader import _lease_epoch, _receiver_from_claim_target
+        next_epoch = _lease_epoch(previous_owner, previous_receiver) + 1
+        leader_uuid = str(previous_owner.get("leader_session_uuid") or "")
         new_owner = {
             "pane_id": pane_id,
             "provider": os.environ.get("TEAM_AGENT_LEADER_PROVIDER", ""),
             "machine_fingerprint": os.environ.get("TEAM_AGENT_MACHINE_FINGERPRINT", ""),
+            "owner_epoch": next_epoch,
             "claimed_at": datetime.now(timezone.utc).isoformat(),
             "claimed_via": "takeover",
         }
+        if leader_uuid:
+            new_owner["leader_session_uuid"] = leader_uuid
         team_state["team_owner"] = new_owner
-        save_team_scoped_state(workspace, team_state)
-        EventLog(workspace).write(
-            "team_owner.takeover",
-            team=team,
-            previous_owner=previous_owner,
+        # C11/C17: takeover converges on the same lease mutation as claim-leader.
+        # Rebind the leader receiver to the caller pane and write owner + receiver
+        # to both state locations together, so takeover never leaves the receiver
+        # pointing at the old (often dead) pane.
+        targets_result = core_list_targets()
+        targets = targets_result.get("targets", []) if isinstance(targets_result, dict) and targets_result.get("ok") else []
+        caller_target = next((item for item in targets if isinstance(item, dict) and str(item.get("pane_id")) == str(pane_id)), None)
+        new_receiver = None
+        if caller_target:
+            new_receiver = _receiver_from_claim_target(
+                caller_target,
+                previous_receiver,
+                leader_uuid or None,
+                next_epoch,
+            )
+            new_receiver["discovery"] = "takeover"
+            team_state["leader_receiver"] = new_receiver
+        from team_agent.leader import _write_lease_dual_state
+        _write_lease_dual_state(workspace, team_state)
+        # C11: takeover converges on the same lease audit events as claim-leader
+        # instead of a divergent legacy team_owner.takeover record.
+        event_log = EventLog(workspace)
+        uuid_prefix = leader_uuid[:8]
+        old_pane_id = previous_receiver.get("pane_id") or (previous_owner or {}).get("pane_id")
+        if new_receiver is not None:
+            event_log.write(
+                "leader_receiver.rebind_applied",
+                reason="takeover_confirmed",
+                old_pane_id=old_pane_id,
+                new_pane_id=pane_id,
+                owner_epoch=next_epoch,
+                uuid_prefix=uuid_prefix,
+                team_id=team,
+            )
+        event_log.write(
+            "owner_epoch_advanced",
+            reason="takeover_confirmed",
+            old_pane_id=old_pane_id,
+            new_pane_id=pane_id,
+            owner_epoch=next_epoch,
+            uuid_prefix=uuid_prefix,
+            team_id=team,
+            previous_owner=previous_owner or None,
             new_owner=new_owner,
+            receiver_rebound=bool(new_receiver),
         )
-        return {"ok": True, "status": "claimed", "team": team, "team_owner": new_owner, "previous_owner": previous_owner}
+        response = {"ok": True, "status": "claimed", "team": team, "team_owner": new_owner, "previous_owner": previous_owner or None, "owner_epoch": next_epoch}
+        if new_receiver is not None:
+            response["leader_receiver"] = new_receiver
+        return response
 
 
 def _running_agent_state(workspace: Path, agent: dict[str, Any], previous: dict[str, Any]) -> dict[str, Any]:

package/src/team_agent/spec.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any
 
 from team_agent.errors import ValidationError
+from team_agent.display.backend import VALID_DISPLAY_BACKENDS
 from team_agent.permissions import CANONICAL_TOOLS, expand_tools
 from team_agent.profiles import AUTH_MODES
 from team_agent.simple_yaml import loads
@@ -233,8 +234,8 @@ def _check_communication(comm: Any, errors: list[str]) -> None:
 
 
 def _check_runtime(runtime: Any, errors: list[str]) -> None:
-    required = {"backend", "display_backend", "session_name", "auto_launch", "require_user_approval_before_launch", "max_active_agents", "startup_order"}
-    allowed = required | {
+    required = {"backend", "session_name", "auto_launch", "require_user_approval_before_launch", "max_active_agents", "startup_order"}
+    allowed = required | {"display_backend"} | {
         "dangerous_auto_approve",
         "auto_attach_leader",
         "fast",
@@ -253,7 +254,7 @@ def _check_runtime(runtime: Any, errors: list[str]) -> None:
         return
     if runtime.get("backend") not in {"tmux", "pty"}:
         errors.append("/runtime/backend: invalid backend")
-    if runtime.get("display_backend") not in {"none", "tmux_attach", "iterm", "ghostty", "ghostty_window", "ghostty_workspace"}:
+    if "display_backend" in runtime and runtime.get("display_backend") not in VALID_DISPLAY_BACKENDS:
         errors.append("/runtime/display_backend: invalid display backend")
     if "dangerous_auto_approve" in runtime and not isinstance(runtime["dangerous_auto_approve"], bool):
         errors.append("/runtime/dangerous_auto_approve: must be a boolean")

package/src/team_agent/wake.py

@@ -0,0 +1,58 @@
+"""Provider-neutral wake layer (Gap 32 §2): decide WHEN to re-read a session
+file, never HOW to parse it. No polling loop, no screen, no provider names.
+
+Two cheap, passive sources:
+  - a file-change watch (the caller wires FSEvents/inotify/kqueue and calls
+    ``on_file_changed``) — naturally per-session (one file per node);
+  - an mtime gate — only re-read the tail when the file changed since the last
+    classification, or when it has been quiet past the debounce window.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def should_reread(
+    *,
+    last_mtime: float | None,
+    current_mtime: float | None,
+    last_classified_mtime: float | None,
+    now: float,
+    debounce_seconds: float,
+) -> dict[str, Any]:
+    """Return whether a fresh tail-read is warranted and why.
+
+    A read is warranted when the file changed since we last classified it, or
+    when it has been silent longer than the debounce window and we have not yet
+    classified at this mtime (so an idle-close that we already saw is not
+    re-read forever).
+    """
+    if current_mtime is None:
+        return {"reread": False, "reason": "no_file"}
+    if last_classified_mtime is None:
+        return {"reread": True, "reason": "never_classified"}
+    if current_mtime != last_classified_mtime:
+        return {"reread": True, "reason": "file_changed"}
+    silent_for = max(0.0, now - current_mtime)
+    if silent_for >= debounce_seconds:
+        return {"reread": False, "reason": "quiescent_already_classified"}
+    return {"reread": False, "reason": "unchanged"}
+
+
+def on_file_changed(watch_state: dict[str, Any] | None, *, node_id: str, mtime: float) -> dict[str, Any]:
+    """Record a file-change wake for a node (the push path)."""
+    state = dict(watch_state or {})
+    pending = set(state.get("pending") or [])
+    pending.add(node_id)
+    state["pending"] = sorted(pending)
+    state.setdefault("mtimes", {})[node_id] = mtime
+    return state
+
+
+def take_pending(watch_state: dict[str, Any] | None) -> tuple[list[str], dict[str, Any]]:
+    """Drain the set of nodes whose files changed since the last drain."""
+    state = dict(watch_state or {})
+    pending = sorted(state.get("pending") or [])
+    state["pending"] = []
+    return pending, state