@team-agent/installer 0.2.11 → 0.3.1

package/src/team_agent/idle_predicate.py

@@ -1,218 +0,0 @@
-"""Provider-neutral take-over reminder predicate (Gap 32 §3).
-
-Consumes already-classified node states only. Contains no provider knowledge.
-Rules: arm only after a worker has opened a turn (C1); fire one neutral ping when
-every node is idle for a monotonic debounce window (C2/C11); idle_interrupted
-counts as idle but is annotated (C12); re-arm on a real turn-open edge (C3).
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-_IDLE_STATES = {"idle", "idle_interrupted"}
-_DELEGATED_STATES = {"working", "blocked_on_human", "idle_interrupted", "abnormal"}
-
-_ARM_KEY = "opened_worker_turn_since_ack"
-_SUPPRESS_KEY = "suppressed"
-
-
-def evaluate_takeover_reminder(
-    nodes: list[dict[str, Any]],
-    *,
-    monitor_state: dict[str, Any] | None,
-    now_monotonic: float,
-    debounce_seconds: float,
-    suspend_intervals: list[tuple[float, float]] | None = None,
-    event_sink: Any = None,
-) -> dict[str, Any]:
-    state = dict(monitor_state or {})
-    state.setdefault(_ARM_KEY, False)
-    state.setdefault(_SUPPRESS_KEY, False)
-    state.setdefault("all_idle_since", None)
-    state.setdefault("pinged_for_episode", None)
-
-    # C1: a WORKER turn-open (working / blocked / interrupted / faulted) is the
-    # only thing that arms the watch. Leader-only activity never arms it.
-    for node in nodes:
-        if _role(node) == "leader":
-            continue
-        if node.get("state") in _DELEGATED_STATES:
-            state[_ARM_KEY] = True
-
-    # Any non-idle node blocks the ping; report which kind (C5 unknown / C14 working).
-    for node in nodes:
-        node_state = node.get("state")
-        if node_state not in _IDLE_STATES:
-            state["all_idle_since"] = None
-            state["pinged_for_episode"] = None
-            return _result(False, None, f"node_{node_state or 'unknown'}", _interrupted(nodes), state, event_sink=event_sink, node=node)
-
-    if not nodes:
-        return _result(False, None, "no_nodes", [], state, event_sink=event_sink)
-
-    if state.get("all_idle_since") is None:
-        state["all_idle_since"] = now_monotonic
-        state["pinged_for_episode"] = None
-    elapsed = _active_elapsed(state["all_idle_since"], now_monotonic, suspend_intervals)
-    interrupted = _interrupted(nodes)
-
-    if not state.get(_ARM_KEY):
-        return _result(False, None, "not_armed_no_worker_turn", interrupted, state, event_sink=event_sink)
-    if state.get(_SUPPRESS_KEY):
-        return _result(False, None, "acknowledged", interrupted, state, event_sink=event_sink)
-    if elapsed < debounce_seconds:
-        return _result(False, None, "debounce_active", interrupted, state, event_sink=event_sink)
-    if state.get("pinged_for_episode") == state.get("all_idle_since"):
-        return _result(False, None, "already_pinged_this_episode", interrupted, state, event_sink=event_sink)
-
-    state["pinged_for_episode"] = state["all_idle_since"]
-    message = _neutral_message(len(nodes), elapsed, interrupted)
-    _emit(event_sink, "idle_takeover.ping", nodes=len(nodes), elapsed_seconds=int(elapsed), interrupted=[i["node_id"] for i in interrupted])
-    return _result(True, message, "all_idle_debounce_elapsed", interrupted, state, event_sink=event_sink)
-
-
-def record_turn_open_after_delivery(
-    monitor_state: dict[str, Any] | None,
-    *,
-    node_id: str,
-    turn_id: str | None,
-    delivered_message_id: str | None,
-    now_monotonic: float,
-    event_sink: Any = None,
-) -> dict[str, Any]:
-    """A delivered inbound message produced a real turn-open edge (C3).
-
-    Re-arms a previously acknowledged watch so delivered-but-unprocessed work
-    can never leave it permanently suppressed. Returns the updated monitor_state
-    directly (with the re-arm flags set).
-    """
-    state = dict(monitor_state or {})
-    state[_ARM_KEY] = True
-    state[_SUPPRESS_KEY] = False
-    state["all_idle_since"] = None
-    state["pinged_for_episode"] = None
-    state["last_turn_open"] = {
-        "node_id": node_id,
-        "turn_id": turn_id,
-        "delivered_message_id": delivered_message_id,
-        "at": now_monotonic,
-    }
-    state["ok"] = True
-    state["rearmed"] = True
-    _emit(event_sink, "idle_takeover.turn_open_rearmed", node_id=node_id, turn_id=turn_id, delivered_message_id=delivered_message_id)
-    return state
-
-
-def _role(node: dict[str, Any]) -> str:
-    return str(node.get("role") or ("leader" if node.get("is_leader") else "worker"))
-
-
-def _interrupted(nodes: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    return [
-        {
-            "node_id": n.get("node_id"),
-            "node": n.get("node_id"),
-            "state": "idle_interrupted",
-            "reason": "interrupted",
-            "interrupted": True,
-            "kind": "interrupted",
-            "type": "interrupted",
-            "annotation": "interrupted",
-        }
-        for n in nodes
-        if n.get("state") == "idle_interrupted"
-    ]
-
-
-def _active_elapsed(start: float, now: float, suspend_intervals: list[tuple[float, float]] | None) -> float:
-    elapsed = max(0.0, now - start)
-    if not suspend_intervals:
-        return elapsed
-    # C11: clip each window to [start, now], then MERGE overlapping/duplicate
-    # windows before subtracting, so an overlap is never counted twice.
-    clipped: list[tuple[float, float]] = []
-    for interval in suspend_intervals:
-        try:
-            s, e = float(interval[0]), float(interval[1])
-        except (TypeError, ValueError, IndexError):
-            continue
-        lo = max(s, start)
-        hi = min(e, now)
-        if hi > lo:
-            clipped.append((lo, hi))
-    suspended = 0.0
-    for lo, hi in _merge_intervals(clipped):
-        suspended += hi - lo
-    return max(0.0, elapsed - suspended)
-
-
-def _merge_intervals(intervals: list[tuple[float, float]]) -> list[tuple[float, float]]:
-    if not intervals:
-        return []
-    ordered = sorted(intervals)
-    merged: list[tuple[float, float]] = [ordered[0]]
-    for lo, hi in ordered[1:]:
-        last_lo, last_hi = merged[-1]
-        if lo <= last_hi:  # overlapping or touching → merge
-            merged[-1] = (last_lo, max(last_hi, hi))
-        else:
-            merged.append((lo, hi))
-    return merged
-
-
-def _neutral_message(node_count: int, elapsed: float, interrupted: list[dict[str, Any]]) -> str:
-    minutes = max(1, int(round(elapsed / 60.0)))
-    base = (
-        f"All nodes idle: {node_count} team nodes have had every turn closed for "
-        f"about {minutes} min. If this idle state is intentional, run "
-        f"team-agent acknowledge-idle to confirm it."
-    )
-    if interrupted:
-        ids = ", ".join(str(i["node_id"]) for i in interrupted)
-        base += f" Interrupted nodes: {ids}."
-    return base
-
-
-def _result(
-    should_ping: bool,
-    message: str | None,
-    reason: str,
-    annotations: list[dict[str, Any]],
-    state: dict[str, Any],
-    *,
-    event_sink: Any = None,
-    node: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    if not should_ping and state.get("last_no_ping_reason") != reason:
-        state["last_no_ping_reason"] = reason
-        _emit(
-            event_sink,
-            "idle_takeover.no_ping",
-            reason=reason,
-            node_id=(node or {}).get("node_id"),
-            armed=bool(state.get(_ARM_KEY)),
-        )
-    return {
-        "should_ping": should_ping,
-        "message": message,
-        "reason": reason,
-        "annotations": list(annotations),
-        "interrupted_nodes": [a.get("node_id") for a in annotations],
-        "interrupted": [a.get("node_id") for a in annotations],
-        "monitor_state": state,
-    }
-
-
-def _emit(event_sink: Any, name: str, **fields: Any) -> None:
-    if event_sink is None:
-        return
-    try:
-        event_sink(name, fields)
-    except TypeError:
-        try:
-            event_sink({"event": name, **fields})
-        except Exception:
-            pass
-    except Exception:
-        pass

package/src/team_agent/idle_takeover.py

@@ -1,59 +0,0 @@
-"""Gap 32 idle/take-over public facade.
-
-Thin surface that the runtime + acceptance contract import. Provider dispatch
-lives in ``provider_state``; the predicate / abnormal / wake logic lives in the
-provider-neutral modules. This module only wires them together.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from team_agent.abnormal_track import detect_whole_team_gone, process_abnormal_records
-from team_agent.idle_predicate import evaluate_takeover_reminder, record_turn_open_after_delivery
-from team_agent.provider_state import read_turn_state
-from team_agent.provider_state.registry import get_provider_registry
-
-
-def classify_provider_turn_state(
-    provider: str,
-    session_log_text: str,
-    *,
-    process: Any = None,
-    file_silence_seconds: float = 0,
-    registry: Any = None,
-    event_sink: Any = None,
-) -> dict[str, Any]:
-    """Classify one node's turn state from its provider session-log text."""
-    result = read_turn_state(
-        provider,
-        session_log_text,
-        process=process,
-        file_silence_seconds=file_silence_seconds,
-        registry=registry,
-    )
-    if event_sink is not None and result.get("state") in {"unknown", "abnormal"}:
-        _emit(event_sink, "idle_takeover.classify", provider=provider, state=result.get("state"), reason=result.get("reason"))
-    return result
-
-
-__all__ = [
-    "classify_provider_turn_state",
-    "evaluate_takeover_reminder",
-    "record_turn_open_after_delivery",
-    "process_abnormal_records",
-    "detect_whole_team_gone",
-    "get_provider_registry",
-]
-
-
-def _emit(event_sink: Any, name: str, **fields: Any) -> None:
-    try:
-        event_sink(name, fields)
-    except TypeError:
-        try:
-            event_sink({"event": name, **fields})
-        except Exception:
-            pass
-    except Exception:
-        pass

