@team-agent/installer 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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/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]:
@@ -119,9 +135,10 @@ def cmd_peek(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def cmd_inbox(args: argparse.Namespace) -> dict[str, Any]:
+    since = getattr(args, "since", None)
     if args.json:
-        return runtime.inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit)
-    return runtime.format_inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit)
+        return runtime.inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit, since=since)
+    return runtime.format_inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit, since=since)
 
 
 def cmd_sessions(args: argparse.Namespace) -> dict[str, Any]:
@@ -136,6 +153,14 @@ def cmd_takeover(args: argparse.Namespace) -> dict[str, Any]:
     return runtime.takeover(Path(args.workspace).resolve(), team=args.team, confirm=args.confirm)
 
 
+def cmd_claim_leader(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.claim_leader(Path(args.workspace).resolve(), team=args.team, confirm=args.confirm)
+
+
+def cmd_identity(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.leader_identity(Path(args.workspace).resolve(), team=args.team)
+
+
 def cmd_send(args: argparse.Namespace) -> dict[str, Any]:
     target = _send_target(args)
     return runtime.send_message(
@@ -190,11 +215,102 @@ def cmd_validate_result(args: argparse.Namespace) -> dict[str, Any]:
     return {"ok": True, "task_id": envelope["task_id"], "agent_id": envelope["agent_id"], "status": envelope["status"]}
 
 
-def cmd_doctor(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)))
+        if args.json:
+            return result
+        return format_cleanup_orphans(result)
     spec = Path(args.spec).resolve() if args.spec else None
     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,12 +24,15 @@ from team_agent.cli.commands import (
     cmd_wait_ready,
     cmd_settle,
     cmd_status,
+    cmd_watch,
     cmd_approvals,
     cmd_peek,
     cmd_inbox,
     cmd_sessions,
     cmd_attach_leader,
     cmd_takeover,
+    cmd_claim_leader,
+    cmd_identity,
     cmd_send,
     cmd_collect,
     cmd_diagnose,
@@ -180,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=".")
@@ -209,6 +218,12 @@ def main(argv: list[str] | None = None) -> None:
     p.add_argument("agent")
     p.add_argument("--workspace", default=".")
     p.add_argument("--limit", type=int, default=20)
+    p.add_argument(
+        "--since",
+        help="ISO 8601 timestamp; only show messages created at-or-after this time. "
+             "Use the timestamp from claim-leader's inbox_hint to retrieve messages "
+             "missed during a prior ambiguous-leader state.",
+    )
     add_json(p)
     p.set_defaults(func=cmd_inbox)
 
@@ -231,6 +246,19 @@ def main(argv: list[str] | None = None) -> None:
     add_json(p)
     p.set_defaults(func=cmd_takeover)
 
+    p = sub.add_parser("claim-leader", help="Claim this pane as leader after ambiguous leader recovery")
+    p.add_argument("--workspace", default=".")
+    p.add_argument("--team", help="Explicit team/session selector when a workspace has multiple teams")
+    p.add_argument("--confirm", action="store_true", help="Apply the claim; without this, show a dry-run summary")
+    add_json(p)
+    p.set_defaults(func=cmd_claim_leader)
+
+    p = sub.add_parser("identity", help="Show leader identity diagnostics")
+    p.add_argument("--workspace", default=".")
+    p.add_argument("--team", help="Explicit team/session selector when a workspace has multiple teams")
+    add_json(p)
+    p.set_defaults(func=cmd_identity)
+
     p = sub.add_parser(
         "send",
         help="Send a message to an agent, task assignee, or attached leader",
@@ -289,6 +317,19 @@ 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",
+        help="Scan for orphan team_agent.coordinator processes pointing at non-existent or "
+             "ephemeral-tempdir workspaces (dry-run unless --confirm is also passed).",
+    )
+    p.add_argument(
+        "--confirm",
+        action="store_true",
+        help="With --cleanup-orphans: send SIGTERM to each orphan (default is dry-run).",
+    )
     add_json(p)
     p.set_defaults(func=cmd_doctor)
 
@@ -429,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,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/coordinator/__main__.py

@@ -38,7 +38,23 @@ def main(argv: list[str] | None = None) -> None:
     signal.signal(signal.SIGINT, _stop)
 
     interval = args.tick_interval if args.tick_interval is not None else _tick_interval(workspace)
+    initial_ppid = os.getppid()
     while not STOP:
+        # Stage 14 (Gap 37b) — orphan self-detection. If our original parent (test harness,
+        # shell, or supervisor) died, our ppid is reparented to 1 (or to a launchd shim on
+        # macOS). When that happens AND the workspace no longer exists on disk, we are an
+        # orphan from a torn-down test environment and must self-terminate so we don't
+        # accumulate (today's evidence: 35 orphans pointing at /var/folders/...team-agent-
+        # watcher-dedupe-* paths long since cleaned up).
+        current_ppid = os.getppid()
+        if current_ppid != initial_ppid and current_ppid == 1 and not workspace.exists():
+            event_log.write(
+                "coordinator.orphan_self_terminate",
+                initial_ppid=initial_ppid,
+                current_ppid=current_ppid,
+                workspace=str(workspace),
+            )
+            break
         result = runtime.coordinator_tick(workspace)
         if result.get("stop") or args.once:
             break
@@ -46,18 +62,21 @@ def main(argv: list[str] | None = None) -> None:
     event_log.write("coordinator.exit", stop=STOP)
 
 
+DEFAULT_TICK_INTERVAL_SEC = 5.0  # Stage 14 (Gap 36c) — bumped from 2.0 (2.5x less CPU)
+
+
 def _tick_interval(workspace: Path) -> float:
     state = load_runtime_state(workspace)
     spec_path = Path(state.get("spec_path", workspace / "team.spec.yaml"))
     if spec_path.exists():
         try:
             spec = load_spec(spec_path)
-            return float(spec.get("runtime", {}).get("tick_interval_sec", 2))
+            return float(spec.get("runtime", {}).get("tick_interval_sec", DEFAULT_TICK_INTERVAL_SEC))
         except Exception:
             pass
     # Ensure schema exists even before launch; this makes doctor/tick diagnostics deterministic.
     MessageStore(workspace)
-    return 2.0
+    return DEFAULT_TICK_INTERVAL_SEC
 
 
 if __name__ == "__main__":

package/src/team_agent/coordinator/lifecycle.py

@@ -265,6 +265,7 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
         detect_idle_fallbacks,
     )
     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)
@@ -318,8 +319,17 @@ 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.
+    from team_agent.message_store.leader_notification_log import prune_leader_notification_log
+    try:
+        pruned = prune_leader_notification_log(store, max_age_hours=24)
+        if pruned:
+            event_log.write("leader_notification.log_pruned", removed=pruned)
+    except Exception as exc:
+        event_log.write("leader_notification.prune_failed", error=str(exc))
     return {
         "ok": True,
         "stop": False,
@@ -330,5 +340,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,
     }