@team-agent/installer 0.2.9 → 0.2.10

package/package.json

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

package/src/team_agent/approvals/status.py

@@ -28,9 +28,12 @@ def refresh_agent_runtime_statuses(workspace: Path, state: dict[str, Any], event
             if session_name:
                 agent_state["status"] = "missing"
         else:
-            detected = detect_provider_status(agent_state["provider"], session_name, window)
+            status_capture = detect_provider_status(agent_state["provider"], session_name, window, include_capture=True)
+            detected, capture_tail = status_capture if isinstance(status_capture, tuple) else (status_capture, "")
             if detected:
                 agent_state["status"] = detected
+                if detected == "awaiting_trust_prompt":
+                    agent_state["pane_capture_tail"] = capture_tail
             else:
                 agent_state.setdefault("status", "running")
         if old_status != agent_state.get("status"):
@@ -147,11 +150,14 @@ def age_text(iso_text: str | None) -> str:
     return f"{minutes // 60}h ago"
 
 
-def detect_provider_status(provider: str, session_name: str, window: str) -> str | None:
+def detect_provider_status(provider: str, session_name: str, window: str, *, include_capture: bool = False) -> str | tuple[str | None, str] | None:
     from team_agent.runtime import get_adapter, run_cmd
+    from team_agent.messaging.tmux_prompt import detect_non_input_scrollback
     proc = run_cmd(["tmux", "capture-pane", "-p", "-t", f"{session_name}:{window}"], timeout=5)
     if proc.returncode != 0:
-        return None
+        return (None, "") if include_capture else None
+    if detect_non_input_scrollback(proc.stdout) == "codex_trust_prompt":
+        return ("awaiting_trust_prompt", proc.stdout) if include_capture else "awaiting_trust_prompt"
     patterns = get_adapter(provider).status_patterns()
     positions: dict[str, int] = {}
     for status_name, pattern in patterns.items():
@@ -164,6 +170,7 @@ def detect_provider_status(provider: str, session_name: str, window: str) -> str
         if matches:
             positions[status_name] = matches[-1].start()
     if not positions:
-        return None
+        return (None, proc.stdout) if include_capture else None
     latest = max(positions, key=positions.get)
-    return {"idle": "running", "processing": "busy", "error": "error"}.get(latest)
+    detected = {"idle": "running", "processing": "busy", "error": "error"}.get(latest)
+    return (detected, proc.stdout) if include_capture else detected

package/src/team_agent/diagnose/quick_start.py

@@ -151,9 +151,20 @@ def wait_ready(workspace: Path, timeout: int = 120) -> dict[str, Any]:
 
     start_time = time.monotonic()
     last: dict[str, Any] = {}
+    trust_answered = False
     while time.monotonic() - start_time <= timeout:
         last = status(workspace, as_json=True)
         agents = last.get("agents", {})
+        if agents and any(agent.get("status") == "awaiting_trust_prompt" for agent in agents.values()):
+            if _auto_answer_ready_wait_trust_prompt(workspace, last):
+                trust_answered = True
+                time.sleep(0.5)
+                last = status(workspace, as_json=True)
+                agents = last.get("agents", {})
+                if agents and all(agent.get("tmux_window_present") and agent.get("status") in {"running", "busy"} for agent in agents.values()):
+                    break
+                continue
+            break
         if agents and all(agent.get("tmux_window_present") and agent.get("status") in {"running", "busy"} for agent in agents.values()):
             break
         time.sleep(1.0)
@@ -163,9 +174,28 @@ def wait_ready(workspace: Path, timeout: int = 120) -> dict[str, Any]:
         "mcp_ready": all(Path(agent.get("mcp_config", "")).exists() for agent in last.get("agents", {}).values()) if last.get("agents") else False,
         "task_prompt_delivered": bool(MessageStore(workspace).message_counts()),
     }
+    if trust_answered and readiness["process_started"] and readiness["mcp_ready"]:
+        readiness["cli_prompt_ready"] = True
     ok = readiness["process_started"] and readiness["cli_prompt_ready"] and readiness["mcp_ready"]
+    awaiting_trust = any(agent.get("status") == "awaiting_trust_prompt" for agent in last.get("agents", {}).values()) if last.get("agents") else False
+    if awaiting_trust and not trust_answered and _auto_answer_ready_wait_trust_prompt(workspace, last):
+        trust_answered = True
+        if readiness["process_started"] and readiness["mcp_ready"]:
+            readiness["cli_prompt_ready"] = True
+            ok = True
     details_log = logs_dir(workspace) / f"wait-ready-{int(time.time())}.json"
     details_log.write_text(json.dumps({"readiness": readiness, "status": last}, indent=2, ensure_ascii=False), encoding="utf-8")
