@team-agent/installer 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.2.2",
+  "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]:
@@ -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/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,6 +319,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 +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,
     }

package/src/team_agent/diagnose/orphan_cleanup.py

@@ -16,7 +16,6 @@ import signal
 import subprocess
 import time
 from datetime import datetime, timezone
-from pathlib import Path
 from typing import Any
 
 # Pattern: argv contains "team_agent.coordinator --workspace <path>" anywhere.
@@ -39,6 +38,7 @@ _EPHEMERAL_PATH_HINTS = (
     "team-agent-test-",
 )
 _SIGTERM_WAIT_SECONDS = 3.0
+_SIGKILL_WAIT_SECONDS = 2.0
 
 
 def find_coordinator_processes(*, runner=subprocess.run) -> list[dict[str, Any]]:
@@ -91,7 +91,7 @@ def classify_orphan(entry: dict[str, Any]) -> tuple[bool, str]:
     workspace = entry.get("workspace")
     if not workspace:
         return False, "cmdline_unparsed"
-    if not Path(workspace).exists():
+    if not os.path.exists(workspace):
         return True, "workspace_path_missing"
     for hint in _EPHEMERAL_PATH_HINTS:
         if hint in workspace:
@@ -104,12 +104,35 @@ def cleanup_orphan_coordinators(
     confirm: bool = False,
     runner=subprocess.run,
     killer=os.kill,
+    pg_killer=None,
+    pgid_getter=None,
     sleeper=time.sleep,
+    sigterm_wait_seconds: float = _SIGTERM_WAIT_SECONDS,
+    sigkill_wait_seconds: float = _SIGKILL_WAIT_SECONDS,
 ) -> dict[str, Any]:
     """Scan for orphan coordinators. Without confirm: dry-run (just classify and report).
-    With confirm: SIGTERM each orphan and wait up to _SIGTERM_WAIT_SECONDS for the
-    process to exit; report success/failure per pid."""
+    With confirm: SIGTERM each orphan, wait up to _SIGTERM_WAIT_SECONDS for graceful
+    exit; if still alive, escalate to SIGKILL and wait _SIGKILL_WAIT_SECONDS. Only
+    report status='failed' (with error='alive_after_sigkill') when the process
+    survives BOTH signals — that's extremely rare and almost always indicates a
+    zombie/uninterruptible-sleep kernel state.
+
+    Mac mini 2026-05-26 evidence: real orphan coordinators have been observed alive
+    40+ hours; many of them never exit on SIGTERM (signal handler suppressed during
+    long sqlite reads, or the python interpreter is hosting an async loop that
+    swallows the term signal). SIGKILL escalation is required for production.
+
+    pg_killer / pgid_getter default to os.killpg / os.getpgid; mock them in tests.
+    If pgid_getter succeeds AND returns a pgid > 1 AND the pgid != pid (i.e. the
+    process leads its own process group with children), we signal the WHOLE group;
+    otherwise we signal the pid directly. This catches orphan coordinators that
+    spawned subprocess.Popen children which would otherwise survive a pid-only
+    SIGTERM."""
     now = datetime.now(timezone.utc).isoformat()
+    if pg_killer is None:
+        pg_killer = getattr(os, "killpg", None)
+    if pgid_getter is None:
+        pgid_getter = getattr(os, "getpgid", None)
     entries = find_coordinator_processes(runner=runner)
     classified: list[dict[str, Any]] = []
     orphans: list[dict[str, Any]] = []
@@ -131,30 +154,19 @@ def cleanup_orphan_coordinators(
     killed: list[dict[str, Any]] = []
     failed: list[dict[str, Any]] = []
     for entry in orphans:
-        pid = entry["pid"]
-        try:
-            killer(pid, signal.SIGTERM)
-        except (ProcessLookupError, PermissionError, OSError) as exc:
-            failed.append({**entry, "error": str(exc)})
-            continue
-        # Wait briefly; if the process is still alive after _SIGTERM_WAIT_SECONDS,
-        # mark as failed (caller may want to SIGKILL).
-        deadline = time.monotonic() + _SIGTERM_WAIT_SECONDS
-        gone = False
-        while time.monotonic() < deadline:
-            try:
-                killer(pid, 0)
-            except ProcessLookupError:
-                gone = True
-                break
-            except (PermissionError, OSError):
-                gone = True
-                break
-            sleeper(0.1)
-        if gone:
-            killed.append(entry)
+        outcome = _terminate_orphan(
+            entry["pid"], killer=killer, pg_killer=pg_killer,
+            pgid_getter=pgid_getter, sleeper=sleeper,
+            sigterm_wait_seconds=sigterm_wait_seconds,
+            sigkill_wait_seconds=sigkill_wait_seconds,
+        )
+        annotated = {**entry, **outcome}
+        if outcome.get("status") == "killed":
+            killed.append(annotated)
+        elif outcome.get("status") == "missing":
+            killed.append(annotated)
         else:
-            failed.append({**entry, "error": "still_alive_after_sigterm"})
+            failed.append(annotated)
     return {
         "ok": True,
         "scanned": len(classified),
@@ -166,6 +178,162 @@ def cleanup_orphan_coordinators(
     }
 
 
+def _terminate_orphan(
+    pid: int,
+    *,
+    killer,
+    pg_killer,
+    pgid_getter,
+    sleeper,
+    sigterm_wait_seconds: float = _SIGTERM_WAIT_SECONDS,
+    sigkill_wait_seconds: float = _SIGKILL_WAIT_SECONDS,
+) -> dict[str, Any]:
+    """SIGTERM → wait 3s → SIGKILL → wait 2s escalation. Returns one of:
+      {status: 'killed', sigkill_required: False, signaled: 'pid'|'pgid'}
+      {status: 'killed', sigkill_required: True,  signaled: 'pid'|'pgid'}
+      {status: 'missing', error: '<exc>'} — process gone before SIGTERM
+      {status: 'failed',  error: 'alive_after_sigkill'} — process survived both
+      {status: 'failed',  error: '<exc>'} — permission denied / OS error
+    """
+    pgid, pgid_error = _safe_getpgid(pid, pgid_getter)
+    use_group = bool(pg_killer and pgid is not None and pgid > 1 and pgid != pid)
+    signaled = "pgid" if use_group else "pid"
+
+    def send(sig: int) -> tuple[bool, str | None]:
+        try:
+            if use_group:
+                pg_killer(pgid, sig)
+            else:
+                killer(pid, sig)
+        except ProcessLookupError:
+            return False, "process_lookup_error"
+        except (PermissionError, OSError) as exc:
+            return False, str(exc)
+        return True, None
+
+    ok, err = send(signal.SIGTERM)
+    if not ok:
+        if err == "process_lookup_error":
+            return {"status": "missing", "signaled": signaled, "pgid": pgid}
+        return {"status": "failed", "error": err, "signaled": signaled, "pgid": pgid}
+    if _wait_for_exit(pid, sigterm_wait_seconds, killer=killer, sleeper=sleeper):
+        return {
+            "status": "killed",
+            "sigkill_required": False,
+            "signaled": signaled,
+            "pgid": pgid,
+            "pgid_error": pgid_error,
+        }
+    # SIGTERM did not work — escalate.
+    ok, err = send(signal.SIGKILL)
+    if not ok:
+        if err == "process_lookup_error":
+            # Race: died between checks.
+            return {
+                "status": "killed",
+                "sigkill_required": False,
+                "signaled": signaled,
+                "pgid": pgid,
+                "pgid_error": pgid_error,
+            }
+        return {
+            "status": "failed",
+            "error": err,
+            "signaled": signaled,
+            "pgid": pgid,
+            "sigkill_attempted": True,
+        }
+    if _wait_for_exit(pid, sigkill_wait_seconds, killer=killer, sleeper=sleeper):
+        return {
+            "status": "killed",
+            "sigkill_required": True,
+            "signaled": signaled,
+            "pgid": pgid,
+            "pgid_error": pgid_error,
+        }
+    return {
+        "status": "failed",
+        "error": "alive_after_sigkill",
+        "signaled": signaled,
+        "pgid": pgid,
+        "sigkill_required": True,
+    }
+
+
+def _safe_getpgid(pid: int, pgid_getter) -> tuple[int | None, str | None]:
+    if pgid_getter is None:
+        return None, "getpgid_unavailable"
+    try:
+        return pgid_getter(pid), None
+    except (ProcessLookupError, PermissionError, OSError) as exc:
+        return None, str(exc)
+
+
+def _wait_for_exit(pid: int, timeout: float, *, killer, sleeper) -> bool:
+    deadline = time.monotonic() + max(timeout, 0.0)
+    while time.monotonic() < deadline:
+        try:
+            killer(pid, 0)
+        except ProcessLookupError:
+            return True
+        except (PermissionError, OSError):
+            return True
+        sleeper(0.1)
+    # Final check after the deadline elapses.
+    try:
+        killer(pid, 0)
+    except ProcessLookupError:
+        return True
+    except (PermissionError, OSError):
+        return True
+    return False
+
+
+def orphan_gate(
+    *,
+    fix: bool = False,
+    confirm: bool = False,
+    runner=subprocess.run,
+    killer=os.kill,
+    pg_killer=None,
+    pgid_getter=None,
+    sleeper=time.sleep,
+    sigterm_wait_seconds: float = _SIGTERM_WAIT_SECONDS,
+    sigkill_wait_seconds: float = _SIGKILL_WAIT_SECONDS,
+) -> dict[str, Any]:
+    if fix and not confirm:
+        return {
+            "ok": False,
+            "gate": "orphans",
+            "status": "refused",
+            "reason": "fix_requires_confirm",
+            "action": "re-run with --gate orphans --fix --confirm",
+        }
+    result = cleanup_orphan_coordinators(
+        confirm=fix and confirm,
+        runner=runner,
+        killer=killer,
+        pg_killer=pg_killer,
+        pgid_getter=pgid_getter,
+        sleeper=sleeper,
+        sigterm_wait_seconds=sigterm_wait_seconds,
+        sigkill_wait_seconds=sigkill_wait_seconds,
+    )
+    orphans = result.get("orphans") or []
+    failed = result.get("failed") or []
+    passed = not orphans if not fix else not failed
+    envelope = {
+        **result,
+        "ok": passed,
+        "gate": "orphans",
+        "status": "passed" if passed else "failed",
+        "fix": bool(fix),
+    }
+    if not fix and orphans:
+        envelope["action_required"] = "re-run with --gate orphans --fix --confirm"
+    return envelope
+
+
 def format_cleanup_orphans(result: dict[str, Any]) -> str:
     lines = [
         f"Coordinator orphan scan @ {result.get('scanned_at')}",
@@ -175,7 +343,9 @@ def format_cleanup_orphans(result: dict[str, Any]) -> str:
     if result.get("dry_run"):
         lines.append("  mode: DRY-RUN (no SIGTERM sent; re-run with --confirm)")
     else:
-        lines.append(f"  killed: {len(result.get('killed') or [])}")
+        killed_entries = result.get("killed") or []
+        escalated = sum(1 for k in killed_entries if k.get("sigkill_required"))
+        lines.append(f"  killed: {len(killed_entries)}  (sigkill_required: {escalated})")
         lines.append(f"  failed: {len(result.get('failed') or [])}")
     for orphan in result.get("orphans") or []:
         lines.append(
@@ -190,4 +360,5 @@ __all__ = [
     "classify_orphan",
     "find_coordinator_processes",
     "format_cleanup_orphans",
+    "orphan_gate",
 ]

package/src/team_agent/launch/core.py

@@ -215,7 +215,7 @@ def launch(
                 stdout=proc.stdout,
             )
             raise RuntimeError(f"Failed to start agent {agent['id']}: {proc.stderr.strip()}")
-        handled_prompts = adapter.handle_startup_prompts(session_name, agent["id"], checks=1, sleep_s=0.0)
+        handled_prompts = adapter.handle_startup_prompts(session_name, agent["id"], checks=20, sleep_s=0.5)
         for prompt_event in handled_prompts:
             event_log.write(
                 "launch.startup_prompt_handled",
@@ -261,6 +261,7 @@ def launch(
             event_log,
             timeout_s=1.5,
             exclude_session_ids=known_session_ids,
+            raise_on_missed=False,
         )
         if state.get("display_backend") in GHOSTTY_DISPLAY_BACKENDS:
             display_jobs.append((agent["id"], agent))

package/src/team_agent/lifecycle/operations.py

@@ -358,6 +358,7 @@ def fork_agent(
             event_log,
             timeout_s=1.5,
             exclude_session_ids={source_session_id},
+            raise_on_missed=False,
         )
         if open_display and state.get("display_backend") in {"ghostty", "ghostty_window"}:
             agent_state["display"] = _open_ghostty_worker_window(workspace, session_name, as_agent_id, new_agent, event_log)

package/src/team_agent/lifecycle/start.py

@@ -319,7 +319,7 @@ def _start_agent_unlocked(workspace: Path, agent_id: str, force: bool, open_disp
         _clear_session_capture_fields(agent_state)
         if command_agent.get("_session_id"):
             agent_state["_pending_session_id"] = command_agent["_session_id"]
-        _capture_agent_session(workspace, agent_id, agent_state, event_log, timeout_s=1.5, exclude_session_ids=known_session_ids)
+        _capture_agent_session(workspace, agent_id, agent_state, event_log, timeout_s=1.5, exclude_session_ids=known_session_ids, raise_on_missed=False)
     if open_display and state.get("display_backend") in {"ghostty", "ghostty_window"}:
         agent_state["display"] = _open_ghostty_worker_window(workspace, session_name, agent_id, agent, event_log)
     elif open_display and state.get("display_backend") == "ghostty_workspace":

package/src/team_agent/message_store/core.py

@@ -331,17 +331,17 @@ class MessageStore:
         return counts
 
     def add_result(self, envelope: dict[str, Any], owner_team_id: str | None = None) -> str:
-        _ = owner_team_id
         validate_result_envelope(envelope)
         result_id = f"res_{uuid.uuid4().hex[:12]}"
         with closing(self.connect()) as conn:
             with conn:
                 conn.execute(
                     """