package/src/team_agent/idle_takeover_wiring.py

@@ -1,114 +0,0 @@
-"""Gap 32 runtime wiring: drive the file-fact idle/takeover reminder from the
-coordinator tick. This is the glue that replaces the legacy screen-scrape
-`detect_idle_fallbacks` path — it classifies each node from its provider
-session-log file (never the pane) and runs the provider-neutral predicate.
-"""
-
-from __future__ import annotations
-
-import time
-from pathlib import Path
-from typing import Any
-
-_TAIL_BYTES = 131072
-_DEBOUNCE_SECONDS = 60.0
-
-
-IDLE_DEBOUNCE_SECONDS = _DEBOUNCE_SECONDS
-
-
-def build_idle_nodes(state: dict[str, Any]) -> list[dict[str, Any]]:
-    """Classify every live node from its provider session-log file fact (never
-    the pane screen, never message-row status). The leader is read via its own
-    transcript when its path is tracked (C13), else omitted rather than guessed.
-    """
-    from team_agent.provider_state import read_turn_state
-
-    nodes: list[dict[str, Any]] = []
-    for agent_id, agent_state in (state.get("agents") or {}).items():
-        if str(agent_state.get("status") or "") in {"stopped", "paused"}:
-            continue
-        provider = str(agent_state.get("provider") or "")
-        classification = read_turn_state(provider, _read_session_tail(agent_state.get("rollout_path")))
-        nodes.append({
-            "node_id": agent_id,
-            "role": "worker",
-            "state": classification.get("state"),
-            "turn_id": classification.get("turn_id"),
-            "annotations": classification.get("annotations"),
-            "provider": provider,
-            "auth_mode": agent_state.get("auth_mode"),
-            "rollout_path": agent_state.get("rollout_path"),
-        })
-    leader_node = _leader_node(state)
-    if leader_node is not None:
-        nodes.append(leader_node)
-    return nodes
-
-
-def push_idle_reminder(workspace: Path, state: dict[str, Any], event_log: Any, result: dict[str, Any]) -> None:
-    """Deliver the one neutral take-over reminder to the leader when the
-    predicate fired. No-op otherwise."""
-    if not result.get("should_ping"):
-        return
-    from team_agent.messaging.internal_delivery import deliver_stored_message
-    from team_agent.state import team_state_key
-
-    leader_id = (state.get("leader") or {}).get("id") or "leader"
-    try:
-        deliver_stored_message(
-            workspace,
-            leader_id,
-            result["message"],
-            sender="coordinator",
-            requires_ack=False,
-            wait_visible=False,
-            team=team_state_key(state),
-        )
-    except Exception as exc:
-        event_log.write("idle_takeover.push_failed", error=str(exc))
-    event_log.write(
-        "idle_takeover.reminder",
-        interrupted=result.get("interrupted_nodes"),
-        reason=result.get("reason"),
-    )
-
-
-def _leader_node(state: dict[str, Any]) -> dict[str, Any] | None:
-    """Best-effort leader node from its own provider transcript (C13). If the
-    leader's session file path is not tracked, the leader is omitted rather than
-    guessed — the predicate then evaluates the workers (the leader is the ping
-    recipient and acts on the reminder regardless)."""
-    from team_agent.provider_state import read_turn_state
-
-    leader = state.get("leader") if isinstance(state.get("leader"), dict) else {}
-    receiver = state.get("leader_receiver") if isinstance(state.get("leader_receiver"), dict) else {}
-    path = leader.get("rollout_path") or receiver.get("rollout_path")
-    provider = str(leader.get("provider") or receiver.get("provider") or "")
-    if not path or not provider:
-        return None
-    classification = read_turn_state(provider, _read_session_tail(path))
-    return {
-        "node_id": leader.get("id") or "leader",
-        "role": "leader",
-        "state": classification.get("state"),
-        "turn_id": classification.get("turn_id"),
-        "annotations": classification.get("annotations"),
-    }
-
-
-def _read_session_tail(path: Any, max_bytes: int = _TAIL_BYTES) -> str:
-    if not path:
-        return ""
-    try:
-        p = Path(str(path))
-        size = p.stat().st_size
-        with p.open("rb") as handle:
-            if size > max_bytes:
-                handle.seek(size - max_bytes)
-                # drop a possibly-partial first line after seeking mid-file
-                handle.readline()
-            data = handle.read()
-        return data.decode("utf-8", errors="ignore")
-    except (OSError, ValueError):
-        return ""

