@team-agent/installer 0.2.2 → 0.2.4

package/src/team_agent/spec.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any
 
 from team_agent.errors import ValidationError
+from team_agent.display.backend import VALID_DISPLAY_BACKENDS
 from team_agent.permissions import CANONICAL_TOOLS, expand_tools
 from team_agent.profiles import AUTH_MODES
 from team_agent.simple_yaml import loads
@@ -27,9 +28,60 @@ def load_yaml(path: Path) -> dict[str, Any]:
 def load_spec(path: Path) -> dict[str, Any]:
     spec = load_yaml(path)
     validate_spec(spec, base_dir=path.parent)
+    _emit_load_time_deprecations(spec, path)
     return spec
 
 
+def _emit_load_time_deprecations(spec: dict[str, Any], path: Path) -> None:
+    """Stage 7 S7 (2026-05-27): deprecation signals attached to the spec field
+    itself must fire when the YAML is read, not lazily inside the trust-prompt
+    code path. A user with the deprecated field in team.spec.yaml needs to see
+    the warning even when startup never reaches attempt_trust_auto_answer.
+
+    The leader-panes helper owns the one-shot stderr guard + the structured
+    audit event, so we reuse it. EventLog points at the WORKSPACE ROOT (not
+    the spec file's directory) so a quick-start layout that stores the spec
+    under <workspace>/.team/current/team.spec.yaml still routes the audit
+    event into the single canonical <workspace>/.team/logs/events.jsonl
+    instead of a doubled <workspace>/.team/current/.team/logs/events.jsonl
+    nesting.
+    """
+    runtime = spec.get("runtime")
+    if not isinstance(runtime, dict):
+        return
+    if not bool(runtime.get("auto_trust_own_workspace")):
+        return
+    # Local import keeps the spec module free of messaging-layer coupling at
+    # import time; only YAMLs that opt into the deprecated field pay the cost.
+    from team_agent.events import EventLog
+    from team_agent.messaging.leader_panes import _emit_spec_opt_in_deprecation
+    _emit_spec_opt_in_deprecation(EventLog(_resolve_workspace_root(path)))
+
+
+def _resolve_workspace_root(spec_path: Path) -> Path:
+    """Find the workspace root that owns this spec.
+
+    A workspace root is the directory whose `.team/` subdirectory holds the
+    runtime state, logs, artifacts, and (for quick-start layouts) the spec
+    itself under `.team/current/`. We climb from the spec file's parent
+    looking for the first ancestor that has a `.team/` child. If no ancestor
+    qualifies (fresh workspace before init, or a spec deliberately placed
+    outside any team workspace), we fall back to `spec_path.parent` which is
+    the legacy single-layout behaviour.
+
+    Implementation note: we use real filesystem evidence (`(dir/.team).is_dir()`)
+    rather than path-string parsing so the resolver works correctly even when
+    workspace paths legitimately contain a `.team` segment.
+    """
+    direct_parent = spec_path.parent
+    if (direct_parent / ".team").is_dir():
+        return direct_parent
+    for ancestor in direct_parent.parents:
+        if (ancestor / ".team").is_dir():
+            return ancestor
+    return direct_parent
+
+
 def validate_spec(spec: dict[str, Any], base_dir: Path | None = None) -> None:
     messages = _basic_schema_errors(spec)
     messages.extend(_semantic_errors(spec, base_dir or Path.cwd()))
@@ -182,24 +234,32 @@ def _check_communication(comm: Any, errors: list[str]) -> None:
 
 
 def _check_runtime(runtime: Any, errors: list[str]) -> None:
-    required = {"backend", "display_backend", "session_name", "auto_launch", "require_user_approval_before_launch", "max_active_agents", "startup_order"}
-    allowed = required | {
+    required = {"backend", "session_name", "auto_launch", "require_user_approval_before_launch", "max_active_agents", "startup_order"}
+    allowed = required | {"display_backend"} | {
         "dangerous_auto_approve",
         "auto_attach_leader",
         "fast",
         "tick_interval_sec",
         "push_min_interval_sec",
         "stuck_timeout_sec",
+        # Gap 29 / F3 deprecation (2026-05-26): accept the legacy spec opt-in so
+        # YAMLs that still set it validate and the deprecation warning + structured
+        # event in messaging/leader_panes.py can fire. The preferred per-session
+        # opt-in is the env var TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE; this spec
+        # field will be removed in 0.3.0.
+        "auto_trust_own_workspace",
     }
     _check_keys(runtime, "/runtime", required, allowed, errors)
     if not isinstance(runtime, dict):
         return
     if runtime.get("backend") not in {"tmux", "pty"}:
         errors.append("/runtime/backend: invalid backend")
-    if runtime.get("display_backend") not in {"none", "tmux_attach", "iterm", "ghostty", "ghostty_window", "ghostty_workspace"}:
+    if "display_backend" in runtime and runtime.get("display_backend") not in VALID_DISPLAY_BACKENDS:
         errors.append("/runtime/display_backend: invalid display backend")
     if "dangerous_auto_approve" in runtime and not isinstance(runtime["dangerous_auto_approve"], bool):
         errors.append("/runtime/dangerous_auto_approve: must be a boolean")
+    if "auto_trust_own_workspace" in runtime and not isinstance(runtime["auto_trust_own_workspace"], bool):
+        errors.append("/runtime/auto_trust_own_workspace: must be a boolean")
     _check_list(runtime.get("startup_order"), "/runtime/startup_order", errors)
 
 

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/wake.py

@@ -0,0 +1,58 @@
+"""Provider-neutral wake layer (Gap 32 §2): decide WHEN to re-read a session
+file, never HOW to parse it. No polling loop, no screen, no provider names.
+
+Two cheap, passive sources:
+  - a file-change watch (the caller wires FSEvents/inotify/kqueue and calls
+    ``on_file_changed``) — naturally per-session (one file per node);
+  - an mtime gate — only re-read the tail when the file changed since the last
+    classification, or when it has been quiet past the debounce window.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def should_reread(
+    *,
+    last_mtime: float | None,
+    current_mtime: float | None,
+    last_classified_mtime: float | None,
+    now: float,
+    debounce_seconds: float,
+) -> dict[str, Any]:
+    """Return whether a fresh tail-read is warranted and why.
+
+    A read is warranted when the file changed since we last classified it, or
+    when it has been silent longer than the debounce window and we have not yet
+    classified at this mtime (so an idle-close that we already saw is not
+    re-read forever).
+    """
+    if current_mtime is None:
+        return {"reread": False, "reason": "no_file"}
+    if last_classified_mtime is None:
+        return {"reread": True, "reason": "never_classified"}
+    if current_mtime != last_classified_mtime:
+        return {"reread": True, "reason": "file_changed"}
+    silent_for = max(0.0, now - current_mtime)
+    if silent_for >= debounce_seconds:
+        return {"reread": False, "reason": "quiescent_already_classified"}
+    return {"reread": False, "reason": "unchanged"}
+
+
+def on_file_changed(watch_state: dict[str, Any] | None, *, node_id: str, mtime: float) -> dict[str, Any]:
+    """Record a file-change wake for a node (the push path)."""
+    state = dict(watch_state or {})
+    pending = set(state.get("pending") or [])
+    pending.add(node_id)
+    state["pending"] = sorted(pending)
+    state.setdefault("mtimes", {})[node_id] = mtime
+    return state
+
+
+def take_pending(watch_state: dict[str, Any] | None) -> tuple[list[str], dict[str, Any]]:
+    """Drain the set of nodes whose files changed since the last drain."""
+    state = dict(watch_state or {})
+    pending = sorted(state.get("pending") or [])
+    state["pending"] = []
+    return pending, state

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"]