-                    insert into results(result_id, task_id, agent_id, envelope, status, created_at)
-                    values (?, ?, ?, ?, ?, ?)
+                    insert into results(owner_team_id, result_id, task_id, agent_id, envelope, status, created_at)
+                    values (?, ?, ?, ?, ?, ?, ?)
                     """,
                     (
+                        owner_team_id,
                         result_id,
                         envelope["task_id"],
                         envelope["agent_id"],
@@ -423,16 +423,17 @@ class MessageStore:
         return dict(row) if row else None
 
     def latest_results(self, limit: int = 5, owner_team_id: str | None = None) -> list[dict[str, Any]]:
-        _ = owner_team_id
+        owner_clause = "and owner_team_id = ?" if owner_team_id else ""
+        args: tuple[Any, ...] = (owner_team_id, limit) if owner_team_id else (limit,)
         with closing(self.connect()) as conn:
             rows = conn.execute(
-                """
+                f"""
                 select * from results
-                where status != 'invalid'
+                where status != 'invalid' {owner_clause}
                 order by created_at desc
                 limit ?
                 """,
-                (limit,),
+                args,
             ).fetchall()
         return [dict(row) for row in reversed(rows)]
 

package/src/team_agent/message_store/schema.py

@@ -22,7 +22,7 @@ MESSAGE_COLUMNS = {
     "error",
     "delivery_attempts",
 }
-RESULT_COLUMNS = {"result_id", "task_id", "agent_id", "envelope", "status", "created_at"}
+RESULT_COLUMNS = {"owner_team_id", "result_id", "task_id", "agent_id", "envelope", "status", "created_at"}
 SCHEDULED_EVENT_COLUMNS = {
     "id",
     "owner_team_id",
@@ -125,6 +125,7 @@ def initialize_schema(conn: sqlite3.Connection) -> None:
             """
             create table if not exists results (
               result_id text primary key,
+              owner_team_id text,
               task_id text not null,
               agent_id text not null,
               envelope text not null,
@@ -215,7 +216,12 @@ def initialize_schema(conn: sqlite3.Connection) -> None:
                 "owner_team_id": "alter table messages add column owner_team_id text",
             },
         )
-        _ensure_table_columns(conn, "results", RESULT_COLUMNS)
+        _ensure_table_columns(
+            conn,
+            "results",
+            RESULT_COLUMNS,
+            {"owner_team_id": "alter table results add column owner_team_id text"},
+        )
         _ensure_table_columns(
             conn,
             "scheduled_events",