@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/status/approvals.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from team_agent.state import load_runtime_state
-from team_agent.status.constants import APPROVAL_SCAN_LINES
-
-
-def approvals(workspace: Path, agent_id: str | None = None) -> dict[str, Any]:
-    from team_agent.runtime import RuntimeError, _extract_approval_prompt, _tmux_window_exists, run_cmd
-    state = load_runtime_state(workspace)
-    session_name = state.get("session_name")
-    approvals_found: list[dict[str, Any]] = []
-    agents = state.get("agents", {})
-    target_ids = [agent_id] if agent_id else sorted(agents)
-    for target_id in target_ids:
-        agent = agents.get(target_id)
-        if not agent:
-            raise RuntimeError(f"unknown agent id: {target_id}")
-        window = agent.get("window", target_id)
-        if not session_name or not _tmux_window_exists(session_name, window):
-            continue
-        proc = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{APPROVAL_SCAN_LINES}", "-t", f"{session_name}:{window}"], timeout=5)
-        if proc.returncode != 0:
-            continue
-        prompt = _extract_approval_prompt(target_id, proc.stdout)
-        if prompt:
-            approvals_found.append(prompt)
-    return {
-        "ok": True,
-        "waiting": bool(approvals_found),
-        "waiting_count": len(approvals_found),
-        "approvals": approvals_found,
-        "scan": {"mode": "tail", "lines": APPROVAL_SCAN_LINES, "raw_output": False},
-    }
-
-
-def format_approvals(workspace: Path, agent_id: str | None = None) -> str:
-    result = approvals(workspace, agent_id=agent_id)
-    if not result["approvals"]:
-        return "No pending approvals."
-    lines: list[str] = []
-    for item in result["approvals"]:
-        detail = item.get("tool") or item.get("command") or item.get("kind")
-        lines.append(f"{item['agent_id']}: {item['state']} {item['kind']} {detail}".rstrip())
-        if item.get("prompt"):
-            lines.append(f"  prompt: {item['prompt']}")
-        if item.get("choices"):
-            lines.append("  choices: " + "; ".join(item["choices"]))
-        lines.append("  raw terminal output omitted; use debug-only peek with --search/--tail/--head if the user explicitly asks.")
-    return "\n".join(lines)

package/src/team_agent/status/compact.py

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from team_agent.status.constants import STATUS_EVENT_LIMIT, STATUS_TEXT_LIMIT
-
-
-def compact_status(data: dict[str, Any]) -> dict[str, Any]:
-    return {
-        "team": data.get("team"),
-        "session_name": data.get("session_name"),
-        "tmux_session_present": data.get("tmux_session_present"),
-        "leader_receiver": compact_mapping(
-            data.get("leader_receiver", {}),
-            {
-                "status",
-                "provider",
-                "mode",
-                "session_name",
-                "window_name",
-                "pane_id",
-                "pane_current_command",
-            },
-        ),
-        "agents": {
-            agent_id: compact_agent_state(agent_id, agent)
-            for agent_id, agent in (data.get("agents") or {}).items()
-        },
-        "agent_health": data.get("agent_health", {}),
-        "tasks": [compact_task(task) for task in data.get("tasks", [])],
-        "messages": data.get("messages", {}),
-        "queued_messages": data.get("queued_messages", [])[:8],
-        "results": data.get("results", {}),
-        "latest_results": data.get("latest_results", [])[:5],
-        "coordinator": compact_mapping(data.get("coordinator", {}), {"status", "pid", "metadata_ok", "schema_ok"}),
-        "last_events": [compact_event(event) for event in data.get("last_events", [])[-STATUS_EVENT_LIMIT:]],
-    }
-
-
-def compact_agent_state(agent_id: str, agent: dict[str, Any]) -> dict[str, Any]:
-    display = agent.get("display") or {}
-    result = compact_mapping(
-        agent,
-        {
-            "agent_id",
-            "status",
-            "provider",
-            "model",
-            "tmux_window_present",
-            "session_id",
-            "captured_via",
-            "attribution_confidence",
-        },
-    )
-    result.setdefault("agent_id", agent_id)
-    if display:
-        result["display"] = compact_mapping(
-            display,
-            {
-                "backend",
-                "status",
-                "workspace_window",
-                "pane_id",
-                "pid",
-                "pids",
-                "reason",
-            },
-        )
-    return result
-
-
-def compact_task(task: dict[str, Any]) -> dict[str, Any]:
-    return compact_mapping(
-        task,
-        {
-            "id",
-            "title",
-            "status",
-            "assignee",
-            "type",
-            "risk",
-            "accepted_result_id",
-            "last_result_summary",
-        },
-    )
-
-
-def compact_event(event: dict[str, Any]) -> dict[str, Any]:
-    skipped = {"command", "payload", "launch_args", "content", "prompt", "developer_instructions"}
-    kept = {
-        "event",
-        "ts",
-        "agent_id",
-        "task_id",
-        "message_id",
-        "result_id",
-        "status",
-        "ok",
-        "reason",
-        "error",
-        "session",
-        "window",
-        "target",
-        "backend",
-        "workspace_window",
-        "pane_id",
-        "restart_mode",
-        "provider",
-        "delivery_status",
-        "warning",
-        "collected",
-        "notified",
-        "lock",
-        "waited_sec",
-        "once",
-        "pid",
-    }
-    result: dict[str, Any] = {}
-    for key, value in event.items():
-        if key in skipped or key not in kept | {"agents", "coordinator"}:
-            continue
-        if key == "agents" and isinstance(value, list):
-            result["agent_count"] = len(value)
-            result["agents"] = [
-                compact_mapping(item, {"agent_id", "restart_mode", "session_id"})
-                for item in value[:8]
-                if isinstance(item, dict)
-            ]
-            continue
-        result[key] = compact_value(value)
-    return result
-
-
-def compact_mapping(source: Any, keys: set[str]) -> dict[str, Any]:
-    if not isinstance(source, dict):
-        return {}
-    return {key: compact_value(source[key]) for key in keys if key in source}
-
-
-def compact_value(value: Any) -> Any:
-    if isinstance(value, str):
-        return value if len(value) <= STATUS_TEXT_LIMIT else value[: STATUS_TEXT_LIMIT - 1] + "…"
-    if isinstance(value, (int, float, bool)) or value is None:
-        return value
-    if isinstance(value, list):
-        if all(isinstance(item, (str, int, float, bool)) or item is None for item in value):
-            compact = [compact_value(item) for item in value[:8]]
-            if len(value) > 8:
-                compact.append(f"... {len(value) - 8} more")
-            return compact
-        return f"{len(value)} item(s)"
-    if isinstance(value, dict):
-        return {
-            key: compact_value(item)
-            for key, item in value.items()
-            if key not in {"command", "payload", "launch_args", "content", "prompt", "developer_instructions"}
-        }
-    return str(value)

package/src/team_agent/status/constants.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-
-STATUS_TEXT_LIMIT = 240
-STATUS_EVENT_LIMIT = 3
-PEEK_MAX_LINES = 80
-PEEK_SEARCH_SCAN_LINES = 300
-PEEK_MAX_MATCHES = 5
-APPROVAL_SCAN_LINES = 120
-
-PENDING_DELIVERY_STATUSES = {
-    "pending",
-    "accepted",
-    "queued_until_idle",
-    "queued_until_start",
-    "queued_stopped",
-    "queued_pane_missing",
-}

package/src/team_agent/status/inbox.py

@@ -1,58 +0,0 @@
-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 _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)
-    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, 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']}"
-        for row in rows
-    ]
-    lines.append(note)
-    return "\n".join(lines)

