@team-agent/installer 0.2.2 → 0.2.4

package/package.json

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

package/schemas/team.schema.json

@@ -72,6 +72,12 @@
         "startup_order": {
           "type": "array",
           "items": { "type": "string" }
+        },
+        "auto_trust_own_workspace": {
+          "type": "boolean",
+          "default": false,
+          "deprecated": true,
+          "description": "DEPRECATED: use env TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE per session. Will be removed in 0.3.0."
         }
       }
     },

package/src/team_agent/abnormal_track.py

@@ -0,0 +1,253 @@
+"""Provider-neutral abnormal-state track (Gap 32 §4).
+
+Reads structured fault records + process identity; never reads a screen and
+never names a provider. Catch-bias for structured error/failed-class records
+(C9), dedup by (signature, turn) (C8), and coordinator-independent whole-team
+disappearance with clean-shutdown vs unexpected distinction (C10).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def process_abnormal_records(
+    records: list[dict[str, Any]],
+    *,
+    registry: Any,
+    notification_state: dict[str, Any] | None,
+    event_sink: Any = None,
+) -> dict[str, Any]:
+    """Classify raw provider session records that may carry faults.
+
+    ``registry`` carries the provider whose records these are (``{"provider":
+    name}``) or a full registry mapping. Records are turned into structured
+    fault facts by the provider reader (so this module names no provider), then
+    catch-biased + deduped by (signature, turn).
+    """
+    from team_agent.provider_state import read_fault_facts
+    from team_agent.provider_state.registry import get_provider_registry
+
+    state = dict(notification_state or {})
+    seen = set(state.get("seen") or [])
+    notifications: list[dict[str, Any]] = []
+    discovery_log: list[dict[str, Any]] = []
+    diagnostics: list[dict[str, Any]] = []
+
+    provider = _provider_of(registry)
+    white, black = _lists_for(provider, registry, get_provider_registry)
+
+    faults = read_fault_facts(provider, records or []) if provider else []
+    if not faults and records:
+        # Records that produced no structured fault fact are not default-notify
+        # candidates (C9): arbitrary unrecognized lines become diagnostics only.
+        diagnostics.append({"kind": "no_structured_fault", "count": len(records)})
+
+    for fact in faults:
+        signature = str(fact.get("signature") or fact.get("reason") or "fault")
+        turn_id = fact.get("turn_id")
+        text = " ".join(str(x) for x in (signature, fact.get("reason"), _raw_message(fact)) if x).lower()
+        decision = _classify(text, signature, white, black)
+        discovery_log.append({
+            "signature": signature,
+            "turn_id": turn_id,
+            "decision": decision,
+            "kind": fact.get("kind"),
+            "provider": provider,
+        })
+        if decision == "skip":
+            continue
+        # C8: dedup by (signature, turn_id) — a retry loop in the SAME turn folds
+        # to one notify. But a MISSING turn_id must not collapse distinct errors
+        # into one global bucket: discriminate by a per-record content fingerprint
+        # so genuinely different faults each notify (identical duplicates still fold).
+        bucket = turn_id if turn_id is not None else f"norow:{_record_fingerprint(fact)}"
+        dedupe_key = (signature, bucket)
+        key = f"{signature}\x00{bucket}"
+        if key in seen:
+            continue
+        seen.add(key)
+        notifications.append({
+            "signature": signature,
+            "turn_id": turn_id,
+            "dedupe_key": dedupe_key,
+            "state": "blocked_on_human" if fact.get("kind") == "approval" else "abnormal",
+            "decision": decision,
+            "provider": provider,
+            "raw": fact.get("raw", fact),
+            "raw_record": fact.get("raw", fact),
+        })
+        _emit(event_sink, "abnormal.notify", signature=signature, turn_id=turn_id, decision=decision)
+
+    state["seen"] = sorted(seen)
+    return {
+        "notifications": notifications,
+        "discovery_log": discovery_log,
+        "diagnostics": diagnostics,
+        "notification_state": state,
+    }
+
+
+def detect_whole_team_gone(
+    snapshot: dict[str, Any],
+    *,
+    marker_store: Any,
+    event_sink: Any = None,
+) -> dict[str, Any]:
+    """Coordinator-independent whole-team-gone detection (C10/C13).
+
+    Does not require the coordinator to be alive. The whole team is gone when the
+    coordinator, the leader, every provider process, and every session are all
+    absent. Clean shutdown / restart-in-progress (flagged in the snapshot) are
+    silent; an unexpected disappearance records a durable marker and defers user
+    escalation to the next leader command.
+    """
+    coordinator = snapshot.get("coordinator") or {}
+    leader = snapshot.get("leader") or {}
+    provider_processes = snapshot.get("provider_processes")
+    if provider_processes is None:
+        provider_processes = snapshot.get("nodes") or snapshot.get("agents") or []
+    tmux_sessions = snapshot.get("tmux_sessions") or []
+
+    coord_alive = _alive(coordinator)
+    leader_alive = _alive(leader)
+    any_worker_alive = any(_alive(p) for p in provider_processes)
+    sessions_present = bool(tmux_sessions)
+
+    whole_gone = not (coord_alive or leader_alive or any_worker_alive or sessions_present)
+
+    if not whole_gone:
+        return {
+            "state": "alive",
+            "whole_team_gone": False,
+            "classification": "alive",
+            "notify": False,
+            "escalate_user_on_next_leader_command": False,
+            "marker_written": False,
+        }
+
+    if snapshot.get("clean_shutdown"):
+        return _silent_gone("clean_shutdown")
+    if snapshot.get("restart_in_progress"):
+        return _silent_gone("restart_in_progress")
+
+    # Unexpected disappearance (闪退): durable marker + deferred escalation.
+    marker_written = _marker_set(marker_store, "whole_team_gone", {
+        "classification": "unexpected_exit",
+        "provider_processes": len(provider_processes),
+    })
+    _emit(event_sink, "abnormal.whole_team_gone", classification="unexpected_exit")
+    return {
+        "state": "whole_team_gone",
+        "whole_team_gone": True,
+        "classification": "unexpected_exit",
+        "notify": True,
+        "escalate_user_on_next_leader_command": True,
+        "marker_written": bool(marker_written),
+    }
+
+
+def _silent_gone(classification: str) -> dict[str, Any]:
+    return {
+        "state": classification,
+        "whole_team_gone": True,
+        "classification": classification,
+        "notify": False,
+        "escalate_user_on_next_leader_command": False,
+        "marker_written": False,
+    }
+
+
+def _alive(entry: Any) -> bool:
+    from team_agent.provider_state.common import process_is_live
+
+    if isinstance(entry, dict):
+        if "alive" in entry:
+            return entry.get("alive") is True
+        if "process" in entry:
+            ok, _r, _d = process_is_live(entry.get("process"))
+            return ok
+        ok, _r, _d = process_is_live(entry)
+        return ok
+    return bool(entry)
+
+
+def _provider_of(registry: Any) -> str | None:
+    if isinstance(registry, dict):
+        if isinstance(registry.get("provider"), str):
+            return registry.get("provider")
+        if isinstance(registry.get("kind"), str):
+            return registry.get("kind")
+    return None
+
+
+def _lists_for(provider: str | None, registry: Any, get_provider_registry: Any) -> tuple[list[str], list[str]]:
+    entry: Any = None
+    if isinstance(registry, dict) and ("error_whitelist" in registry or "error_blacklist" in registry):
+        entry = registry
+    elif provider is not None:
+        entry = get_provider_registry(provider)
+    if not isinstance(entry, dict):
+        return [], []
+    lists = entry.get("error_lists") if isinstance(entry.get("error_lists"), dict) else {}
+    white = [str(x).lower() for x in (lists.get("whitelist") or entry.get("error_whitelist") or [])]
+    black = [str(x).lower() for x in (lists.get("blacklist") or entry.get("error_blacklist") or [])]
+    return white, black
+
+
+def _classify(text: str, signature: str, white: list[str], black: list[str]) -> str:
+    sig = signature.lower()
+    if any(w and (w in text or w in sig) for w in white):
+        return "skip"  # whitelist > blacklist > default
+    if any(b and (b in text or b in sig) for b in black):
+        return "notify_blacklist"
+    return "notify_default"  # C9 catch-bias for structured faults
+
+
+def _record_fingerprint(fact: dict[str, Any]) -> str:
+    import hashlib
+    import json
+
+    raw = fact.get("raw", fact)
+    try:
+        blob = json.dumps(raw, sort_keys=True, default=str)
+    except (TypeError, ValueError):
+        blob = repr(raw)
+    return hashlib.sha256(blob.encode("utf-8", errors="ignore")).hexdigest()[:16]
+
+
+def _raw_message(fact: dict[str, Any]) -> str:
+    raw = fact.get("raw")
+    if isinstance(raw, dict):
+        return str(raw.get("message") or "")
+    return ""
+
+
+def _marker_set(marker_store: Any, name: str, value: Any) -> bool:
+    if marker_store is None:
+        return False
+    if isinstance(marker_store, dict):
+        marker_store[name] = value
+        return True
+    setter = getattr(marker_store, "set", None) or getattr(marker_store, "write", None)
+    if callable(setter):
+        try:
+            setter(name, value)
+            return True
+        except Exception:
+            return False
+    return False
+
+
+def _emit(event_sink: Any, name: str, **fields: Any) -> None:
+    if event_sink is None:
+        return
+    try:
+        event_sink(name, fields)
+    except TypeError:
+        try:
+            event_sink({"event": name, **fields})
+        except Exception:
+            pass
+    except Exception:
+        pass

package/src/team_agent/approvals/runtime_prompts.py

@@ -64,7 +64,7 @@ def handle_provider_startup_prompts(workspace: Path, state: dict[str, Any], even
             continue
         agent_state["startup_prompt_check_count"] = check_count + 1
         adapter = get_adapter(agent_state["provider"])
-        for prompt_event in adapter.handle_startup_prompts(session_name, window, checks=1, sleep_s=0.0):
+        for prompt_event in adapter.handle_startup_prompts(session_name, window, checks=20, sleep_s=0.5):
             event_log.write(
                 "runtime.startup_prompt_handled",
                 agent_id=agent_id,

package/src/team_agent/cli/commands.py

@@ -88,9 +88,25 @@ def cmd_settle(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def cmd_status(args: argparse.Namespace) -> dict[str, Any]:
-    if args.json:
-        return runtime.status(Path(args.workspace).resolve(), as_json=True, compact=not args.detail)
-    return runtime.format_status(Path(args.workspace).resolve(), args.agent)
+    if getattr(args, "summary", False) is True:
+        if getattr(args, "json", False) is True:
+            raise TeamAgentError("--summary and --json are mutually exclusive")
+        if getattr(args, "agent", None):
+            raise TeamAgentError("status --summary does not accept an agent argument")
+        data = runtime.status(Path(args.workspace).resolve(), as_json=True, compact=False)
+        return _format_status_summary(data)
+    if getattr(args, "json", False) is True:
+        return runtime.status(Path(args.workspace).resolve(), as_json=True, compact=not (getattr(args, "detail", False) is True))
+    return runtime.format_status(Path(args.workspace).resolve(), getattr(args, "agent", None))
+
+
+def cmd_watch(args: argparse.Namespace) -> None:
+    from team_agent.watch import run_watch
+    try:
+        run_watch(Path(args.workspace).resolve(), team=getattr(args, "team", None))
+    except KeyboardInterrupt:
+        raise SystemExit(0)
+    raise SystemExit(0)
 
 
 def cmd_approvals(args: argparse.Namespace) -> dict[str, Any]:
@@ -200,6 +216,14 @@ def cmd_validate_result(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def cmd_doctor(args: argparse.Namespace) -> dict[str, Any] | str:
+    gate = getattr(args, "gate", None)
+    if getattr(args, "fix", False) is True and not gate:
+        raise TeamAgentError("--fix requires --gate")
+    if isinstance(gate, str) and gate:
+        from team_agent.diagnose.orphan_cleanup import orphan_gate
+        if gate != "orphans":
+            raise TeamAgentError(f"unknown doctor gate: {gate}")
+        return orphan_gate(fix=bool(getattr(args, "fix", False)), confirm=bool(getattr(args, "confirm", False)))
     if getattr(args, "cleanup_orphans", False):
         from team_agent.diagnose.orphan_cleanup import cleanup_orphan_coordinators, format_cleanup_orphans
         result = cleanup_orphan_coordinators(confirm=bool(getattr(args, "confirm", False)))
@@ -210,6 +234,83 @@ def cmd_doctor(args: argparse.Namespace) -> dict[str, Any] | str:
     return runtime.doctor(spec)
 
 
+def _format_status_summary(data: dict[str, Any]) -> str:
+    coordinator = data.get("coordinator") or {}
+    receiver = data.get("leader_receiver") or {}
+    agents = data.get("agents") or {}
+    health = data.get("agent_health") or {}
+    latest = (data.get("latest_results") or [{}])[0] if data.get("latest_results") else None
+    counts = _agent_summary_counts(agents, health)
+    agents_line = (
+        f"agents: {len(agents)} — running={counts['running']} busy={counts['busy']} "
+        f"idle={counts['idle']} stopped={counts['stopped']} failed={counts['failed']} "
+        f"unknown={counts['unknown']}"
+    )
+    # C3 (cr verdict, 2026-05-27): append a (N interacted, M never) marker
+    # only when at least one worker has a valid first_send_at stamp. When N
+    # is zero, the agents line stays byte-identical to the pre-Route-B
+    # output so the Gap 18a triage contract (strict five-line shape with
+    # exact line[2] string) remains unchanged.
+    interacted_count, never_count = _interaction_counts(agents)
+    if interacted_count > 0:
+        agents_line = f"{agents_line} ({interacted_count} interacted, {never_count} never)"
+    return "\n".join([
+        f"coordinator: {coordinator.get('status') or 'stopped'} schema_ok={bool(coordinator.get('schema_ok'))} tmux={bool(data.get('tmux_session_present'))}",
+        f"receiver: {receiver.get('pane_id') or '-'} cmd={receiver.get('pane_current_command') or receiver.get('current_command') or '-'}",
+        agents_line,
+        f"queued: {len(data.get('queued_messages') or [])} mailbox messages awaiting delivery",
+        _latest_result_line(latest),
+    ])
+
+
+def _interaction_counts(agents: dict[str, Any]) -> tuple[int, int]:
+    """Return (interacted, never_interacted) over the agents dict. An agent is
+    interacted when its `interacted` field (added by status.queries.status) is
+    a non-empty string other than the literal "never". This intentionally
+    sources from the enriched per-status interacted field rather than re-
+    parsing first_send_at so the summary stays a derived view."""
+    interacted = 0
+    never = 0
+    for entry in agents.values():
+        marker = (entry or {}).get("interacted") if isinstance(entry, dict) else None
+        if isinstance(marker, str) and marker and marker != "never":
+            interacted += 1
+        else:
+            never += 1
+    return interacted, never
+
+
+def _agent_summary_counts(agents: dict[str, Any], health: dict[str, Any]) -> dict[str, int]:
+    counts = dict.fromkeys(("running", "busy", "idle", "stopped", "failed", "unknown"), 0)
+    for agent_id, agent in agents.items():
+        raw = str((agent or {}).get("status") or "").lower()
+        hstatus = str((health.get(agent_id) or {}).get("status") or "").lower()
+        if raw in {"failed", "error"} or hstatus in {"failed", "error"}:
+            counts["failed"] += 1
+        elif raw in {"stopped", "done"} or hstatus == "done":
+            counts["stopped"] += 1
+        elif raw == "busy" or hstatus in {"running", "working"}:
+            counts["busy"] += 1
+        elif hstatus == "idle":
+            counts["idle"] += 1
+        elif raw in {"blocked", "awaiting_approval", "interrupted", "missing", "stuck", "uncertain"} or hstatus in {
+            "blocked", "awaiting_approval", "interrupted", "missing", "stuck", "uncertain"
+        }:
+            counts["unknown"] += 1
+        elif raw == "running":
+            counts["running"] += 1
+        else:
+            counts["unknown"] += 1
+    return counts
+
+
+def _latest_result_line(result: dict[str, Any] | None) -> str:
+    if not result:
+        return "latest result: none"
+    summary = str(result.get("summary") or "").replace("\n", " ")[:80]
+    return f"latest result: {result.get('agent_id') or '-'} -> {summary or '-'} @ {runtime._age_text(result.get('created_at'))}"
+
+
 def cmd_shutdown(args: argparse.Namespace) -> dict[str, Any]:
     return runtime.shutdown(Path(args.workspace).resolve(), keep_logs=args.keep_logs, team=args.team)
 

package/src/team_agent/cli/parser.py

@@ -24,6 +24,7 @@ from team_agent.cli.commands import (
     cmd_wait_ready,
     cmd_settle,
     cmd_status,
+    cmd_watch,
     cmd_approvals,
     cmd_peek,
     cmd_inbox,
@@ -182,9 +183,15 @@ def main(argv: list[str] | None = None) -> None:
     p.add_argument("agent", nargs="?")
     p.add_argument("--workspace", default=".")
     p.add_argument("--detail", action="store_true", help="Include full raw runtime state in --json output")
+    p.add_argument("--summary", action="store_true", help="Emit five-line human-readable triage summary")
     add_json(p)
     p.set_defaults(func=cmd_status)
 
+    p = sub.add_parser("watch", help="Watch leader-visible team events")
+    p.add_argument("--workspace", default=".")
+    p.add_argument("--team", help="Explicit team/session selector when a workspace has multiple teams")
+    p.set_defaults(func=cmd_watch)
+
     p = sub.add_parser("approvals", help="Show structured pending worker approval prompts")
     p.add_argument("agent", nargs="?")
     p.add_argument("--workspace", default=".")
@@ -310,6 +317,8 @@ def main(argv: list[str] | None = None) -> None:
 
     p = sub.add_parser("doctor", help="Check local dependencies, providers, auth hints, tmux, and MCP")
     p.add_argument("spec", nargs="?")
+    p.add_argument("--gate", choices=["orphans"], help="Run a CI-friendly doctor gate")
+    p.add_argument("--fix", action="store_true", help="With --gate orphans: apply the gate fix")
     p.add_argument(
         "--cleanup-orphans",
         action="store_true",
@@ -461,7 +470,7 @@ def main(argv: list[str] | None = None) -> None:
     sub._choices_actions = [  # type: ignore[attr-defined]
         action for action in sub._choices_actions if action.help != argparse.SUPPRESS  # type: ignore[attr-defined]
     ]
-    sub.metavar = "{codex,claude,quick-start,send,status,approvals,inbox,takeover,claim-leader,identity,shutdown,restart,start-agent,stop-agent,reset-agent,add-agent,fork-agent,remove-agent,stuck-list,stuck-cancel,acknowledge-idle,doctor}"
+    sub.metavar = "{codex,claude,quick-start,send,status,watch,approvals,inbox,takeover,claim-leader,identity,shutdown,restart,start-agent,stop-agent,reset-agent,add-agent,fork-agent,remove-agent,stuck-list,stuck-cancel,acknowledge-idle,doctor}"
 
     args = parser.parse_args(raw_argv)
     try:

package/src/team_agent/compiler.py

@@ -93,7 +93,7 @@ def compile_team(team_dir: Path, out_path: Path | None = None) -> dict[str, Any]
         },
         "runtime": {
             "backend": "tmux",
-            "display_backend": str(team_meta.get("display_backend") or "ghostty_window"),
+            "display_backend": str(team_meta.get("display_backend") or "adaptive"),
             "session_name": str(team_meta.get("session_name") or f"team-{_slug(team_name)}"),
             "auto_launch": True,
             "require_user_approval_before_launch": True,

package/src/team_agent/coordinator/lifecycle.py

@@ -262,9 +262,12 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
     )
     from team_agent.messaging.idle_alerts import (
         detect_cross_worker_deadlocks,
-        detect_idle_fallbacks,
     )
+    from team_agent.idle_predicate import evaluate_takeover_reminder
+    from team_agent.idle_takeover_wiring import build_idle_nodes, push_idle_reminder, IDLE_DEBOUNCE_SECONDS
+    import time as _time
     from team_agent.messaging.activity_detector import detect_compaction_degradation
+    from team_agent.messaging.leader_api_errors import detect_leader_api_errors
     from team_agent.messaging.session_drift import detect_session_drift
     from team_agent.state import load_runtime_state, save_runtime_state
     state = load_runtime_state(workspace)
@@ -282,7 +285,23 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
     delivered = _deliver_pending_messages(workspace, state, event_log)
     fired = _fire_due_scheduled_events(workspace, store, event_log)
     stuck = _detect_stuck_agents(workspace, state, store, event_log)
-    idle_alerts = detect_idle_fallbacks(workspace, state, store, event_log)
+    # Gap 32: the take-over reminder is driven by file-fact turn-state via the
+    # idle_takeover predicate (the legacy screen-scrape obligation path is retired).
+    _coord_meta = state.setdefault("coordinator", {})
+    idle_eval = evaluate_takeover_reminder(
+        build_idle_nodes(state),
+        monitor_state=_coord_meta.get("idle_takeover_monitor"),
+        now_monotonic=_time.monotonic(),
+        debounce_seconds=IDLE_DEBOUNCE_SECONDS,
+    )
+    _coord_meta["idle_takeover_monitor"] = idle_eval.get("monitor_state")
+    push_idle_reminder(workspace, state, event_log, idle_eval)
+    idle_alerts = (
+        [{"alert_type": "idle_takeover", "message": idle_eval.get("message"),
+          "reason": idle_eval.get("reason"), "interrupted": idle_eval.get("interrupted_nodes")}]
+        if idle_eval.get("should_ping")
+        else []
+    )
     deadlock_alerts = detect_cross_worker_deadlocks(workspace, state, store, event_log)
     compaction_results: list[dict[str, Any]] = []
     for agent_id, agent_state in state.get("agents", {}).items():
@@ -318,6 +337,7 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
         )
         if drift:
             drift_results.append(drift)
+    api_errors = detect_leader_api_errors(workspace, state, store, event_log)
     save_runtime_state(workspace, state)
     results = _collect_results_and_notify_watchers(workspace, event_log)
     # Stage 12: prune the dedupe log every tick — cheap O(n) delete bounded by 24h window.
@@ -338,5 +358,6 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
         "deadlock_alerts": deadlock_alerts,
         "compaction": compaction_results,
         "session_drift": drift_results,
+        "api_errors": api_errors,
         "results": results,
     }