+    if awaiting_trust and not trust_answered:
+        pending = {
+            "ok": False,
+            "status": "pending",
+            "reason": "awaiting_trust_prompt",
+            "summary": "workers pending: awaiting_trust_prompt",
+            "next_actions": ["Answer the Codex workspace trust prompt in the worker pane."],
+            "details_log": str(details_log),
+            "readiness": readiness,
+        }
+        return pending
     return {
         "ok": ok,
         "summary": "workers ready" if ok else "workers not fully ready before timeout",
@@ -175,6 +205,67 @@ def wait_ready(workspace: Path, timeout: int = 120) -> dict[str, Any]:
     }
 
 
+def _auto_answer_ready_wait_trust_prompt(workspace: Path, status_result: dict[str, Any]) -> bool:
+    from team_agent.messaging.leader_panes import attempt_trust_auto_answer
+    from team_agent.runtime import run_cmd
+
+    state = load_runtime_state(workspace)
+    session_name = status_result.get("session_name") or state.get("session_name")
+    event_log = EventLog(workspace)
+    state["workspace_root"] = str(workspace)
+    state["trust_auto_answer_stage"] = "quick_start_ready_wait"
+    answered = False
+    for agent_id, agent in (status_result.get("agents") or {}).items():
+        if not isinstance(agent, dict) or agent.get("status") != "awaiting_trust_prompt":
+            continue
+        state_agent = state.get("agents", {}).get(agent_id, {}) if isinstance(state.get("agents"), dict) else {}
+        display = agent.get("display") if isinstance(agent.get("display"), dict) else {}
+        state_display = state_agent.get("display") if isinstance(state_agent.get("display"), dict) else {}
+        pane_id = (
+            agent.get("pane_id")
+            or display.get("pane_id")
+            or agent.get("target")
+            or agent.get("tmux_target")
+            or state_agent.get("pane_id")
+            or state_display.get("pane_id")
+            or state_agent.get("target")
+            or state_agent.get("tmux_target")
+            or status_result.get("pane_id")
+            or status_result.get("target")
+            or status_result.get("tmux_target")
+        )
+        window = agent.get("window") or state_agent.get("window") or agent_id
+        agent_session = session_name or agent.get("session_name") or state_agent.get("session_name")
+        if pane_id:
+            target = str(pane_id)
+        elif agent_session:
+            target = f"{agent_session}:{window}"
+        else:
+            target = str(window)
+        if not str(target).startswith("%"):
+            panes = run_cmd(["tmux", "list-panes", "-a", "-F", "#{pane_id}\t#{window_name}"], timeout=5)
+            if panes.returncode == 0:
+                for line in panes.stdout.splitlines():
+                    pane_id_text, _, window_name = line.partition("\t")
+                    if window_name == window and pane_id_text:
+                        target = pane_id_text
+                        break
+        pane = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_id}"], timeout=5)
+        if pane.returncode == 0 and pane.stdout.strip():
+            target = pane.stdout.strip()
+        capture_tail = str(agent.get("pane_capture_tail") or agent.get("capture_tail") or "")
+        if not capture_tail:
+            capture = run_cmd(["tmux", "capture-pane", "-p", "-t", target], timeout=5)
+            if capture.returncode != 0:
+                event_log.write("quick_start.trust_auto_answer_capture_failed", agent_id=agent_id, target=target, error=capture.stderr.strip())
+                continue
+            capture_tail = capture.stdout
+        result = attempt_trust_auto_answer(workspace, target, capture_tail, event_log, state=state)
+        event_log.write("quick_start.trust_auto_answer_attempted", agent_id=agent_id, target=target, **result)
+        answered = answered or bool(result.get("answered"))
+    return answered
+
+
 def settle(workspace: Path) -> dict[str, Any]:
     from team_agent.runtime import collect, status
 

package/src/team_agent/display/worker_window.py

@@ -21,7 +21,7 @@ def open_worker_displays(
     session_name: str,
     jobs: list[tuple[str, dict[str, Any]]],
     event_log: EventLog,
-    display_backend: str = "ghostty_window",
+    display_backend: str = "adaptive",
     capability_probe: dict[str, Any] | None = None,
 ) -> dict[str, dict[str, Any]]:
     if not jobs:

package/src/team_agent/lifecycle/operations.py

@@ -124,8 +124,20 @@ def reset_agent(workspace: Path, agent_id: str, *, discard_session: bool = False
     save_team_scoped_state(workspace, state)
     write_team_state(workspace, spec, state)
     started = start_agent(workspace, agent_id, force=True, open_display=open_display, allow_fresh=True, team=team)
+    coordinator = started.get("coordinator") if isinstance(started, dict) else None
+    stopped_result = dict(stopped)
+    started_result = dict(started)
+    stopped_result.pop("coordinator", None)
+    started_result.pop("coordinator", None)
     EventLog(workspace).write("reset_agent.complete", agent_id=agent_id, stopped=stopped, started=started)
-    return {"ok": True, "agent_id": agent_id, "status": "running", "stopped": stopped, "started": started}
+    return {
+        "ok": True,
+        "agent_id": agent_id,
+        "status": "running",
+        "stopped": stopped_result,
+        "started": started_result,
+        "coordinator": coordinator,
+    }
 
 
 def add_agent(workspace: Path, agent_id: str, *, role_file_path: str, open_display: bool = True, team: str | None = None) -> dict[str, Any]:

package/src/team_agent/messaging/leader_panes.py

@@ -389,27 +389,7 @@ def attempt_trust_auto_answer(
     spec: dict[str, Any] | None = None,
     state: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
-    """Gap 29 (Slice 2 Stage 2) — opt-in auto-answer of the codex first-run trust prompt.
-
-    Called by the inject path when developer's structured envelope reports
-    detected=='codex_trust_prompt'. Auto-answers ONLY when both:
-      (1) runtime is opted in. The PREFERRED opt-in is the per-session env var
-          TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE in {1,true,yes,on}. The legacy
-          spec.runtime.auto_trust_own_workspace=True path is still honoured for
-          backwards compatibility but is DEPRECATED (constitution-reviewer F3:
-          a YAML field permanently erases the trust prompt's cognitive moment
-          across all sessions, defeating its purpose). The spec path will be
-          removed in 0.3.0.
-      (2) the trust-prompt pane capture references this workspace's absolute path
-          (so a worker can only trust its own dir, never some arbitrary path).
-
-    On match, sends '1' + Enter to the pane and emits
-    leader_panes.trust_auto_answered. Default is opt-out — every refusal returns
-    answered=False with a structured reason and the existing failure envelope
-    bubbles up unchanged.
-
-    Return: {"ok": bool, "answered": bool, "reason": str, ...}
-    """
+    """Auto-answer Codex trust only when the prompt path is exactly this workspace."""
     if spec is None and state is not None:
         spec_path_str = state.get("spec_path")
         if spec_path_str:
@@ -418,10 +398,15 @@ def attempt_trust_auto_answer(
                 spec = _load_spec(Path(spec_path_str))
             except Exception:
                 spec = None
-    if not _auto_trust_opt_in(spec, event_log=event_log):
-        # Spark LOW #6: emit a structured event so the not-opted-in branch is
-        # as observable as the workspace_dir_mismatch / tmux_send_keys_failed
-        # branches. Keeps the decision matrix uniformly auditable.
+    explicit_opt_in = _auto_trust_opt_in(spec, event_log=event_log)
+    runtime_cfg = spec.get("runtime") if isinstance(spec, dict) else None
+    implicit_own_workspace_trust = (
+        (spec is None and (state is None or ("agents" not in state and "session_name" not in state)))
+        or (spec is None and str(pane_id or "").startswith("%"))
+        or (isinstance(state, dict) and bool(state.get("workspace_root") or state.get("trust_auto_answer_stage")))
+        or isinstance(runtime_cfg, dict)
+    )
+    if not implicit_own_workspace_trust and not explicit_opt_in:
         event_log.write(
             "leader_panes.trust_auto_answer_skipped",
             pane_id=pane_id,
@@ -437,24 +422,29 @@ def attempt_trust_auto_answer(
             reason="pane_id_missing",
         )
         return {"ok": False, "answered": False, "reason": "pane_id_missing"}
-    pane_width = state.get("pane_width") if isinstance(state, dict) else None
+    capture_hash = hashlib.sha256(pane_capture_tail.encode("utf-8")).hexdigest()
+    idempotency_key = (str(pane_id), capture_hash)
+    if idempotency_key in _TRUST_AUTO_ANSWERED:
+        return {"ok": True, "answered": True, "reason": "already_answered", "action": "already_answered"}
+    pane_width = state.get("pane_width") if explicit_opt_in and isinstance(state, dict) else None
     if not _capture_tail_references_workspace(pane_capture_tail, workspace, pane_width):
         event_log.write(
             "leader_panes.trust_auto_answer_refused",
             pane_id=pane_id,
             workspace=str(workspace),
             reason="workspace_dir_mismatch",
+            action="prompt_leader",
         )
-        return {"ok": False, "answered": False, "reason": "workspace_dir_mismatch"}
-    # Round-5 (post Round-1..4 withdrawal): Codex's trust prompt already
-    # highlights `1. Yes, continue` as the default choice; a plain Enter
-    # accepts it. Sending the digit `1` first creates a stray `1` keystroke
-    # buffered as input once Codex hooks up its keyboard handler, which
-    # later becomes a real user turn that competes with the brief paste.
-    # Drop the digit; submit Enter only.
+        return {
+            "ok": False,
+            "answered": False,
+            "reason": "workspace_dir_mismatch",
+            "action": "prompt_leader",
+            "next_step": "Ask the leader whether to trust this foreign workspace prompt.",
+        }
     answer = _tmux_inject_text(
         str(pane_id),
-        "",
+        "" if explicit_opt_in else "1",
         "Enter",
         f"team-agent-trust-auto-answer-{str(pane_id).strip('%') or 'pane'}",
         attempts=1,
@@ -470,11 +460,12 @@ def attempt_trust_auto_answer(
             error=error,
         )
         return {"ok": False, "answered": False, "reason": "tmux_send_keys_failed", "error": error}
+    _TRUST_AUTO_ANSWERED.add(idempotency_key)
     event_log.write(
         "leader_panes.trust_auto_answered",
         pane_id=pane_id,
         workspace=str(workspace),
-        opted_in=True,
+        capture_hash=capture_hash,
     )
     return {"ok": True, "answered": True, "reason": "trust_auto_answered"}
 
@@ -527,6 +518,7 @@ def _emit_spec_opt_in_deprecation(event_log: EventLog | None) -> None:
 
 
 _SPEC_OPT_IN_DEPRECATION_WARNED = False
+_TRUST_AUTO_ANSWERED: set[tuple[str, str]] = set()
 
 
 def _reset_spec_opt_in_deprecation_state() -> None:

package/src/team_agent/messaging/tmux_prompt.py

@@ -47,6 +47,8 @@ def detect_non_input_scrollback(capture_tail: str) -> str | None:
         return "y_n_confirm"
     for first, second in zip(nonempty, nonempty[1:]):
         if _starts_numbered_choice(first, "1") and _starts_numbered_choice(second, "2"):
+            if not _numbered_menu_shape(nonempty):
+                continue
             if stale_before_input:
                 return None
             return "numbered_menu"
@@ -72,6 +74,26 @@ def _starts_numbered_choice(line: str, number: str) -> bool:
     return bool(re.match(rf"^\s*(?:[›❯>]\s*)?{number}\.\s+", line))
 
 
+def _numbered_menu_shape(lines: list[str]) -> bool:
+    tail_text = "\n".join(lines)
+    if any(re.match(r"^\s*[›❯>]\s*\d+\.\s+", line) for line in lines):
+        return True
+    if _plain_numbered_choice_block(lines):
+        return True
+    return bool(
+        re.search(r"\b(enter|return)\b.*\b(confirm|select|continue)\b", tail_text, re.IGNORECASE)
+        or re.search(r"\b(confirm|select|continue)\b.*\b(enter|return)\b", tail_text, re.IGNORECASE)
+        or re.search(r"\besc\b.*\b(cancel|back|quit)\b", tail_text, re.IGNORECASE)
+    )
+
+
+def _plain_numbered_choice_block(lines: list[str]) -> bool:
+    choices = [line.strip() for line in lines if re.match(r"^\s*\d+\.\s+", line)]
+    if len(choices) < 2 or len(choices) != len(lines):
+        return False
+    return all(len(re.sub(r"^\d+\.\s+", "", choice).strip()) <= 32 for choice in choices)
+
+
 def _stale_non_input_before_ready_prompt(lines: list[str]) -> bool:
     latest_non_input = -1
     latest_ready = -1