package/src/team_agent/status/peek.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from team_agent.state import load_runtime_state
-from team_agent.status.constants import (
-    PEEK_MAX_LINES,
-    PEEK_MAX_MATCHES,
-    PEEK_SEARCH_SCAN_LINES,
-)
-
-
-def peek(
-    workspace: Path,
-    agent_id: str,
-    *,
-    head: int | None = None,
-    tail: int | None = None,
-    search: str | None = None,
-    context: int = 3,
-) -> dict[str, Any]:
-    from team_agent.runtime import RuntimeError, _tmux_window_exists, run_cmd
-    modes = [head is not None, tail is not None, search is not None]
-    if sum(modes) != 1:
-        raise RuntimeError("peek requires exactly one of --head, --tail, or --search")
-    if head is not None:
-        validate_line_count("--head", head)
-    if tail is not None:
-        validate_line_count("--tail", tail)
-    if search is not None and not search.strip():
-        raise RuntimeError("--search must not be empty")
-    if context < 0 or context > 10:
-        raise RuntimeError("--context must be between 0 and 10")
-    state = load_runtime_state(workspace)
-    agent = state.get("agents", {}).get(agent_id)
-    if not agent:
-        raise RuntimeError(f"unknown agent id: {agent_id}")
-    session_name = state.get("session_name")
-    window = agent.get("window", agent_id)
-    if not session_name or not _tmux_window_exists(session_name, window):
-        raise RuntimeError(f"agent terminal is not available: {agent_id}")
-    scan_lines = tail or PEEK_SEARCH_SCAN_LINES
-    proc = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{scan_lines}", "-t", f"{session_name}:{window}"], timeout=5)
-    if proc.returncode != 0:
-        raise RuntimeError(proc.stderr.strip() or f"capture failed for {agent_id}")
-    captured = proc.stdout.splitlines()
-    if head is not None:
-        selected = captured[:head]
-        return {
-            "ok": True,
-            "agent_id": agent_id,
-            "mode": "head",
-            "lines": head,
-            "scanned_lines": scan_lines,
-            "text": "\n".join(selected),
-        }
-    if tail is not None:
-        return {
-            "ok": True,
-            "agent_id": agent_id,
-            "mode": "tail",
-            "lines": tail,
-            "scanned_lines": scan_lines,
-            "text": "\n".join(captured[-tail:]),
-        }
-    assert search is not None
-    matches = search_lines(captured, search, context)
-    return {
-        "ok": True,
-        "agent_id": agent_id,
-        "mode": "search",
-        "search": search,
-        "context": context,
-        "scanned_lines": scan_lines,
-        "matches": matches,
-        "truncated": len(matches) >= PEEK_MAX_MATCHES,
-        "text": format_search_matches(matches),
-    }
-
-
-def validate_line_count(flag: str, value: int) -> None:
-    from team_agent.runtime import RuntimeError
-    if value < 1 or value > PEEK_MAX_LINES:
-        raise RuntimeError(f"{flag} must be between 1 and {PEEK_MAX_LINES}")
-
-
-def search_lines(lines: list[str], needle: str, context: int) -> list[dict[str, Any]]:
-    needle_lower = needle.lower()
-    matches: list[dict[str, Any]] = []
-    used_ranges: list[tuple[int, int]] = []
-    for index, line in enumerate(lines):
-        if needle_lower not in line.lower():
-            continue
-        start = max(0, index - context)
-        end = min(len(lines), index + context + 1)
-        if used_ranges and start <= used_ranges[-1][1]:
-            previous = matches[-1]
-            previous["lines"] = lines[previous["start_line"] - 1 : end]
-            previous["end_line"] = end
-            used_ranges[-1] = (previous["start_line"] - 1, end)
-        else:
-            matches.append({"line": index + 1, "start_line": start + 1, "end_line": end, "lines": lines[start:end]})
-            used_ranges.append((start, end))
-        if len(matches) >= PEEK_MAX_MATCHES:
-            break
-    return matches
-
-
-def format_search_matches(matches: list[dict[str, Any]]) -> str:
-    if not matches:
-        return "no matches"
-    blocks: list[str] = []
-    for match in matches:
-        blocks.append(f"match line {match['line']} ({match['start_line']}-{match['end_line']}):")
-        blocks.extend(str(line) for line in match["lines"])
-    return "\n".join(blocks)

package/src/team_agent/status/queries.py

