@team-agent/installer 0.1.10 → 0.1.11

package/package.json

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

package/skills/team-agent/SKILL.md

@@ -118,7 +118,7 @@ For diagnosis, run `team-agent profile show deepseek --workspace . --json`; neve
 - `team-agent send --watch-result coder "Do the bounded task"` sends a direct worker message, returns after delivery, and lets the coordinator collect/report completion asynchronously.
 - After `send --watch-result` succeeds, do not run `sleep`, `status`, `inbox`, or `collect` polling loops unless the user explicitly asks for diagnosis; the coordinator will notify the leader when the result arrives.
 - `team-agent send --task task_initial "Start"` routes by task.
-- `team-agent status` shows team, worker health, result-store counts, `session_id`, `captured_via`, and attribution confidence.
+- `team-agent status` shows team, worker health, result-store counts, `session_id`, `captured_via`, and attribution confidence. `team-agent status --json` is compact and context-safe by default; use `team-agent status --detail --json` only for raw runtime-state diagnostics.
 - `team-agent status coder` shows one worker.
 - `team-agent approvals [coder]` shows structured pending approval prompts without copying worker terminal pages.
 - `team-agent inbox coder` shows message history only. Final results are not in inbox.

package/src/team_agent/cli.py

@@ -135,6 +135,7 @@ def main(argv: list[str] | None = None) -> None:
     p = sub.add_parser("status", help="Show team runtime status")
     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")
     add_json(p)
     p.set_defaults(func=cmd_status)
 
@@ -504,7 +505,7 @@ 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)
+        return runtime.status(Path(args.workspace).resolve(), as_json=True, compact=not args.detail)
     return runtime.format_status(Path(args.workspace).resolve(), args.agent)
 
 

package/src/team_agent/mcp_server.py

@@ -170,7 +170,7 @@ class TeamOrchestratorTools:
         return {"ok": True, "state_file": str(path)}
 
     def get_team_status(self) -> dict[str, Any]:
-        return runtime.status(self.workspace, as_json=True)
+        return runtime.status(self.workspace, as_json=True, compact=True)
 
     def request_human(self, question: str, task_id: str | None = None, agent_id: str | None = None) -> dict[str, Any]:
         store = MessageStore(self.workspace)

package/src/team_agent/runtime.py