package/src/team_agent/launch/__init__.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-from team_agent.launch.bootstrap import (
-    attach_team_profile_dirs,
-    compile_team_dir_spec,
-    init_workspace,
-    is_team_doc_dir,
-    spec_team_dir,
-    tmux_session_conflict_error,
-    validate_file,
-)
-from team_agent.launch.config import (
-    DANGEROUS_LEADER_FLAGS,
-    command_has_flag,
-    detect_inherited_dangerous_permissions,
-    effective_runtime_config,
-    process_ancestry,
-    process_info,
-    requires_direct_leader_receiver,
-)
-from team_agent.launch.core import launch
-from team_agent.launch.requirements import ensure_agent_start_requirements
-
-__all__ = [
-    "DANGEROUS_LEADER_FLAGS",
-    "attach_team_profile_dirs",
-    "command_has_flag",
-    "compile_team_dir_spec",
-    "detect_inherited_dangerous_permissions",
-    "effective_runtime_config",
-    "ensure_agent_start_requirements",
-    "init_workspace",
-    "is_team_doc_dir",
-    "launch",
-    "process_ancestry",
-    "process_info",
-    "requires_direct_leader_receiver",
-    "spec_team_dir",
-    "tmux_session_conflict_error",
-    "validate_file",
-]

package/src/team_agent/launch/bootstrap.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.simple_yaml import dumps
-from team_agent.spec import load_spec, workspace_from_spec
-
-
-def init_workspace(workspace: Path, force: bool = False) -> dict[str, Path]:
-    from team_agent.runtime import ensure_workspace_dirs
-    from team_agent.paths import example_path, template_path
-
-    ensure_workspace_dirs(workspace)
-    team_dir = workspace / ".team" / "current"
-    team_dir.mkdir(parents=True, exist_ok=True)
-    spec_path = team_dir / "team.spec.yaml"
-    state_path = workspace / "team_state.md"
-    if spec_path.exists() and not force:
-        from team_agent.runtime import RuntimeError
-        raise RuntimeError(f"{spec_path} already exists; pass --force to overwrite")
-    spec_path.write_text(example_path("team.spec.yaml").read_text(encoding="utf-8"), encoding="utf-8")
-    if not state_path.exists() or force:
-        state_path.write_text(template_path("team_state.md").read_text(encoding="utf-8"), encoding="utf-8")
-    EventLog(workspace).write("init", spec_path=str(spec_path), state_path=str(state_path))
-    return {"spec": spec_path, "state": state_path}
-
-
-def validate_file(spec_path: Path) -> dict[str, Any]:
-    if spec_path.is_dir():
-        from team_agent.compiler import compile_team
-
-        result = compile_team(spec_path)
-        spec = result["spec"]
-        return {
-            "ok": True,
-            "type": "team_dir",
-            "workspace": str(Path(spec["team"]["workspace"]).resolve()),
-            "team": spec["team"]["name"],
-            "agents": [agent["id"] for agent in spec.get("agents", [])],
-        }
-    spec = load_spec(spec_path)
-    workspace = workspace_from_spec(spec, spec_path)
-    return {"ok": True, "workspace": str(workspace), "team": spec["team"]["name"]}
-
-
-def tmux_session_conflict_error(session_name: str) -> str:
-    return (
-        f"tmux session already exists: {session_name}. "
-        "Startup will not terminate existing tmux sessions because they may belong to active teams. "
-        "Use a different team name or runtime.session_name and start again."
-    )
-
-
-def spec_team_dir(spec_path: Path, workspace: Path) -> Path:
-    spec_dir = spec_path.resolve().parent
-    if spec_dir.parent.name == ".team":
-        return spec_dir
-    return workspace.resolve() / ".team" / "current"
-
-
-def is_team_doc_dir(team_dir: Path) -> bool:
-    return (team_dir / "TEAM.md").exists() and (team_dir / "agents").is_dir()
-
-
-def compile_team_dir_spec(team_dir: Path, workspace: Path) -> dict[str, Any]:
-    from team_agent.compiler import compile_team
-
-    spec_path = team_dir / "team.spec.yaml"
-    compiled = compile_team(team_dir, spec_path)
-    if compiled["spec"].get("context", {}).get("state_file") == "team_state.md":
-        state_file = str(team_dir.relative_to(workspace) / "team_state.md") if team_dir.is_relative_to(workspace) else "team_state.md"
-        compiled["spec"]["context"]["state_file"] = state_file
-        spec_path.write_text(dumps(compiled["spec"]), encoding="utf-8")
-    return compiled
-
-
-def attach_team_profile_dirs(spec: dict[str, Any], spec_path: Path, workspace: Path | None = None, team_dir: Path | None = None) -> None:
-    workspace = workspace.resolve() if workspace else workspace_from_spec(spec, spec_path)
-    team_dir = team_dir.resolve() if team_dir else spec_team_dir(spec_path, workspace)
-    profiles_dir = team_dir / "profiles"
-    for agent in spec.get("agents", []):
-        if isinstance(agent, dict) and agent.get("profile"):
-            agent["_profile_dir"] = str(profiles_dir)