@@ -1,199 +0,0 @@
-from __future__ import annotations
-
-import json
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.message_store import MessageStore
-from team_agent.state import load_runtime_state, save_runtime_state
-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,
-        _handle_provider_startup_prompts,
-        _refresh_agent_runtime_statuses,
-        _sync_agent_health,
-        _tmux_session_exists,
-        coordinator_health,
-    )
-    _ = as_json
-    state = load_runtime_state(workspace)
-    store = MessageStore(workspace)
-    event_log = EventLog(workspace)
-    _capture_missing_sessions(workspace, state, event_log, timeout_s=0.0, log_miss=False)
-    _refresh_agent_runtime_statuses(workspace, state, event_log)
-    _handle_provider_startup_prompts(workspace, state, event_log)
-    _sync_agent_health(workspace, state, store)
-    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": enriched_agents,
-        "agent_health": store.agent_health(),
-        "tasks": state.get("tasks", []),
-        "messages": store.message_counts(),
-        "queued_messages": queued_message_statuses(store.messages()),
-        "results": store.result_counts(),
-        "latest_results": latest_result_summaries(store),
-        "coordinator": coordinator_health(workspace),
-        "last_events": EventLog(workspace).tail(10),
-    }
-    return compact_status(result) if compact else result
-
-
-def latest_result_summaries(store: MessageStore, limit: int = 5) -> list[dict[str, Any]]:
-    summaries: list[dict[str, Any]] = []
-    for row in store.latest_results(limit=limit):
-        summary = result_summary_from_row(row)
-        if summary:
-            summaries.append(summary)
-    return summaries
-
-
-def result_summary_from_row(row: dict[str, Any]) -> dict[str, Any] | None:
-    try:
-        envelope = json.loads(row["envelope"]) if isinstance(row.get("envelope"), str) else row.get("envelope")
-    except (TypeError, json.JSONDecodeError):
-        return None
-    if not isinstance(envelope, dict):
-        return None
-    return {
-        "result_id": row.get("result_id"),
-        "task_id": envelope.get("task_id") or row.get("task_id"),
-        "agent_id": envelope.get("agent_id") or row.get("agent_id"),
-        "status": envelope.get("status") or row.get("status"),
-        "summary": envelope.get("summary"),
-        "created_at": row.get("created_at"),
-    }
-
-
-def queued_message_statuses(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    from team_agent.runtime import _age_text
-    visible_statuses = PENDING_DELIVERY_STATUSES | {"target_resolved", "delivery_blocked", "injected_unverified"}
-    queued: list[dict[str, Any]] = []
-    for row in messages:
-        if row.get("status") not in visible_statuses:
-            continue
-        queued.append(
-            {
-                "message_id": row.get("message_id"),
-                "recipient": row.get("recipient"),
-                "sender": row.get("sender"),
-                "status": row.get("status"),
-                "reason": row.get("error"),
-                "age": _age_text(row.get("created_at")),
-                "attempts": row.get("delivery_attempts") or 0,
-            }
-        )
-    return queued
-
-
-def format_status(workspace: Path, agent_id: str | None = None) -> str:
-    from team_agent.runtime import RuntimeError, _agent_health_status, _age_text, _current_task_for_agent
-    data = status(workspace, as_json=True)
-    health = data.get("agent_health", {})
-    tasks = data.get("tasks", [])
-    if agent_id:
-        if agent_id not in data.get("agents", {}) and agent_id not in health:
-            raise RuntimeError(f"unknown agent id: {agent_id}")
-        agent = data.get("agents", {}).get(agent_id, {})
-        row = health.get(agent_id, {})
-        task_id = _current_task_for_agent(tasks, agent_id) or "-"
-        inbox_rows = MessageStore(workspace).inbox(agent_id, limit=3)
-        lines = [
-            f"{agent_id}  {row.get('status', _agent_health_status(agent))}",
-            f"  provider: {agent.get('provider', '-')}",
-            f"  model: {agent.get('model', '-')}",
-            f"  profile: {agent.get('profile', '-')}",
-            f"  session_id: {agent.get('session_id') or '-'}",
-            f"  captured_via: {agent.get('captured_via') or '-'}",
-            f"  attribution_confidence: {agent.get('attribution_confidence') or '-'}",
-            f"  task: {task_id}",
-            f"  handoff: {agent.get('handoff_path', '-')}",
-            "  recent messages:",
-        ]
-        if inbox_rows:
-            for item in inbox_rows:
-                lines.append(
-                    f"    {item['created_at']} {item['sender']} -> {item['recipient']} "
-                    f"{item['status']}: {item['content'][:120]}"
-                )
-        else:
-            lines.append("    none")
-        return "\n".join(lines)
-
-    agents = data.get("agents", {})
-    state_name = "up" if data.get("tmux_session_present") else "down"
-    results = data.get("results", {})
-    lines = [
-        f"team {data.get('session_name') or '-'} ({state_name})",
-        (
-            "results "
-            f"total {results.get('total', 0)} "
-            f"uncollected {results.get('uncollected', 0)} "
-            f"collected {results.get('collected', 0)} "
-            f"invalid {results.get('invalid', 0)}"
-        ),
-    ]
-    if results.get("uncollected", 0):
-        lines.append("  final result pending in result store; run team-agent collect")
-    queued_messages = data.get("queued_messages") or []
-    if queued_messages:
-        lines.append("queued messages")
-        for item in queued_messages[:8]:
-            reason = item.get("reason") or "-"
-            lines.append(
-                f"  {item.get('message_id')} -> {item.get('recipient')} "
-                f"{item.get('status')} age {item.get('age')} attempts {item.get('attempts')} reason {reason}"
-            )
-    for aid in sorted(agents):
-        agent = agents[aid]
-        row = health.get(aid, {})
-        status_value = row.get("status") or _agent_health_status(agent)
-        task_id = _current_task_for_agent(tasks, aid) or "-"
-        context = row.get("context_usage_pct")
-        context_text = f"ctx {context}%" if context is not None else "ctx -"
-        last = _age_text(row.get("last_output_at"))
-        session_text = f"sid {agent.get('session_id') or '-'}"
-        capture_text = f"via {agent.get('captured_via') or '-'} {agent.get('attribution_confidence') or '-'}"
-        lines.append(f"  {aid}  {status_value}  {task_id}  {context_text}  last {last}  {session_text}  {capture_text}")
-    return "\n".join(lines)

package/src/team_agent/task_graph.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-TASK_STATUSES = {
-    "pending",
-    "ready",
-    "running",
-    "blocked",
-    "needs_retry",
-    "done",
-    "failed",
-    "cancelled",
-}
-
-TERMINAL_TASK_STATUSES = {"done", "failed", "cancelled"}
-
-
-def find_dependency_cycle(tasks: list[dict[str, Any]]) -> list[str]:
-    graph = {t.get("id"): list(t.get("deps", [])) for t in tasks if t.get("id")}
-    visiting: set[str] = set()
-    visited: set[str] = set()
-    stack: list[str] = []
-
-    def visit(node: str) -> list[str] | None:
-        if node in visited:
-            return None
-        if node in visiting:
-            if node in stack:
-                return stack[stack.index(node) :] + [node]
-            return [node, node]
-        visiting.add(node)
-        stack.append(node)
-        for dep in graph.get(node, []):
-            if dep in graph:
-                cycle = visit(dep)
-                if cycle:
-                    return cycle
-        stack.pop()
-        visiting.remove(node)
-        visited.add(node)
-        return None
-
-    for node in graph:
-        cycle = visit(node)
-        if cycle:
-            return cycle
-    return []
-
-
-def ready_tasks(tasks: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    by_id = {t["id"]: t for t in tasks}
-    ready: list[dict[str, Any]] = []
-    for task in tasks:
-        if task.get("status", "pending") not in {"pending", "ready", "needs_retry"}:
-            continue
-        deps_done = all(by_id.get(dep, {}).get("status") == "done" for dep in task.get("deps", []))
-        if deps_done:
-            ready.append(task)
-    return ready
-
-
-def update_task_status(
-    tasks: list[dict[str, Any]],
-    task_id: str,
-    status: str,
-    summary: str | None = None,
-    artifact_refs: list[dict[str, Any]] | None = None,
-) -> None:
-    if status not in TASK_STATUSES:
-        raise ValueError(f"Unknown task status: {status}")
-    for task in tasks:
-        if task.get("id") == task_id:
-            task["status"] = status
-            if summary is not None:
-                task["last_result_summary"] = summary
-            if artifact_refs is not None:
-                task["artifact_refs"] = artifact_refs
-            return
-    raise KeyError(f"Unknown task id: {task_id}")