@team-agent/installer 0.1.11 → 0.2.1

package/src/team_agent/cli/__init__.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from team_agent.cli.parser import (
+    SEND_ORDER_HINT,
+    TeamAgentArgumentParser,
+    _run_leader_passthrough,
+    add_json,
+    main,
+)
+from team_agent.cli.helpers import (
+    _cli_error_payload,
+    _emit_cli_error,
+    _leader_launcher_args,
+    _provider_args,
+    _tmux_session_conflict_action,
+    _tmux_session_conflict_name,
+    _tmux_session_conflict_next_action,
+    _workspace_from_args,
+    emit,
+)
+from team_agent.cli.commands import (
+    cmd_quick_start,
+    cmd_codex,
+    cmd_claude,
+    cmd_init,
+    cmd_validate,
+    cmd_compile,
+    _profile_scope,
+    cmd_profile_init,
+    cmd_profile_doctor,
+    cmd_profile_show,
+    cmd_launch,
+    cmd_preflight,
+    cmd_start,
+    cmd_wait_ready,
+    cmd_settle,
+    cmd_status,
+    cmd_approvals,
+    cmd_peek,
+    cmd_inbox,
+    cmd_sessions,
+    cmd_attach_leader,
+    cmd_send,
+    cmd_collect,
+    cmd_diagnose,
+    cmd_repair_state,
+    cmd_validate_result,
+    cmd_doctor,
+    cmd_shutdown,
+    cmd_restart,
+    cmd_start_agent,
+    cmd_stop_agent,
+    cmd_reset_agent,
+    cmd_add_agent,
+    cmd_fork_agent,
+    cmd_remove_agent,
+    cmd_stuck_list,
+    cmd_stuck_cancel,
+    cmd_acknowledge_idle,
+    cmd_allow_peer_talk,
+    cmd_advanced,
+    cmd_install_skill,
+    _skill_dest_dir,
+    _install_skill_to,
+
+)
+from team_agent.cli.e2e import (
+    _fake_spec,
+    _run_fake_e2e,
+    _run_real_launch_smoke,
+    cmd_e2e,
+)
+
+__all__ = [
+    'SEND_ORDER_HINT',
+    'TeamAgentArgumentParser',
+    'main',
+    'add_json',
+    '_run_leader_passthrough',
+    'emit',
+    '_workspace_from_args',
+    '_emit_cli_error',
+    '_cli_error_payload',
+    '_tmux_session_conflict_name',
+    '_tmux_session_conflict_next_action',
+    '_tmux_session_conflict_action',
+    '_provider_args',
+    '_leader_launcher_args',
+    'cmd_quick_start',
+    'cmd_codex',
+    'cmd_claude',
+    'cmd_init',
+    'cmd_validate',
+    'cmd_compile',
+    '_profile_scope',
+    'cmd_profile_init',
+    'cmd_profile_doctor',
+    'cmd_profile_show',
+    'cmd_launch',
+    'cmd_preflight',
+    'cmd_start',
+    'cmd_wait_ready',
+    'cmd_settle',
+    'cmd_status',
+    'cmd_approvals',
+    'cmd_peek',
+    'cmd_inbox',
+    'cmd_sessions',
+    'cmd_attach_leader',
+    'cmd_send',
+    'cmd_collect',
+    'cmd_diagnose',
+    'cmd_repair_state',
+    'cmd_validate_result',
+    'cmd_doctor',
+    'cmd_shutdown',
+    'cmd_restart',
+    'cmd_start_agent',
+    'cmd_stop_agent',
+    'cmd_reset_agent',
+    'cmd_add_agent',
+    'cmd_fork_agent',
+    'cmd_remove_agent',
+    'cmd_stuck_list',
+    'cmd_stuck_cancel',
+    'cmd_acknowledge_idle',
+    'cmd_allow_peer_talk',
+    'cmd_advanced',
+    'cmd_install_skill',
+    '_skill_dest_dir',
+    '_install_skill_to',
+    'cmd_e2e',
+    '_run_fake_e2e',
+    '_run_real_launch_smoke',
+    '_fake_spec',
+
+]

package/src/team_agent/cli/commands.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+from team_agent import compiler, profiles, runtime
+from team_agent.errors import TeamAgentError
+from team_agent.paths import repo_root, team_workspace
+from team_agent.spec import validate_result_envelope
+
+from team_agent.cli.helpers import _provider_args
+
+
+def cmd_quick_start(args: argparse.Namespace) -> dict[str, Any]:
+    result = runtime.quick_start(Path(args.agents_dir), name=args.name, yes=args.yes, fresh=args.fresh, team_id=args.team_id)
+    if args.json or not result.get("ok"):
+        return result
+    return result["summary"]
+
+
+def cmd_codex(args: argparse.Namespace) -> None:
+    runtime.start_leader("codex", _provider_args(args.provider_args), Path.cwd().resolve())
+
+
+def cmd_claude(args: argparse.Namespace) -> None:
+    runtime.start_leader("claude_code", _provider_args(args.provider_args), Path.cwd().resolve())
+
+
+def cmd_init(args: argparse.Namespace) -> dict[str, Any]:
+    paths = runtime.init_workspace(Path(args.workspace).resolve(), force=args.force)
+    return {"ok": True, "spec": str(paths["spec"]), "state": str(paths["state"])}
+
+
+def cmd_validate(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.validate_file(Path(args.spec).resolve())
+
+
+def cmd_compile(args: argparse.Namespace) -> dict[str, Any]:
+    result = compiler.compile_team(Path(args.team).resolve(), Path(args.out).resolve())
+    return {"ok": True, "team_dir": result["team_dir"], "out": result["out"], "agents": [a["id"] for a in result["spec"]["agents"]]}
+
+
+def _profile_scope(args: argparse.Namespace) -> tuple[Path, Path | None]:
+    team = getattr(args, "team", None)
+    if team:
+        team_dir = Path(team).resolve()
+        return team_workspace(team_dir), team_dir / "profiles"
+    return Path(args.workspace).resolve(), None
+
+
+def cmd_profile_init(args: argparse.Namespace) -> dict[str, Any]:
+    workspace, profiles_dir = _profile_scope(args)
+    return profiles.init_profile(workspace, args.name, args.auth_mode, profiles_dir=profiles_dir)
+
+
+def cmd_profile_doctor(args: argparse.Namespace) -> dict[str, Any]:
+    workspace, profiles_dir = _profile_scope(args)
+    return profiles.doctor_profile(workspace, args.name, profiles_dir=profiles_dir)
+
+
+def cmd_profile_show(args: argparse.Namespace) -> dict[str, Any]:
+    workspace, profiles_dir = _profile_scope(args)
+    return profiles.show_profile(workspace, args.name, profiles_dir=profiles_dir)
+
+
+def cmd_launch(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.launch(Path(args.spec).resolve(), dry_run=args.dry_run, auto_approve=args.yes)
+
+
+def cmd_preflight(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.preflight(Path(args.team).resolve())
+
+
+def cmd_start(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.start(Path(args.team).resolve(), yes=args.yes)
+
+
+def cmd_wait_ready(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.wait_ready(Path(args.workspace).resolve(), timeout=args.timeout)
+
+
+def cmd_settle(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.settle(Path(args.workspace).resolve())
+
+
+def cmd_status(args: argparse.Namespace) -> dict[str, Any]:
+    if args.json:
+        return runtime.status(Path(args.workspace).resolve(), as_json=True, compact=not args.detail)
+    return runtime.format_status(Path(args.workspace).resolve(), args.agent)
+
+
+def cmd_approvals(args: argparse.Namespace) -> dict[str, Any]:
+    if args.json:
+        return runtime.approvals(Path(args.workspace).resolve(), agent_id=args.agent)
+    return runtime.format_approvals(Path(args.workspace).resolve(), agent_id=args.agent)
+
+
+def cmd_peek(args: argparse.Namespace) -> dict[str, Any]:
+    if not args.allow_raw_screen:
+        raise TeamAgentError(
+            "raw worker terminal inspection requires explicit user authorization and --allow-raw-screen; "
+            "normal operation must use status, approvals, inbox, collect, or event logs"
+        )
+    result = runtime.peek(
+        Path(args.workspace).resolve(),
+        args.agent,
+        head=args.head,
+        tail=args.tail,
+        search=args.search,
+        context=args.context,
+    )
+    if args.json:
+        return result
+    return result["text"]
+
+
+def cmd_inbox(args: argparse.Namespace) -> dict[str, Any]:
+    if args.json:
+        return runtime.inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit)
+    return runtime.format_inbox(Path(args.workspace).resolve(), args.agent, limit=args.limit)
+
+
+def cmd_sessions(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.sessions(Path(args.workspace).resolve())
+
+
+def cmd_attach_leader(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.attach_leader(Path(args.workspace).resolve(), pane=args.pane, provider=args.provider)
+
+
+def cmd_takeover(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.takeover(Path(args.workspace).resolve(), team=args.team, confirm=args.confirm)
+
+
+def cmd_send(args: argparse.Namespace) -> dict[str, Any]:
+    target = _send_target(args)
+    return runtime.send_message(
+        Path(args.workspace).resolve(),
+        target,
+        " ".join(args.message),
+        task_id=args.task,
+        sender=args.sender,
+        requires_ack=not args.no_ack,
+        confirm_human=args.confirm_human,
+        wait_visible=not args.no_wait,
+        timeout=args.timeout,
+        watch_result=args.watch_result,
+        team=args.team,
+    )
+
+
+def _send_target(args: argparse.Namespace) -> str | list[str] | None:
+    if getattr(args, "targets", None):
+        return [item.strip() for item in args.targets.split(",") if item.strip()]
+    return args.target
+
+
+def cmd_collect(args: argparse.Namespace) -> dict[str, Any]:
+    result_file = Path(args.result_file).resolve() if args.result_file else None
+    return runtime.collect(Path(args.workspace).resolve(), result_file=result_file)
+
+
+def cmd_diagnose(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.diagnose(Path(args.workspace).resolve())
+
+
+def cmd_repair_state(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.repair_state(
+        Path(args.workspace).resolve(),
+        task_id=args.task,
+        assignee=args.assignee,
+        status_value=args.status,
+        summary=args.summary,
+    )
+
+
+def cmd_validate_result(args: argparse.Namespace) -> dict[str, Any]:
+    if args.file:
+        raw = Path(args.file).read_text(encoding="utf-8")
+    elif args.result:
+        raw = args.result
+    else:
+        raw = sys.stdin.read()
+    envelope = json.loads(raw)
+    validate_result_envelope(envelope)
+    return {"ok": True, "task_id": envelope["task_id"], "agent_id": envelope["agent_id"], "status": envelope["status"]}
+
+
+def cmd_doctor(args: argparse.Namespace) -> dict[str, Any]:
+    spec = Path(args.spec).resolve() if args.spec else None
+    return runtime.doctor(spec)
+
+
+def cmd_shutdown(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.shutdown(Path(args.workspace).resolve(), keep_logs=args.keep_logs, team=args.team)
+
+
+def cmd_restart(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.restart(Path(args.workspace).resolve(), allow_fresh=args.allow_fresh, team=args.team)
+
+
+def cmd_start_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.start_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        force=args.force,
+        open_display=not args.no_display,
+        allow_fresh=args.allow_fresh,
+        team=args.team,
+    )
+
+
+def cmd_stop_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.stop_agent(Path(args.workspace).resolve(), args.agent, team=args.team)
+
+
+def cmd_reset_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.reset_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        discard_session=args.discard_session,
+        open_display=not args.no_display,
+        team=args.team,
+    )
+
+
+def cmd_add_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.add_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        role_file_path=args.role_file,
+        open_display=not args.no_display,
+        team=args.team,
+    )
+
+
+def cmd_fork_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.fork_agent(
+        Path(args.workspace).resolve(),
+        args.source_agent,
+        as_agent_id=args.as_agent,
+        label=args.label,
+        open_display=not args.no_display,
+        team=args.team,
+    )
+
+
+def cmd_remove_agent(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.remove_agent(
+        Path(args.workspace).resolve(),
+        args.agent,
+        from_spec=args.from_spec,
+        confirm=args.confirm,
+        force=args.force,
+        team=args.team,
+    )
+
+
+def cmd_stuck_list(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.stuck_list(Path(args.workspace).resolve())
+
+
+def cmd_stuck_cancel(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.stuck_cancel(
+        Path(args.workspace).resolve(),
+        args.agent,
+        alert_type=args.alert_type,
+        suppressed_by="leader",
+    )
+
+
+def cmd_acknowledge_idle(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.acknowledge_idle(Path(args.workspace).resolve(), team=args.team)
+
+
+def cmd_allow_peer_talk(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.allow_peer_talk(Path(args.workspace).resolve(), args.agent_a, args.agent_b)
+
+
+def cmd_run_overnight(args: argparse.Namespace) -> dict[str, Any]:
+    from team_agent import orchestrator
+    workspace = Path(args.workspace).resolve()
+    if args.status:
+        return orchestrator.plan_status(workspace, plan_id=args.plan_id)
+    if args.halt:
+        if not args.plan_id:
+            raise TeamAgentError("--halt requires --plan-id")
+        return orchestrator.halt_plan(workspace, args.plan_id, reason=args.reason)
+    if not args.plan:
+        raise TeamAgentError("--plan PATH is required unless --status or --halt is used")
+    return orchestrator.start_plan(workspace, Path(args.plan).resolve(), start=not args.no_start)
+
+
+def cmd_advanced(args: argparse.Namespace) -> str:
+    return "\n".join(
+        [
+            "Low-level commands:",
+            "  init validate compile profile launch preflight start wait-ready settle",
+            "  sessions attach-leader collect diagnose repair-state validate-result",
+            "  install-skill e2e",
+        ]
+    )
+
+
+def cmd_install_skill(args: argparse.Namespace) -> dict[str, Any]:
+    source = repo_root() / "skills" / "team-agent"
+    if args.dest and args.target == "all":
+        raise TeamAgentError("--dest cannot be combined with --target all")
+    if args.dest:
+        dest_dir = Path(args.dest).expanduser().resolve()
+        return _install_skill_to(source, dest_dir, args.dry_run)
+    if args.target == "all":
+        results = [
+            _install_skill_to(source, _skill_dest_dir("codex"), args.dry_run),
+            _install_skill_to(source, _skill_dest_dir("claude"), args.dry_run),
+        ]
+        return {"ok": all(item["ok"] for item in results), "targets": results}
+    return _install_skill_to(source, _skill_dest_dir(args.target), args.dry_run)
+
+
+def _skill_dest_dir(target: str) -> Path:
+    if target == "claude":
+        dest_dir = Path.home() / ".claude" / "skills" / "team-agent"
+    else:
+        dest_dir = Path.home() / ".codex" / "skills" / "team-agent"
+    return dest_dir
+
+
+def _install_skill_to(source: Path, dest_dir: Path, dry_run: bool) -> dict[str, Any]:
+    dest = dest_dir / "SKILL.md"
+    if dry_run:
+        return {"ok": True, "source": str(source / "SKILL.md"), "dest": str(dest), "dry_run": True}
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source, dest_dir, dirs_exist_ok=True)
+    return {"ok": True, "source": str(source / "SKILL.md"), "dest": str(dest)}

package/src/team_agent/cli/e2e.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import argparse
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from team_agent import runtime
+from team_agent.simple_yaml import dumps
+
+
+def cmd_e2e(args: argparse.Namespace) -> dict[str, Any]:
+    providers = [item.strip() for item in args.providers.split(",") if item.strip()]
+    workspace = Path(args.workspace).resolve() if args.workspace else Path(tempfile.mkdtemp(prefix="team-agent-e2e-"))
+    workspace.mkdir(parents=True, exist_ok=True)
+    results: dict[str, Any] = {"workspace": str(workspace), "providers": {}, "ok": True}
+    if "fake" in providers:
+        spec_path = workspace / "team.spec.yaml"
+        spec_path.write_text(dumps(_fake_spec(workspace)), encoding="utf-8")
+        results["providers"]["fake"] = _run_fake_e2e(spec_path, workspace)
+        results["ok"] = results["ok"] and results["providers"]["fake"]["ok"]
+    for provider in [p for p in providers if p != "fake"]:
+        from team_agent.providers import get_adapter
+
+        adapter = get_adapter(provider)
+        installed = adapter.is_installed()
+        if not installed:
+            provider_result = {
+                "ok": False,
+                "skipped": True,
+                "reason": f"{adapter.command_name} not installed",
+                "version": None,
+            }
+        elif not args.real:
+            provider_result = {
+                "ok": False,
+                "skipped": True,
+                "reason": "real provider launch disabled; rerun with --real on an authenticated machine",
+                "version": adapter.version(),
+            }
+        else:
+            provider_result = _run_real_launch_smoke(provider, workspace)
+        results["providers"][provider] = provider_result
+        results["ok"] = results["ok"] and provider_result["ok"]
+    return results
+
+
+def _run_fake_e2e(spec_path: Path, workspace: Path) -> dict[str, Any]:
+    launched = runtime.launch(spec_path, auto_approve=True)
+    sent = runtime.send_message(workspace, None, "implement fake task", task_id="task_impl", requires_ack=True)
+    import time
+
+    time.sleep(1.0)
+    collected = runtime.collect(workspace)
+    stopped = runtime.shutdown(workspace)
+    return {"ok": bool(launched["ok"] and sent["ok"] and collected["collected"] and stopped["ok"]), "launch": launched, "send": sent, "collect": collected, "shutdown": stopped}
+
+
+def _run_real_launch_smoke(provider: str, workspace: Path) -> dict[str, Any]:
+    spec_path = workspace / f"team.{provider}.spec.yaml"
+    spec = _fake_spec(workspace)
+    spec["team"]["name"] = f"real-{provider}-smoke"
+    spec["leader"]["provider"] = provider
+    spec["agents"][0]["provider"] = provider
+    spec["agents"][0]["id"] = f"{provider}_smoke"
+    spec["agents"][0]["tools"] = ["fs_read", "fs_list", "git_diff", "mcp_team", "provider_builtin"]
+    spec["agents"][0]["role"] = "reviewer"
+    spec["agents"][0]["system_prompt"]["inline"] = (
+        "Real provider smoke. Do not edit files or run shell. "
+        "Do not call team-agent launch and do not create a nested Team Agent team. "
+        "When asked, call team_orchestrator.report_result exactly once with result_envelope_v1."
+    )
+    spec["routing"]["rules"][0]["assign_to"] = spec["agents"][0]["id"]
+    spec["runtime"]["session_name"] = f"team-agent-real-{provider}"
+    spec["runtime"]["startup_order"] = [spec["agents"][0]["id"]]
+    spec["tasks"][0]["id"] = f"task_real_{provider}_callback"
+    spec["tasks"][0]["title"] = f"Real {provider} callback smoke"
+    spec["tasks"][0]["assignee"] = spec["agents"][0]["id"]
+    spec["tasks"][0]["requires_tools"] = ["fs_read", "git_diff"]
+    spec["tasks"][0]["type"] = "review"
+    spec_path.write_text(dumps(spec), encoding="utf-8")
+    launched = runtime.launch(spec_path, auto_approve=True)
+    import time
+
+    time.sleep(10.0 if provider == "codex" else 3.0)
+    collected = None
+    sent = None
+    if provider == "codex":
+        task_id = spec["tasks"][0]["id"]
+        agent_id = spec["agents"][0]["id"]
+        message = (
+            "Do not call team-agent launch and do not create a nested Team Agent team. "
+            "Do not edit files or run shell. "
+            "Call team_orchestrator.report_result with envelope "
+            f'{{"schema_version":"result_envelope_v1","task_id":"{task_id}",'
+            f'"agent_id":"{agent_id}","status":"success","summary":"ok",'
+            '"changes":[],"tests":[{"command":"real-codex-callback-smoke","status":"passed"}],'
+            '"risks":[],"artifacts":[],"next_actions":[]}. Do not edit files or run shell.'
+        )
+        sent = runtime.send_message(workspace, agent_id, message, task_id=task_id, requires_ack=True)
+        for _ in range(24):
+            time.sleep(5.0)
+            result = runtime.collect(workspace)
+            if result["collected"]:
+                collected = result
+                break
+    status = runtime.status(workspace, as_json=True)
+    stopped = runtime.shutdown(workspace)
+    agent_id = spec["agents"][0]["id"]
+    agent_status = status["agents"].get(agent_id, {})
+    callback_ok = provider != "codex" or bool(collected and collected["collected"])
+    return {
+        "ok": bool(launched["ok"] and stopped["ok"] and agent_status.get("tmux_window_present") and callback_ok),
+        "launch": launched,
+        "send": sent,
+        "collect": collected,
+        "status": status,
+        "shutdown": stopped,
+    }
+
+
+def _fake_spec(workspace: Path) -> dict[str, Any]:
+    return {
+        "version": 1,
+        "team": {
+            "name": "fake-e2e",
+            "mode": "supervisor_worker",
+            "objective": "Exercise fake provider orchestration.",
+            "workspace": str(workspace),
+        },
+        "leader": {
+            "id": "leader",
+            "role": "leader",
+            "provider": "fake",
+            "model": None,
+            "tools": ["fs_read", "fs_list", "mcp_team"],
+            "context_policy": {
+                "keep_user_thread": True,
+                "receive_worker_outputs": "structured_only",
+                "max_worker_result_tokens": 2000,
+            },
+        },
+        "agents": [
+            {
+                "id": "fake_impl",
+                "role": "implementation_engineer",
+                "provider": "fake",
+                "model": None,
+                "working_directory": str(workspace),
+                "system_prompt": {"inline": "Handle fake implementation tasks.", "file": None},
+                "tools": ["fs_read", "fs_write", "fs_list", "execute_bash", "git_diff", "mcp_team", "provider_builtin"],
+                "permission_mode": "restricted",
+                "preferred_for": ["implementation"],
+                "avoid_for": [],
+                "output_contract": {"format": "result_envelope_v1", "required_fields": ["task_id", "status", "summary", "artifacts"]},
+            }
+        ],
+        "routing": {
+            "default_assignee": "leader",
+            "rules": [{"id": "implementation-to-fake", "match": {"type": ["implementation"]}, "assign_to": "fake_impl", "priority": 10}],
+        },
+        "communication": {
+            "protocol": "mcp_inbox",
+            "topology": "leader_centered",
+            "worker_to_worker": True,
+            "ack_timeout_sec": 2,
+            "result_format": "result_envelope_v1",
+            "message_store": {"sqlite": ".team/runtime/team.db", "mirror_files": ".team/messages"},
+        },
+        "runtime": {
+            "backend": "tmux",
+            "display_backend": "none",
+            "session_name": "team-agent-fake-e2e",
+            "auto_launch": True,
+            "require_user_approval_before_launch": False,
+            "max_active_agents": 1,
+            "startup_order": ["fake_impl"],
+        },
+        "context": {
+            "state_file": "team_state.md",
+            "artifact_dir": ".team/artifacts",
+            "log_dir": ".team/logs",
+            "summarization": {
+                "worker_full_logs": "retain_outside_leader_context",
+                "state_update": "after_each_result",
+            },
+        },
+        "tasks": [
+            {
+                "id": "task_impl",
+                "title": "Fake implementation",
+                "type": "implementation",
+                "assignee": None,
+                "deps": [],
+                "acceptance": ["fake result collected"],
+                "status": "pending",
+                "requires_tools": ["fs_write", "execute_bash"],
+                "files": ["src/example.py"],
+                "risk": "low",
+            }
+        ],
+    }