@team-agent/installer 0.1.11 → 0.2.0

package/crates/team-agent-core/src/lib.rs

@@ -215,15 +215,54 @@ pub fn validate_profile(profile: &Profile) -> Result<(), Vec<String>> {
 }
 
 pub fn contains_inline_secret(value: &str) -> bool {
-    let lower = value.to_ascii_lowercase();
-    lower.contains("api_key")
-        || lower.contains("apikey")
-        || lower.contains("token")
-        || lower.contains("secret")
+    contains_secret_assignment(value)
+        || contains_bearer_secret(value)
+        || value
+            .split_whitespace()
+            .any(|chunk| chunk.starts_with("sk-") || looks_base64_secret(chunk))
         || value.starts_with("sk-")
         || looks_base64_secret(value)
 }
 
+fn contains_secret_assignment(value: &str) -> bool {
+    for line in value.lines() {
+        for separator in ['=', ':'] {
+            let Some((key, raw)) = line.split_once(separator) else {
+                continue;
+            };
+            let normalized: String = key
+                .to_ascii_lowercase()
+                .chars()
+                .filter(|ch| ch.is_ascii_alphanumeric())
+                .collect();
+            if !matches!(
+                normalized.as_str(),
+                "apikey" | "token" | "secret" | "password" | "credential"
+            ) {
+                continue;
+            }
+            let candidate = raw.trim().trim_matches(|ch| ch == '"' || ch == '\'');
+            if candidate.starts_with("sk-") || candidate.len() >= 8 || looks_base64_secret(candidate) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn contains_bearer_secret(value: &str) -> bool {
+    let mut previous_was_bearer = false;
+    for chunk in value.split_whitespace() {
+        if previous_was_bearer && chunk.len() >= 16 && chunk.chars().all(|ch| {
+            ch.is_ascii_alphanumeric() || matches!(ch, '.' | '_' | '~' | '+' | '/' | '=' | '-')
+        }) {
+            return true;
+        }
+        previous_was_bearer = chunk.eq_ignore_ascii_case("bearer");
+    }
+    false
+}
+
 pub fn json_escape(input: &str) -> String {
     let mut out = String::new();
     for ch in input.chars() {
@@ -273,6 +312,12 @@ mod tests {
         assert!(!redacted.contains("sk-test"));
     }
 
+    #[test]
+    fn inline_secret_scan_allows_ordinary_token_prose() {
+        assert!(!contains_inline_secret("Use the visible token in logs for delivery evidence."));
+        assert!(contains_inline_secret("API_KEY=sk-inline-secret"));
+    }
+
     #[test]
     fn profile_rejects_inline_secret() {
         let profile = Profile {

package/package.json

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

package/schemas/team.schema.json

@@ -134,6 +134,7 @@
         "auth_mode": { "enum": ["subscription", "official_api", "compatible_api"] },
         "profile": { "type": "string", "minLength": 1 },
         "credential_ref": { "type": "string", "minLength": 1 },
+        "forked_from": { "type": "string", "minLength": 1 },
         "working_directory": { "type": "string", "minLength": 1 },
         "paused": { "type": "boolean" },
         "system_prompt": {

package/src/team_agent/approvals/__init__.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from team_agent.approvals.constants import (
+    INTERNAL_MCP_APPROVAL_CHOICE,
+    INTERNAL_MCP_AUTO_APPROVE_TOOLS,
+    STARTUP_PROMPT_RUNTIME_CHECK_LIMIT,
+)
+from team_agent.approvals.parsing import (
+    APPROVAL_CHOICE_RE,
+    active_approval_choice_index,
+    active_approval_control_index,
+    approval_choice_keys,
+    approval_prompt_fingerprint,
+    capture_has_approval_prompt,
+    capture_has_team_orchestrator_mcp_prompt,
+    choose_internal_mcp_approval_choice,
+    extract_approval_choices,
+    extract_approval_prompt,
+    extract_command_approval_subject,
+    is_approval_control_line,
+    line_is_approval_choice,
+)
+from team_agent.approvals.runtime_prompts import (
+    handle_internal_mcp_approval_prompt,
+    handle_provider_runtime_prompts,
+    handle_provider_startup_prompts,
+    submit_internal_mcp_approval,
+)
+from team_agent.approvals.status import (
+    age_text,
+    agent_health_status,
+    current_task_for_agent,
+    detect_provider_status,
+    refresh_agent_runtime_statuses,
+    sync_agent_health,
+)
+
+__all__ = [
+    "APPROVAL_CHOICE_RE",
+    "INTERNAL_MCP_APPROVAL_CHOICE",
+    "INTERNAL_MCP_AUTO_APPROVE_TOOLS",
+    "STARTUP_PROMPT_RUNTIME_CHECK_LIMIT",
+    "active_approval_choice_index",
+    "active_approval_control_index",
+    "age_text",
+    "agent_health_status",
+    "approval_choice_keys",
+    "approval_prompt_fingerprint",
+    "capture_has_approval_prompt",
+    "capture_has_team_orchestrator_mcp_prompt",
+    "choose_internal_mcp_approval_choice",
+    "current_task_for_agent",
+    "detect_provider_status",
+    "extract_approval_choices",
+    "extract_approval_prompt",
+    "extract_command_approval_subject",
+    "handle_internal_mcp_approval_prompt",
+    "handle_provider_runtime_prompts",
+    "handle_provider_startup_prompts",
+    "is_approval_control_line",
+    "line_is_approval_choice",
+    "refresh_agent_runtime_statuses",
+    "submit_internal_mcp_approval",
+    "sync_agent_health",
+]

package/src/team_agent/approvals/constants.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+
+STARTUP_PROMPT_RUNTIME_CHECK_LIMIT = 3
+INTERNAL_MCP_AUTO_APPROVE_TOOLS = {"send_message", "report_result", "get_team_status", "request_human"}
+INTERNAL_MCP_APPROVAL_CHOICE = "Allow for this session"

package/src/team_agent/approvals/parsing.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+
+from team_agent.approvals.constants import INTERNAL_MCP_APPROVAL_CHOICE
+
+
+APPROVAL_CHOICE_RE = re.compile(r"(?:[›❯>]\s*)?(\d+)\.\s+(.+?)(?:\s{2,}.+)?$")
+
+
+def capture_has_approval_prompt(text: str) -> bool:
+    return extract_approval_prompt("_", text) is not None
+
+
+def extract_approval_prompt(agent_id: str, text: str) -> dict[str, Any] | None:
+    lines = text.splitlines()
+    control_index = active_approval_control_index(lines)
+    if control_index is None:
+        return None
+    for index in range(control_index, -1, -1):
+        line = lines[index]
+        if "Allow the team_orchestrator MCP server to run tool" not in line:
+            continue
+        tool_match = re.search(r'run tool "([^"]+)"', line)
+        return {
+            "agent_id": agent_id,
+            "state": "waiting_approval",
+            "kind": "mcp_tool",
+            "tool": tool_match.group(1) if tool_match else None,
+            "prompt": line.strip(),
+            "choices": extract_approval_choices(lines[index : control_index + 1]),
+        }
+    for index in range(control_index, -1, -1):
+        line = lines[index]
+        if line_is_approval_choice(line):
+            continue
+        tool_match = re.search(r"\bteam_orchestrator\s*[-.]\s*([A-Za-z_][A-Za-z0-9_]*)\b", line)
+        if not tool_match:
+            continue
+        return {
+            "agent_id": agent_id,
+            "state": "waiting_approval",
+            "kind": "mcp_tool",
+            "tool": tool_match.group(1),
+            "prompt": f"team_orchestrator - {tool_match.group(1)}",
+            "choices": extract_approval_choices(lines[index : control_index + 1]),
+        }
+    for index in range(control_index, -1, -1):
+        line = lines[index]
+        if "Would you like to run the following command" not in line:
+            continue
+        return {
+            "agent_id": agent_id,
+            "state": "waiting_approval",
+            "kind": "command",
+            "command": extract_command_approval_subject(lines[: control_index + 1], index),
+            "prompt": line.strip(),
+            "choices": extract_approval_choices(lines[index : control_index + 1]),
+        }
+    return {
+        "agent_id": agent_id,
+        "state": "waiting_approval",
+        "kind": "unknown",
+        "prompt": "approval prompt detected",
+        "choices": extract_approval_choices(lines[: control_index + 1]),
+    }
+
+
+def active_approval_control_index(lines: list[str]) -> int | None:
+    control_indices = [
+        index
+        for index, line in enumerate(lines)
+        if is_approval_control_line(line)
+    ]
+    if not control_indices:
+        return None
+    control_index = control_indices[-1]
+    if any(line.strip() for line in lines[control_index + 1 :]):
+        return None
+    return control_index
+
+
+def is_approval_control_line(line: str) -> bool:
+    normalized = line.lower()
+    return "enter to submit | esc to cancel" in normalized or ("esc to cancel" in normalized and "tab to amend" in normalized)
+
+
+def extract_approval_choices(lines: list[str]) -> list[str]:
+    choices: list[str] = []
+    for line in lines:
+        stripped = line.strip()
+        match = APPROVAL_CHOICE_RE.match(stripped)
+        if not match:
+            continue
+        label = match.group(2).strip()
+        if label and label not in choices:
+            choices.append(label)
+    return choices
+
+
+def line_is_approval_choice(line: str) -> bool:
+    return APPROVAL_CHOICE_RE.match(line.strip()) is not None
+
+
+def extract_command_approval_subject(lines: list[str], prompt_index: int) -> str | None:
+    for line in reversed(lines[:prompt_index]):
+        stripped = line.strip()
+        if stripped.startswith("Bash(") or stripped.startswith("Shell("):
+            return stripped[:200]
+    for line in lines[prompt_index + 1 : prompt_index + 8]:
+        stripped = line.strip()
+        if stripped.startswith("Bash(") or stripped.startswith("Shell("):
+            return stripped[:200]
+    return None
+
+
+def active_approval_choice_index(text: str) -> int | None:
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not (stripped.startswith("›") or stripped.startswith("❯") or stripped.startswith(">")):
+            continue
+        match = re.match(r"[›❯>]\s*(\d+)\.", stripped)
+        if match:
+            return int(match.group(1)) - 1
+    return None
+
+
+def capture_has_team_orchestrator_mcp_prompt(text: str) -> bool:
+    return (
+        "Allow the team_orchestrator MCP server to run tool" in text
+        or re.search(r"\bteam_orchestrator\s*[-.]\s*[A-Za-z_][A-Za-z0-9_]*\b", text) is not None
+    )
+
+
+def approval_prompt_fingerprint(prompt: dict[str, Any]) -> str:
+    data = {
+        "kind": prompt.get("kind"),
+        "tool": prompt.get("tool"),
+        "prompt": prompt.get("prompt"),
+        "choices": prompt.get("choices") or [],
+    }
+    return hashlib.sha256(json.dumps(data, sort_keys=True, ensure_ascii=False).encode("utf-8")).hexdigest()[:16]
+
+
+def choose_internal_mcp_approval_choice(prompt: dict[str, Any]) -> str:
+    choices = prompt.get("choices") or []
+    if INTERNAL_MCP_APPROVAL_CHOICE in choices:
+        return INTERNAL_MCP_APPROVAL_CHOICE
+    for choice in choices:
+        if str(choice).startswith("Yes, and don't ask again"):
+            return str(choice)
+    if "Allow" in choices:
+        return "Allow"
+    if "Yes" in choices:
+        return "Yes"
+    return INTERNAL_MCP_APPROVAL_CHOICE
+
+
+def approval_choice_keys(prompt: dict[str, Any], capture_text: str, choice: str) -> list[str]:
+    choices = prompt.get("choices") or []
+    try:
+        target_index = choices.index(choice)
+    except ValueError:
+        return ["Down", "Enter"]
+    active_index = active_approval_choice_index(capture_text)
+    if active_index is None:
+        return [str(target_index + 1), "Enter"]
+    delta = target_index - active_index
+    if delta > 0:
+        return ["Down"] * delta + ["Enter"]
+    if delta < 0:
+        return ["Up"] * abs(delta) + ["Enter"]
+    return ["Enter"]

package/src/team_agent/approvals/runtime_prompts.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from team_agent.approvals.constants import (
+    INTERNAL_MCP_AUTO_APPROVE_TOOLS,
+    STARTUP_PROMPT_RUNTIME_CHECK_LIMIT,
+)
+from team_agent.approvals.parsing import (
+    approval_choice_keys,
+    approval_prompt_fingerprint,
+    choose_internal_mcp_approval_choice,
+    extract_approval_prompt,
+)
+from team_agent.events import EventLog
+from team_agent.status import APPROVAL_SCAN_LINES
+
+
+def handle_provider_runtime_prompts(workspace: Path, state: dict[str, Any], event_log: EventLog) -> None:
+    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists, get_adapter
+    _ = workspace
+    session_name = state.get("session_name")
+    if not session_name or not _tmux_session_exists(session_name):
+        return
+    for agent_id, agent_state in state.get("agents", {}).items():
+        if agent_state.get("status") in {"paused", "stopped", "missing"}:
+            continue
+        window = agent_state.get("window", agent_id)
+        if not _tmux_window_exists(session_name, window):
+            continue
+        internal_mcp = handle_internal_mcp_approval_prompt(agent_id, session_name, window, event_log)
+        if internal_mcp is not None:
+            continue
+        adapter = get_adapter(agent_state["provider"])
+        for prompt_event in adapter.handle_runtime_prompts(session_name, window):
+            event_log.write(
+                "runtime.prompt_handled",
+                agent_id=agent_id,
+                provider=agent_state["provider"],
+                **prompt_event,
+            )
+
+
+def handle_provider_startup_prompts(workspace: Path, state: dict[str, Any], event_log: EventLog) -> None:
+    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists, get_adapter
+    _ = workspace
+    session_name = state.get("session_name")
+    if not session_name or not _tmux_session_exists(session_name):
+        return
+    for agent_id, agent_state in state.get("agents", {}).items():
+        if agent_state.get("status") in {"paused", "stopped", "missing"}:
+            continue
+        window = agent_state.get("window", agent_id)
+        if not _tmux_window_exists(session_name, window):
+            continue
+        spawned_at = str(agent_state.get("spawned_at") or "")
+        if agent_state.get("startup_prompt_check_spawned_at") != spawned_at:
+            agent_state["startup_prompt_check_spawned_at"] = spawned_at
+            agent_state["startup_prompt_check_count"] = 0
+        check_count = int(agent_state.get("startup_prompt_check_count") or 0)
+        if check_count >= STARTUP_PROMPT_RUNTIME_CHECK_LIMIT:
+            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):
+            event_log.write(
+                "runtime.startup_prompt_handled",
+                agent_id=agent_id,
+                provider=agent_state["provider"],
+                **prompt_event,
+            )
+
+
+def handle_internal_mcp_approval_prompt(
+    agent_id: str,
+    session_name: str,
+    window: str,
+    event_log: EventLog,
+) -> dict[str, Any] | None:
+    from team_agent.runtime import run_cmd
+    target = f"{session_name}:{window}"
+    proc = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{APPROVAL_SCAN_LINES}", "-t", target], timeout=5)
+    if proc.returncode != 0:
+        return None
+    prompt = extract_approval_prompt(agent_id, proc.stdout)
+    if not prompt or prompt.get("kind") != "mcp_tool":
+        return None
+    tool = str(prompt.get("tool") or "")
+    fingerprint = approval_prompt_fingerprint(prompt)
+    if tool not in INTERNAL_MCP_AUTO_APPROVE_TOOLS:
+        result = {
+            "ok": False,
+            "action": "skipped",
+            "reason": "tool_not_allowlisted",
+            "tool": tool,
+            "fingerprint": fingerprint,
+        }
+        event_log.write("runtime.internal_mcp_approval.skipped", agent_id=agent_id, **result)
+        return result
+    result = submit_internal_mcp_approval(agent_id, target, tool, prompt, proc.stdout)
+    event_log.write("runtime.internal_mcp_approval.auto", agent_id=agent_id, **result)
+    return result
+
+
+def submit_internal_mcp_approval(
+    agent_id: str,
+    target: str,
+    tool: str,
+    prompt: dict[str, Any],
+    capture_text: str,
+    attempts: int = 3,
+) -> dict[str, Any]:
+    from team_agent.runtime import run_cmd
+    choice = choose_internal_mcp_approval_choice(prompt)
+    fingerprint = approval_prompt_fingerprint(prompt)
+    attempt_log: list[dict[str, Any]] = []
+    current_prompt = prompt
+    current_capture = capture_text
+    for attempt in range(1, attempts + 1):
+        keys = approval_choice_keys(current_prompt, current_capture, choice)
+        proc = run_cmd(["tmux", "send-keys", "-t", target, *keys], timeout=10)
+        if proc.returncode != 0:
+            return {
+                "ok": False,
+                "action": "auto_approve",
+                "tool": tool,
+                "choice": choice,
+                "fingerprint": fingerprint,
+                "attempts": attempt_log + [{"attempt": attempt, "submitted": False, "error": proc.stderr.strip()}],
+                "verification": "send_keys_failed",
+            }
+        time.sleep(0.35)
+        verify = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{APPROVAL_SCAN_LINES}", "-t", target], timeout=5)
+        if verify.returncode != 0:
+            attempt_log.append({"attempt": attempt, "submitted": True, "keys": keys, "verification": "capture_failed"})
+            continue
+        after_prompt = extract_approval_prompt(agent_id, verify.stdout)
+        if not after_prompt:
+            return {
+                "ok": True,
+                "action": "auto_approved",
+                "tool": tool,
+                "choice": choice,
+                "fingerprint": fingerprint,
+                "attempts": attempt_log + [{"attempt": attempt, "submitted": True, "keys": keys, "verification": "prompt_absent"}],
+                "verification": "prompt_absent_after_submit",
+            }
+        if after_prompt.get("kind") != "mcp_tool" or after_prompt.get("tool") != tool:
+            return {
+                "ok": True,
+                "action": "auto_approved",
+                "tool": tool,
+                "choice": choice,
+                "fingerprint": fingerprint,
+                "attempts": attempt_log + [{"attempt": attempt, "submitted": True, "keys": keys, "verification": "different_prompt_present"}],
+                "verification": "original_prompt_replaced",
+            }
+        attempt_log.append({"attempt": attempt, "submitted": True, "keys": keys, "verification": "prompt_still_present"})
+        current_prompt = after_prompt
+        current_capture = verify.stdout
+    return {
+        "ok": False,
+        "action": "auto_approve",
+        "tool": tool,
+        "choice": choice,
+        "fingerprint": fingerprint,
+        "attempts": attempt_log,
+        "verification": "prompt_still_present_after_retries",
+    }

package/src/team_agent/approvals/status.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from team_agent.approvals.parsing import capture_has_approval_prompt
+from team_agent.events import EventLog
+from team_agent.message_store import MessageStore
+from team_agent.state import team_state_key
+
+
+def refresh_agent_runtime_statuses(workspace: Path, state: dict[str, Any], event_log: EventLog) -> None:
+    from team_agent.runtime import _tmux_session_exists, _tmux_window_exists
+    _ = workspace
+    session_name = state.get("session_name")
+    tmux_exists = _tmux_session_exists(session_name) if session_name else False
+    for agent_id, agent_state in state.get("agents", {}).items():
+        if agent_state.get("status") in {"paused", "stopped"}:
+            continue
+        old_status = agent_state.get("status")
+        window = agent_state.get("window", agent_id)
+        window_present = _tmux_window_exists(session_name, window) if tmux_exists else False
+        agent_state["tmux_window_present"] = window_present
+        if not window_present:
+            if session_name:
+                agent_state["status"] = "missing"
+        else:
+            detected = detect_provider_status(agent_state["provider"], session_name, window)
+            if detected:
+                agent_state["status"] = detected
+            else:
+                agent_state.setdefault("status", "running")
+        if old_status != agent_state.get("status"):
+            event_log.write(
+                "runtime.status_detected",
+                agent_id=agent_id,
+                provider=agent_state.get("provider"),
+                old_status=old_status,
+                status=agent_state.get("status"),
+            )
+
+
+def sync_agent_health(workspace: Path, state: dict[str, Any], store: MessageStore | None = None) -> dict[str, dict[str, Any]]:
+    from team_agent.runtime import _tmux_window_exists, _tmux_pane_info, run_cmd
+    from team_agent.messaging.activity_detector import classify_agent_activity
+    store = store or MessageStore(workspace)
+    session_name = state.get("session_name")
+    owner_team_id = team_state_key(state)
+    captures: dict[str, dict[str, Any]] = {}
+    for agent_id, agent_state in state.get("agents", {}).items():
+        health_status = agent_health_status(agent_state)
+        last_output_at = agent_state.get("last_output_at")
+        window = agent_state.get("window", agent_id)
+        scrollback = ""
+        pane_info: dict[str, Any] | None = None
+        if session_name and _tmux_window_exists(session_name, window):
+            proc = run_cmd(["tmux", "capture-pane", "-p", "-S", "-40", "-t", f"{session_name}:{window}"], timeout=5)
+            if proc.returncode == 0:
+                scrollback = proc.stdout
+                digest = hashlib.sha256(proc.stdout.encode("utf-8", errors="ignore")).hexdigest()
+                if digest != agent_state.get("last_output_hash"):
+                    last_output_at = datetime.now(timezone.utc).isoformat()
+                    agent_state["last_output_hash"] = digest
+                    agent_state["last_output_at"] = last_output_at
+                if capture_has_approval_prompt(proc.stdout):
+                    health_status = "AWAITING_APPROVAL"
+            try:
+                pane_info = _tmux_pane_info(f"{session_name}:{window}")
+            except Exception:
+                pane_info = None
+            if scrollback and health_status != "AWAITING_APPROVAL":
+                activity = classify_agent_activity(
+                    agent_id,
+                    agent_state.get("provider") or "",
+                    last_output_at,
+                    pane_info,
+                    scrollback,
+                )
+                agent_state["activity"] = {
+                    "status": activity.get("status"),
+                    "confidence": activity.get("confidence"),
+                    "rationale": activity.get("rationale"),
+                    "classified_at": datetime.now(timezone.utc).isoformat(),
+                }
+                if activity.get("confidence", 0) >= 0.85:
+                    raw = str(activity.get("status") or "")
+                    mapping = {"idle": "IDLE", "working": "WORKING", "stuck": "STUCK", "uncertain": "UNCERTAIN"}
+                    mapped = mapping.get(raw)
+                    if mapped:
+                        health_status = mapped
+        current_task = current_task_for_agent(state.get("tasks", []), agent_id)
+        store.upsert_agent_health(
+            agent_id,
+            health_status,
+            last_output_at=last_output_at,
+            context_usage_pct=agent_state.get("context_usage_pct"),
+            current_task_id=current_task,
+            owner_team_id=owner_team_id,
+        )
+        captures[agent_id] = {"scrollback": scrollback, "pane_info": pane_info, "health_status": health_status}
+    return captures
+
+
+def agent_health_status(agent_state: dict[str, Any]) -> str:
+    raw = str(agent_state.get("status") or "").lower()
+    if raw in {"busy", "running"}:
+        return "RUNNING" if raw == "busy" else "IDLE"
+    if raw in {"paused", "blocked"}:
+        return "BLOCKED"
+    if raw in {"error", "missing", "interrupted"}:
+        return "ERROR"
+    if raw in {"stopped", "done"}:
+        return "DONE"
+    return "IDLE"
+
+
+def current_task_for_agent(tasks: list[dict[str, Any]], agent_id: str) -> str | None:
+    active = {"pending", "ready", "running", "blocked", "needs_retry"}
+    for task in reversed(tasks):
+        if task.get("assignee") == agent_id and task.get("status", "pending") in active:
+            return task.get("id")
+    return None
+
+
+def age_text(iso_text: str | None) -> str:
+    if not iso_text:
+        return "-"
+    try:
+        dt = datetime.fromisoformat(iso_text)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        seconds = max(0, int((datetime.now(timezone.utc) - dt).total_seconds()))
+    except ValueError:
+        return "-"
+    if seconds < 60:
+        return f"{seconds}s ago"
+    minutes = seconds // 60
+    if minutes < 60:
+        return f"{minutes}m ago"
+    return f"{minutes // 60}h ago"
+
+
+def detect_provider_status(provider: str, session_name: str, window: str) -> str | None:
+    from team_agent.runtime import get_adapter, run_cmd
+    proc = run_cmd(["tmux", "capture-pane", "-p", "-t", f"{session_name}:{window}"], timeout=5)
+    if proc.returncode != 0:
+        return None
+    patterns = get_adapter(provider).status_patterns()
+    positions: dict[str, int] = {}
+    for status_name, pattern in patterns.items():
+        if not pattern:
+            continue
+        try:
+            matches = list(re.finditer(pattern, proc.stdout, re.MULTILINE))
+        except re.error:
+            continue
+        if matches:
+            positions[status_name] = matches[-1].start()
+    if not positions:
+        return None
+    latest = max(positions, key=positions.get)
+    return {"idle": "running", "processing": "busy", "error": "error"}.get(latest)