@@ -56,6 +56,8 @@ TMUX_PANE_FORMAT = (
 HEALTH_STATUSES = {"RUNNING", "IDLE", "AWAITING_APPROVAL", "BLOCKED", "ERROR", "DONE"}
 GHOSTTY_DISPLAY_BACKENDS = {"ghostty", "ghostty_window", "ghostty_workspace"}
 GHOSTTY_WORKSPACE_PANES_PER_WINDOW = 3
+STATUS_TEXT_LIMIT = 240
+STATUS_EVENT_LIMIT = 3
 PEEK_MAX_LINES = 80
 PEEK_SEARCH_SCAN_LINES = 300
 PEEK_MAX_MATCHES = 5
@@ -635,7 +637,7 @@ def _quick_start_existing_context(workspace: Path, session_name: str) -> dict[st
     return None
 
 
-def status(workspace: Path, as_json: bool = False) -> dict[str, Any]:
+def status(workspace: Path, as_json: bool = False, *, compact: bool = False) -> dict[str, Any]:
     state = load_runtime_state(workspace)
     store = MessageStore(workspace)
     event_log = EventLog(workspace)
@@ -646,7 +648,7 @@ def status(workspace: Path, as_json: bool = False) -> dict[str, Any]:
     save_runtime_state(workspace, state)
     session_name = state.get("session_name")
     tmux_exists = _tmux_session_exists(session_name) if session_name else False
-    return {
+    result = {
         "team": state.get("leader", {}).get("id", "leader"),
         "session_name": session_name,
         "tmux_session_present": tmux_exists,
@@ -658,6 +660,157 @@ def status(workspace: Path, as_json: bool = False) -> dict[str, Any]:
         "results": store.result_counts(),
         "last_events": EventLog(workspace).tail(10),
     }
+    return _compact_status(result) if compact else result
+
+
+def _compact_status(data: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "team": data.get("team"),
+        "session_name": data.get("session_name"),
+        "tmux_session_present": data.get("tmux_session_present"),
+        "leader_receiver": _compact_mapping(
+            data.get("leader_receiver", {}),
+            {
+                "status",
+                "provider",
+                "mode",
+                "session_name",
+                "window_name",
+                "pane_id",
+                "pane_current_command",
+            },
+        ),
+        "agents": {
+            agent_id: _compact_agent_state(agent_id, agent)
+            for agent_id, agent in (data.get("agents") or {}).items()
+        },
+        "agent_health": data.get("agent_health", {}),
+        "tasks": [_compact_task(task) for task in data.get("tasks", [])],
+        "messages": data.get("messages", {}),
+        "results": data.get("results", {}),
+        "last_events": [_compact_event(event) for event in data.get("last_events", [])[-STATUS_EVENT_LIMIT:]],
+    }
+
+
+def _compact_agent_state(agent_id: str, agent: dict[str, Any]) -> dict[str, Any]:
+    display = agent.get("display") or {}
+    result = _compact_mapping(
+        agent,
+        {
+            "agent_id",
+            "status",
+            "provider",
+            "model",
+            "tmux_window_present",
+            "session_id",
+            "captured_via",
+            "attribution_confidence",
+        },
+    )
+    result.setdefault("agent_id", agent_id)
+    if display:
+        result["display"] = _compact_mapping(
+            display,
+            {
+                "backend",
+                "status",
+                "workspace_window",
+                "pane_id",
+                "pid",
+                "pids",
+                "reason",
+            },
+        )
+    return result
+
+
+def _compact_task(task: dict[str, Any]) -> dict[str, Any]:
+    return _compact_mapping(
+        task,
+        {
+            "id",
+            "title",
+            "status",
+            "assignee",
+            "type",
+            "risk",
+            "accepted_result_id",
+            "last_result_summary",
+        },
+    )
+
+
+def _compact_event(event: dict[str, Any]) -> dict[str, Any]:
+    skipped = {"command", "payload", "launch_args", "content", "prompt", "developer_instructions"}
+    kept = {
+        "event",
+        "ts",
+        "agent_id",
+        "task_id",
+        "message_id",
+        "result_id",
+        "status",
+        "ok",
+        "reason",
+        "error",
+        "session",
+        "window",
+        "target",
+        "backend",
+        "workspace_window",
+        "pane_id",
+        "restart_mode",
+        "provider",
+        "delivery_status",
+        "warning",
+        "collected",
+        "notified",
+        "lock",
+        "waited_sec",
+        "once",
+        "pid",
+    }
+    result: dict[str, Any] = {}
+    for key, value in event.items():
+        if key in skipped or key not in kept | {"agents", "coordinator"}:
+            continue
+        if key == "agents" and isinstance(value, list):
+            result["agent_count"] = len(value)
+            result["agents"] = [
+                _compact_mapping(item, {"agent_id", "restart_mode", "session_id"})
+                for item in value[:8]
+                if isinstance(item, dict)
+            ]
+            continue
+        result[key] = _compact_value(value)
+    return result
+
+
+def _compact_mapping(source: Any, keys: set[str]) -> dict[str, Any]:
+    if not isinstance(source, dict):
+        return {}
+    return {key: _compact_value(source[key]) for key in keys if key in source}
+
+
+def _compact_value(value: Any) -> Any:
+    if isinstance(value, str):
+        return value if len(value) <= STATUS_TEXT_LIMIT else value[: STATUS_TEXT_LIMIT - 1] + "…"
+    if isinstance(value, (int, float, bool)) or value is None:
+        return value
+    if isinstance(value, list):
+        if all(isinstance(item, (str, int, float, bool)) or item is None for item in value):
+            compact = [_compact_value(item) for item in value[:8]]
+            if len(value) > 8:
+                compact.append(f"... {len(value) - 8} more")
+            return compact
+        return f"{len(value)} item(s)"
+    if isinstance(value, dict):
+        return {
+            key: _compact_value(item)
+            for key, item in value.items()
+            if key not in {"command", "payload", "launch_args", "content", "prompt", "developer_instructions"}
+        }
+    return str(value)
 
 
 def format_status(workspace: Path, agent_id: str | None = None) -> str: