@team-agent/installer 0.2.1 → 0.2.3

package/src/team_agent/status/inbox.py

@@ -1,24 +1,54 @@
 from __future__ import annotations
 
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
 from team_agent.message_store import MessageStore
 
 
-def inbox(workspace: Path, agent_id: str, limit: int = 20) -> dict[str, Any]:
+def _parse_since(since: str | None) -> datetime | None:
+    if not since:
+        return None
+    try:
+        dt = datetime.fromisoformat(since.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def _filter_since(rows: list[dict[str, Any]], since: str | None) -> list[dict[str, Any]]:
+    cutoff = _parse_since(since)
+    if cutoff is None:
+        return rows
+    filtered: list[dict[str, Any]] = []
+    for row in rows:
+        ts_raw = str(row.get("created_at") or "")
+        ts = _parse_since(ts_raw)
+        if ts and ts >= cutoff:
+            filtered.append(row)
+    return filtered
+
+
+def inbox(workspace: Path, agent_id: str, limit: int = 20, since: str | None = None) -> dict[str, Any]:
     rows = MessageStore(workspace).inbox(agent_id, limit=limit)
-    return {"ok": True, "agent_id": agent_id, "messages": rows}
+    rows = _filter_since(rows, since)
+    return {"ok": True, "agent_id": agent_id, "messages": rows, "since": since}
 
 
-def format_inbox(workspace: Path, agent_id: str, limit: int = 20) -> str:
+def format_inbox(workspace: Path, agent_id: str, limit: int = 20, since: str | None = None) -> str:
     store = MessageStore(workspace)
     rows = store.inbox(agent_id, limit=limit)
+    rows = _filter_since(rows, since)
     result_counts = store.result_counts()
     note = "final results are not in inbox; use team-agent collect"
     if result_counts.get("uncollected", 0):
         note += f" ({result_counts['uncollected']} uncollected result(s) pending)"
     if not rows:
+        if since:
+            return f"{agent_id}: no messages since {since}\n{note}"
         return f"{agent_id}: no messages\n{note}"
     lines = [
         f"{row['created_at']} {row['sender']} -> {row['recipient']} {row['status']}: {row['content']}"

package/src/team_agent/status/queries.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -11,6 +12,24 @@ from team_agent.status.compact import compact_status
 from team_agent.status.constants import PENDING_DELIVERY_STATUSES
 
 
+def _interacted_marker(first_send_at: Any) -> str:
+    """C3 (cr verdict, 2026-05-27): render the persisted first_send_at as a
+    user-visible status field. Valid ISO 8601 UTC strings pass through; any
+    other shape (None, empty string, 0, False, corrupt garbage) renders as
+    the literal "never" so the operator sees a consistent classification
+    instead of leaking raw garbage into status output. Restart enforces
+    strict typing separately (corrupt values fail the operation); status is
+    a read-only surface and tolerantly degrades to "never" rather than
+    failing the status command."""
+    if isinstance(first_send_at, str) and first_send_at:
+        try:
+            datetime.fromisoformat(first_send_at)
+        except (ValueError, TypeError):
+            return "never"
+        return first_send_at
+    return "never"
+
+
 def status(workspace: Path, as_json: bool = False, *, compact: bool = False) -> dict[str, Any]:
     from team_agent.runtime import (
         _capture_missing_sessions,
@@ -31,12 +50,24 @@ def status(workspace: Path, as_json: bool = False, *, compact: bool = False) ->
     save_runtime_state(workspace, state)
     session_name = state.get("session_name")
     tmux_exists = _tmux_session_exists(session_name) if session_name else False
+    # C3 (cr verdict): enrich each worker entry with an explicit `interacted`
+    # field derived from the persisted first_send_at. The original entry
+    # passes through unchanged so any pre-existing field (including raw
+    # first_send_at) stays visible.
+    enriched_agents: dict[str, Any] = {}
+    for aid, raw in (state.get("agents") or {}).items():
+        if isinstance(raw, dict):
+            entry = dict(raw)
+            entry["interacted"] = _interacted_marker(raw.get("first_send_at"))
+        else:
+            entry = raw
+        enriched_agents[aid] = entry
     result = {
         "team": state.get("leader", {}).get("id", "leader"),
         "session_name": session_name,
         "tmux_session_present": tmux_exists,
         "leader_receiver": state.get("leader_receiver", {}),
-        "agents": state.get("agents", {}),
+        "agents": enriched_agents,
         "agent_health": store.agent_health(),
         "tasks": state.get("tasks", []),
         "messages": store.message_counts(),

package/src/team_agent/watch/__init__.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+from team_agent.message_store import MessageStore
+from team_agent.paths import logs_dir, runtime_dir
+from team_agent.status.queries import result_summary_from_row
+
+
+@dataclass
+class WatchCursor:
+    event_offset: int = 0
+    seen_result_ids: set[str] = field(default_factory=set)
+    initialized: bool = False
+    archive_signature: tuple[int, int] | None = None
+
+
+ROTATION_MARKER = "[watch] log rotated; archived segment events.jsonl.1 not replayed — historical replay deferred to a future --replay flag"
+
+
+def run_watch(
+    workspace: Path,
+    *,
+    team: str | None = None,
+    interval: float = 0.5,
+    output: Callable[[str], None] = print,
+    sleep: Callable[[float], None] = time.sleep,
+) -> None:
+    cursor = WatchCursor()
+    while True:
+        for line in collect_watch_lines(workspace, cursor, team=team):
+            output(line)
+        sleep(interval)
+
+
+def collect_watch_lines(workspace: Path, cursor: WatchCursor, *, team: str | None = None) -> list[str]:
+    lines = _collect_event_lines(workspace, cursor, team=team)
+    lines.extend(_collect_result_lines(workspace, cursor, team=team))
+    return lines
+
+
+def render_event_line(event: dict[str, Any]) -> str | None:
+    kind = event.get("event")
+    if kind == "result_received":
+        return _result_line(event.get("agent_id"), event.get("summary"))
+    if kind in {"leader_receiver.injected", "leader_receiver.submitted"}:
+        return f"leader_receiver.injected: {_message_snippet(event)} -> {_recipient(event)}"
+    if kind == "send.failed":
+        return f"send.failed: {_recipient(event)} reason={_clean(event.get('reason') or event.get('error') or '-')}"
+    if kind == "leader_receiver.rebind_required":
+        pane = event.get("old_pane_id") or event.get("pane_id") or event.get("target") or "-"
+        reason = event.get("reason") or event.get("rediscovery_status") or "-"
+        return f"leader_receiver.rebind_required: pane={pane} reason={_clean(reason)}"
+    if kind == "leader.api_error":
+        error_class = event.get("error_class") or "Unknown"
+        provider = event.get("provider") or "-"
+        snippet = _clean(event.get("matched_pattern_snippet") or event.get("snippet") or "-")
+        return f"leader.api_error: {error_class} provider={provider} snippet={snippet}"
+    return None
+
+
+def _collect_event_lines(workspace: Path, cursor: WatchCursor, *, team: str | None = None) -> list[str]:
+    path = logs_dir(workspace) / "events.jsonl"
+    archive_signature = _archive_signature(path.with_name("events.jsonl.1"))
+    lines: list[str] = []
+    if not cursor.initialized:
+        cursor.archive_signature = archive_signature
+        cursor.initialized = True
+    elif archive_signature and archive_signature != cursor.archive_signature:
+        lines.append(ROTATION_MARKER)
+        cursor.archive_signature = archive_signature
+        cursor.event_offset = 0
+    if not path.exists():
+        return lines
+    size = path.stat().st_size
+    if cursor.event_offset > size:
+        if ROTATION_MARKER not in lines:
+            lines.append(ROTATION_MARKER)
+        cursor.event_offset = 0
+    with path.open("r", encoding="utf-8") as handle:
+        handle.seek(cursor.event_offset)
+        for raw in handle:
+            try:
+                event = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if team and _event_team_id(event) != team:
+                continue
+            rendered = render_event_line(event)
+            if rendered:
+                lines.append(rendered)
+        cursor.event_offset = handle.tell()
+    return lines
+
+
+def _collect_result_lines(workspace: Path, cursor: WatchCursor, *, team: str | None = None) -> list[str]:
+    if not (runtime_dir(workspace) / "team.db").exists():
+        return []
+    store = MessageStore(workspace)
+    lines: list[str] = []
+    for row in store.latest_results(limit=20, owner_team_id=team):
+        result_id = str(row.get("result_id") or "")
+        if not result_id or result_id in cursor.seen_result_ids:
+            continue
+        cursor.seen_result_ids.add(result_id)
+        summary = result_summary_from_row(row) or {}
+        lines.append(_result_line(summary.get("agent_id"), summary.get("summary")))
+    return lines
+
+
+def _result_line(agent_id: Any, summary: Any) -> str:
+    return f"result_received: {agent_id or '-'} -> {_clean(summary or '-')[:80]}"
+
+
+def _message_snippet(event: dict[str, Any]) -> str:
+    message_id = str(event.get("message_id") or event.get("msg_id") or "-")
+    return message_id[:12] if message_id != "-" else "-"
+
+
+def _recipient(event: dict[str, Any]) -> str:
+    return str(event.get("recipient") or event.get("to") or event.get("target") or "-")
+
+
+def _clean(value: Any) -> str:
+    return " ".join(str(value).split())
+
+
+def _event_team_id(event: dict[str, Any]) -> str | None:
+    value = event.get("team_id") or event.get("owner_team_id") or event.get("team")
+    return str(value) if value else None
+
+
+def _archive_signature(path: Path) -> tuple[int, int] | None:
+    try:
+        stat = path.stat()
+    except FileNotFoundError:
+        return None
+    return (stat.st_size, stat.st_mtime_ns)
+
+
+__all__ = ["ROTATION_MARKER", "WatchCursor", "collect_watch_lines", "render_event_line", "run_watch"]