package/src/team_agent/launch/config.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-import os
-import re
-import subprocess
-from typing import Any
-
-
-DANGEROUS_LEADER_FLAGS = (
-    ("claude", "--dangerously-skip-permissions"),
-    ("claude", "--dangerously-skip-permission"),
-    ("codex", "--dangerously-bypass-approvals-and-sandbox"),
-)
-
-
-def effective_runtime_config(runtime_cfg: dict[str, Any]) -> dict[str, Any]:
-    # Route via the runtime alias surface so tests patching
-    # team_agent.runtime._detect_inherited_dangerous_permissions still take effect.
-    from team_agent.runtime import _detect_inherited_dangerous_permissions
-    effective = dict(runtime_cfg)
-    if effective.get("dangerous_auto_approve"):
-        effective["dangerous_auto_approve_source"] = "runtime_config"
-        effective["dangerous_auto_approve_inherited"] = False
-        return effective
-    inherited = _detect_inherited_dangerous_permissions()
-    if not inherited.get("enabled"):
-        effective["dangerous_auto_approve"] = False
-        effective["dangerous_auto_approve_source"] = "disabled"
-        effective["dangerous_auto_approve_inherited"] = False
-        return effective
-    effective["dangerous_auto_approve"] = True
-    effective["dangerous_auto_approve_source"] = "leader_process"
-    effective["dangerous_auto_approve_inherited"] = True
-    effective["dangerous_auto_approve_provider"] = inherited.get("provider")
-    effective["dangerous_auto_approve_flag"] = inherited.get("flag")
-    return effective
-
-
-def requires_direct_leader_receiver(spec: dict[str, Any], runtime_cfg: dict[str, Any]) -> bool:
-    if runtime_cfg.get("require_leader_receiver") is not None:
-        return bool(runtime_cfg.get("require_leader_receiver"))
-    return any(agent.get("provider") != "fake" for agent in spec.get("agents", []))
-
-
-def detect_inherited_dangerous_permissions() -> dict[str, Any]:
-    # Route via runtime alias so existing patches of
-    # team_agent.runtime._process_ancestry take effect at call time.
-    from team_agent.runtime import _process_ancestry
-    for proc in _process_ancestry(os.getpid()):
-        command = str(proc.get("command") or "")
-        for provider, flag in DANGEROUS_LEADER_FLAGS:
-            if command_has_flag(command, flag):
-                return {
-                    "enabled": True,
-                    "provider": provider,
-                    "flag": flag,
-                    "pid": proc.get("pid"),
-                }
-    return {"enabled": False}
-
-
-def command_has_flag(command: str, flag: str) -> bool:
-    return re.search(rf"(?<!\S){re.escape(flag)}(?!\S)", command) is not None
-
-
-def process_ancestry(pid: int, max_depth: int = 12) -> list[dict[str, Any]]:
-    ancestry: list[dict[str, Any]] = []
-    current = pid
-    seen: set[int] = set()
-    for _ in range(max_depth):
-        if current in seen or current <= 0:
-            break
-        seen.add(current)
-        info = process_info(current)
-        if not info:
-            break
-        ancestry.append(info)
-        parent = info.get("ppid")
-        if not isinstance(parent, int) or parent <= 1 or parent == current:
-            break
-        current = parent
-    return ancestry
-
-
-def process_info(pid: int) -> dict[str, Any] | None:
-    try:
-        proc = subprocess.run(
-            ["ps", "-p", str(pid), "-o", "ppid=", "-o", "command="],
-            text=True,
-            capture_output=True,
-            timeout=2,
-            check=False,
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-    if proc.returncode != 0:
-        return None
-    line = proc.stdout.strip()
-    if not line:
-        return None
-    parts = line.split(None, 1)
-    try:
-        ppid = int(parts[0])
-    except (IndexError, ValueError):
-        return None
-    return {"pid": pid, "ppid": ppid, "command": parts[1] if len(parts) > 1 else ""}