@team-agent/installer 0.5.111 → 0.5.112

package/crates/team-agent/src/cli/adapters.rs

@@ -4,7 +4,6 @@
 //! `cmd_doctor`(gate/comms/fix-schema/cleanup-orphans 分派)。
 
 use super::*;
-use crate::transport::Transport;
 
 /// `cmd_quick_start`(`commands.py:18`)。`--json` 或 `!ok` → 整 dict;否则 `result["summary"]`。
 pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
@@ -350,699 +349,11 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
     )))
 }
 
-/// `cmd_watch`(`commands.py:103`)。委派 `coordinator::run_watch`;KeyboardInterrupt/正常 → `SystemExit(0)`。
-/// 返回 [`CmdResult::none`](不经 emit)。
-pub fn cmd_watch(args: &WatchArgs) -> Result<CmdResult, CliError> {
-    let workspace = crate::coordinator::WorkspacePath::new(args.workspace.clone());
-    #[cfg(not(test))]
-    {
-        let mut output = |line: &str| {
-            println!("{line}");
-            let _ = std::io::Write::flush(&mut std::io::stdout());
-        };
-        crate::coordinator::run_watch(&workspace, args.team.as_deref(), 1.0, &mut output)
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
-        Ok(CmdResult::none())
-    }
-    #[cfg(test)]
-    {
-        let store = crate::message_store::MessageStore::open(&args.workspace)
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut cursor = crate::coordinator::WatchCursor::default();
-        let lines = crate::coordinator::collect_watch_lines(
-            &workspace,
-            &mut cursor,
-            &store,
-            args.team.as_deref(),
-        )
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-        Ok(CmdResult::human(lines.join("\n")))
-    }
-}
-
-/// `cmd_sessions`(`parser.py:230`)。
-pub fn cmd_sessions(args: &SessionsArgs) -> Result<CmdResult, CliError> {
-    let selected = crate::state::selector::resolve_active_team(
-        &args.workspace,
-        args.team.as_deref(),
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let spec = match selected.spec_path.as_ref() {
-        Some(path) => load_team_spec_at(path)?,
-        None => load_team_spec_optional(&selected.run_workspace, &selected.state)?,
-    };
-    Ok(CmdResult::from_json(
-        json!({
-            "ok": true,
-            "sessions": sessions_overview(&selected.state, spec.as_ref()),
-            "workspace": args.workspace.to_string_lossy().to_string(),
-        }),
-        args.json,
-    ))
-}
-
-pub fn cmd_results(args: &ResultsArgs) -> Result<CmdResult, CliError> {
-    let selected = match crate::state::selector::resolve_active_team(
-        &args.workspace,
-        args.team.as_deref(),
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    ) {
-        Ok(selected) => selected,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": args.workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let results = messaging::results::results_for_case(
-        &selected.run_workspace,
-        &args.case_id,
-        Some(selected.team_key.as_str()),
-        args.team.as_deref(),
-    )?;
-    let value = json!({
-        "ok": true,
-        "case_id": args.case_id,
-        "results": results,
-        "workspace": selected.run_workspace.to_string_lossy().to_string(),
-    });
-    Ok(if args.json {
-        CmdResult::from_ordered_json(value)
-    } else {
-        CmdResult::from_json(value, false)
-    })
-}
-
 pub fn cmd_wait(args: &WaitArgs) -> Result<CmdResult, CliError> {
     let result = messaging::wait_for_result(&args.workspace, &args.task_id)?;
     Ok(CmdResult::from_json(result.to_json(), args.json))
 }
 
-/// `cmd_allow_peer_talk`(`parser.py allow-peer-talk`).
-pub fn cmd_allow_peer_talk(args: &AllowPeerTalkArgs) -> Result<CmdResult, CliError> {
-    if args.team.is_some() {
-        return Err(CliError::Usage(
-            "allow-peer-talk --team is not supported yet because peer allowlist storage is not team-scoped".to_string(),
-        ));
-    }
-    let value = messaging::allow_peer_talk(&args.workspace, &args.a, &args.b)?;
-    Ok(CmdResult::from_json(value, args.json))
-}
-
-/// `cmd_preflight`(`parser.py:160`)。
-pub fn cmd_preflight(args: &PreflightArgs) -> Result<CmdResult, CliError> {
-    let report = build_preflight_report(&args.team)?;
-    Ok(CmdResult::from_json(report, args.json))
-}
-
-/// `cmd_wait_ready`(`parser.py:171`)。
-pub fn cmd_wait_ready(args: &WaitReadyArgs) -> Result<CmdResult, CliError> {
-    let report = build_wait_ready_report(&args.workspace, args.timeout, args.team.as_deref())?;
-    Ok(CmdResult::from_json(report, args.json))
-}
-
-/// `cmd_e2e`(`parser.py:449`)。
-pub fn cmd_e2e(args: &E2eArgs) -> Result<CmdResult, CliError> {
-    let mut providers = serde_json::Map::new();
-    for provider in &args.providers {
-        let result = if provider == "fake" {
-            run_fake_e2e(&args.workspace)?
-        } else {
-            skipped_provider_e2e(provider, args.real)
-        };
-        providers.insert(provider.clone(), result);
-    }
-    let ok = providers
-        .values()
-        .all(|value| value.get("ok").and_then(Value::as_bool) == Some(true));
-    Ok(CmdResult::from_json(
-        json!({
-            "workspace": args.workspace.to_string_lossy().to_string(),
-            "providers": Value::Object(providers),
-            "ok": ok,
-        }),
-        args.json,
-    ))
-}
-
-/// `cmd_peek`(`commands.py:118`)。
-pub fn cmd_peek(args: &PeekArgs) -> Result<CmdResult, CliError> {
-    if !args.allow_raw_screen {
-        return Err(CliError::Usage(
-            "peek requires --allow-raw-screen".to_string(),
-        ));
-    }
-    let state = crate::state::persist::load_runtime_state(&args.workspace)?;
-    let Some(agent_state) = state
-        .get("agents")
-        .and_then(|agents| agents.get(&args.agent))
-    else {
-        return Ok(CmdResult::from_json(
-            json!({
-                "ok": false,
-                "agent_id": args.agent,
-                "error": format!("unknown agent id: {}", args.agent),
-            }),
-            args.json,
-        ));
-    };
-    let Some((session, window, target)) = agent_pane_id(&state, &args.agent, agent_state) else {
-        return Ok(peek_unavailable(&args.agent, args.json));
-    };
-    // 0.5.x Phase 1d Batch 3: factory-routed peek backend so conpty
-    // teams peek from the shim scrollback rather than a workspace
-    // tmux capture that would always be empty. Tmux teams keep
-    // byte-equivalent behavior.
-    let backend: Box<dyn crate::transport::Transport> =
-        match crate::transport_factory::resolve_read_only_transport(
-            &args.workspace,
-            Some(&state),
-            crate::transport_factory::TransportPurpose::Status,
-        ) {
-            Ok(r) => r.backend,
-            Err(_) => Box::new(crate::tmux_backend::TmuxBackend::for_workspace(
-                &args.workspace,
-            )),
-        };
-    let windows = backend
-        .list_windows(&crate::transport::SessionName::new(session.clone()))
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    if !windows.iter().any(|w| w.as_str() == window) {
-        return Ok(peek_unavailable(&args.agent, args.json));
-    }
-    let range = args
-        .head
-        .map(|head| crate::transport::CaptureRange::Head(head as u32))
-        .unwrap_or_else(|| crate::transport::CaptureRange::Tail(args.tail as u32));
-    let capture = backend
-        .capture(
-            &crate::transport::Target::Pane(crate::transport::PaneId::new(target.clone())),
-            range,
-        )
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let matches = args.search.as_ref().map(|needle| {
-        capture
-            .text
-            .lines()
-            .filter(|line| line.contains(needle))
-            .map(str::to_string)
-            .collect::<Vec<_>>()
-    });
-    Ok(CmdResult::from_json(
-        json!({
-            "ok": true,
-            "agent_id": args.agent,
-            "workspace": args.workspace.to_string_lossy().to_string(),
-            "tail": args.tail,
-            "head": args.head,
-            "search": args.search,
-            "matches": matches,
-            "pane_id": target,
-            "text": capture.text,
-        }),
-        args.json,
-    ))
-}
-
-fn peek_unavailable(agent: &str, json: bool) -> CmdResult {
-    CmdResult::from_json(
-        json!({
-            "ok": false,
-            "agent_id": agent,
-            "error": format!("agent terminal is not available: {agent}"),
-        }),
-        json,
-    )
-}
-
-fn agent_pane_id(
-    state: &Value,
-    agent: &str,
-    agent_state: &Value,
-) -> Option<(String, String, String)> {
-    let session = state
-        .get("session_name")
-        .and_then(Value::as_str)
-        .filter(|s| !s.is_empty())?;
-    let window = ["window", "window_name"]
-        .iter()
-        .find_map(|key| {
-            agent_state
-                .get(*key)
-                .and_then(Value::as_str)
-                .filter(|s| !s.is_empty())
-        })
-        .unwrap_or(agent);
-    Some((
-        session.to_string(),
-        window.to_string(),
-        format!("{session}:{window}"),
-    ))
-}
-
-fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
-    std::fs::create_dir_all(workspace)?;
-    let spec_path = workspace.join("team.spec.yaml");
-    std::fs::write(&spec_path, fake_spec_yaml(workspace))?;
-    let launch = match crate::lifecycle::launch(&spec_path, true, true, true) {
-        Ok(report) => json!({
-            "ok": true,
-            "dry_run": report.dry_run,
-            "session_name": report.session_name.as_str(),
-        }),
-        Err(error) => json!({
-            "ok": false,
-            "error": error.to_string(),
-        }),
-    };
-    seed_fake_e2e_state(workspace)?;
-    let send = messaging::send_message(
-        workspace,
-        &MessageTarget::Single("fake_impl".to_string()),
-        "implement fake task",
-        &SendOptions {
-            task_id: Some(TaskId::new("task_impl")),
-            route_task_id: false,
-            sender: messaging::TrustedSender::leader(),
-            requires_ack: true,
-            ..SendOptions::default()
-        },
-    )?;
-    let send_value = json!({
-        "ok": send.ok,
-        "status": send.status,
-        "message_status": send.message_status.0,
-        "message_id": send.message_id,
-        "reason": send.reason,
-    });
-    if send.ok {
-        if let Some(message_id) = send.message_id.as_deref() {
-            crate::message_store::MessageStore::open(workspace)
-                .map_err(crate::messaging::MessagingError::from)?
-                .mark(message_id, "delivered", None)
-                .map_err(crate::messaging::MessagingError::from)?;
-        }
-        let report = messaging::report_result(
-            workspace,
-            &json!({
-                "schema_version": "result_envelope_v1",
-                "task_id": "task_impl",
-                "agent_id": "fake_impl",
-                "status": "success",
-                "summary": "fake result finalized",
-                "changes": [],
-                "tests": [],
-                "risks": [],
-                "artifacts": [],
-                "next_actions": [],
-            }),
-        )?;
-        let auto_finalized =
-            report.get("finalization_status").and_then(Value::as_str) == Some("auto_finalized");
-        let shutdown = fake_shutdown(workspace)?;
-        let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
-            && send.ok
-            && auto_finalized
-            && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
-        return Ok(json!({
-            "ok": ok,
-            "launch": launch,
-            "send": send_value,
-            "report": report,
-            "shutdown": shutdown,
-        }));
-    }
-    let shutdown = fake_shutdown(workspace)?;
-    Ok(json!({
-        "ok": false,
-        "launch": launch,
-        "send": send_value,
-        "report": null,
-        "shutdown": shutdown,
-    }))
-}
-
-fn skipped_provider_e2e(provider: &str, real: bool) -> Value {
-    let command = provider_command(provider);
-    if !command_on_path(command) {
-        return json!({
-            "ok": false,
-            "skipped": true,
-            "reason": format!("{command} not installed"),
-            "version": null,
-        });
-    }
-    let version = command_version(command);
-    if !real {
-        return json!({
-            "ok": false,
-            "skipped": true,
-            "reason": "real provider launch disabled; rerun with --real on an authenticated machine",
-            "version": version,
-        });
-    }
-    json!({
-        "ok": false,
-        "skipped": true,
-        "reason": "real provider e2e is not available in this build",
-        "version": version,
-    })
-}
-
-fn command_on_path(command: &str) -> bool {
-    std::env::var_os("PATH").is_some_and(|paths| {
-        std::env::split_paths(&paths).any(|dir| {
-            let candidate = dir.join(command);
-            candidate.is_file()
-        })
-    })
-}
-
-fn command_version(command: &str) -> Value {
-    match std::process::Command::new(command)
-        .arg("--version")
-        .output()
-    {
-        Ok(output) if output.status.success() => {
-            let text = String::from_utf8_lossy(&output.stdout).trim().to_string();
-            if text.is_empty() {
-                Value::Null
-            } else {
-                Value::String(text)
-            }
-        }
-        _ => Value::Null,
-    }
-}
-
-fn provider_command(provider: &str) -> &str {
-    // E2E provider command grammar, not persisted provider identity parsing.
-    match provider {
-        "claude" | "claude_code" => "claude",
-        "gemini" | "gemini_cli" => "gemini",
-        other => other,
-    }
-}
-
-fn seed_fake_e2e_state(workspace: &Path) -> Result<(), CliError> {
-    crate::state::repository::StateRepository::new(workspace).save(
-        crate::state::repository::StateWriteIntent::FakeE2eSeed,
-        &json!({
-            "leader": {"id": "leader"},
-            "session_name": "team-agent-fake-e2e",
-            "agents": {
-                "fake_impl": {
-                    "provider": "fake",
-                    "status": "running",
-                    "window": "fake_impl",
-                    "pane_id": "%fake_impl",
-                    "spawn_cwd": workspace.to_string_lossy().to_string(),
-                }
-            },
-            "tasks": [{
-                "id": "task_impl",
-                "title": "Fake implementation",
-                "type": "implementation",
-                "assignee": "fake_impl",
-                "status": "pending",
-            }]
-        }),
-    )?;
-    Ok(())
-}
-
-fn fake_shutdown(workspace: &Path) -> Result<Value, CliError> {
-    let mut state = crate::state::persist::load_runtime_state(workspace)?;
-    if let Some(agents) = state.get_mut("agents").and_then(Value::as_object_mut) {
-        for agent in agents.values_mut() {
-            if let Some(obj) = agent.as_object_mut() {
-                obj.insert("status".to_string(), Value::String("stopped".to_string()));
-            }
-        }
-    }
-    crate::state::repository::StateRepository::new(workspace).save(
-        crate::state::repository::StateWriteIntent::FakeE2eSeed,
-        &state,
-    )?;
-    Ok(json!({
-        "ok": true,
-        "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
-        "session_killed": false,
-        "coordinator": {"status": "missing", "pid": null},
-    }))
-}
-
-fn fake_spec_yaml(workspace: &Path) -> String {
-    let ws = workspace.to_string_lossy();
-    format!(
-        r#"version: 1
-team:
-  name: "fake-e2e"
-  mode: "supervisor_worker"
-  objective: "Exercise fake provider orchestration."
-  workspace: "{ws}"
-leader:
-  id: "leader"
-  role: "leader"
-  provider: "fake"
-  model: null
-  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: null
-    working_directory: "{ws}"
-    system_prompt:
-      inline: "Handle fake implementation tasks."
-      file: null
-    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"
-  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: "fake_impl"
-    deps: []
-    acceptance:
-      - "fake result collected"
-    status: "pending"
-    requires_tools:
-      - "fs_write"
-      - "execute_bash"
-    files:
-      - "src/example.py"
-    risk: "low"
-"#
-    )
-}
-
-fn sessions_overview(state: &Value, spec: Option<&crate::model::yaml::Value>) -> Value {
-    let mut rows = Vec::new();
-    if let Some(agents) = spec
-        .and_then(|v| v.get("agents"))
-        .and_then(crate::model::yaml::Value::as_list)
-    {
-        for agent in agents {
-            let Some(agent_id) = agent.get("id").and_then(crate::model::yaml::Value::as_str) else {
-                continue;
-            };
-            let agent_state = state
-                .get("agents")
-                .and_then(|agents| agents.get(agent_id))
-                .unwrap_or(&Value::Null);
-            rows.push(session_row(state, agent, agent_id, agent_state));
-        }
-    }
-    Value::Array(rows)
-}
-
-fn session_row(
-    state: &Value,
-    spec_agent: &crate::model::yaml::Value,
-    agent_id: &str,
-    agent_state: &Value,
-) -> Value {
-    json!({
-        "agent_id": agent_id,
-        "provider": yaml_str(spec_agent, "provider").map(Value::String).unwrap_or(Value::Null),
-        "model": yaml_str(spec_agent, "model").map(Value::String).unwrap_or(Value::Null),
-        "profile": yaml_str(spec_agent, "profile").map(Value::String).unwrap_or(Value::Null),
-        "session_id": field_or_null(agent_state, &["session_id"]),
-        "resume_id": field_or_null(agent_state, &["resume_id"]),
-        "rollout_path": field_or_null(agent_state, &["rollout_path"]),
-        "captured_at": field_or_null(agent_state, &["captured_at"]),
-        "captured_via": field_or_null(agent_state, &["captured_via"]),
-        "attribution_confidence": field_or_null(agent_state, &["attribution_confidence"]),
-        "spawn_cwd": field_or_null(agent_state, &["spawn_cwd", "working_directory"]),
-        "context_usage": field_or_null(agent_state, &["context_usage"]),
-        "status": field_or_default(agent_state, "status", "unknown"),
-        "last_task": last_task_for_agent(state, agent_id),
-        "handoff_path": field_or_null(agent_state, &["handoff_path"]),
-        "display_target": field_or_null(agent_state, &["display"]),
-        "terminal_target": terminal_target(state, agent_id, agent_state),
-    })
-}
-
-fn yaml_str(value: &crate::model::yaml::Value, key: &str) -> Option<String> {
-    value
-        .get(key)
-        .and_then(crate::model::yaml::Value::as_str)
-        .map(ToString::to_string)
-}
-
-fn field_or_null(value: &Value, keys: &[&str]) -> Value {
-    keys.iter()
-        .find_map(|key| value.get(*key).cloned())
-        .unwrap_or(Value::Null)
-}
-
-fn field_or_default(value: &Value, key: &str, default: &str) -> Value {
-    value
-        .get(key)
-        .cloned()
-        .unwrap_or_else(|| Value::String(default.to_string()))
-}
-
-fn last_task_for_agent(state: &Value, agent_id: &str) -> Value {
-    state
-        .get("tasks")
-        .and_then(Value::as_array)
-        .and_then(|tasks| {
-            tasks
-                .iter()
-                .rev()
-                .find(|task| task.get("assignee").and_then(Value::as_str) == Some(agent_id))
-        })
-        .and_then(|task| {
-            task.get("id")
-                .and_then(Value::as_str)
-                .map(ToString::to_string)
-        })
-        .map(Value::String)
-        .unwrap_or(Value::Null)
-}
-
-fn terminal_target(state: &Value, agent_id: &str, agent_state: &Value) -> Value {
-    json!({
-        "session": agent_state
-            .get("session_name")
-            .cloned()
-            .or_else(|| state.get("session_name").cloned())
-            .unwrap_or(Value::Null),
-        "window": window_target(agent_state, agent_id),
-        "pane": field_or_null(agent_state, &["pane_id"]),
-    })
-}
-
-fn window_target(agent_state: &Value, agent_id: &str) -> Value {
-    let window = field_or_null(agent_state, &["window", "window_name"]);
-    if window.is_null() {
-        Value::String(agent_id.to_string())
-    } else {
-        window
-    }
-}
-
-fn load_team_spec_optional(
-    workspace: &Path,
-    state: &Value,
-) -> Result<Option<crate::model::yaml::Value>, CliError> {
-    let spec_path = state
-        .get("spec_path")
-        .and_then(Value::as_str)
-        .filter(|path| !path.is_empty())
-        .map(PathBuf::from)
-        .or_else(|| {
-            state
-                .get("team_dir")
-                .and_then(Value::as_str)
-                .filter(|path| !path.is_empty())
-                .map(|path| PathBuf::from(path).join("team.spec.yaml"))
-        })
-        .unwrap_or_else(|| workspace.join("team.spec.yaml"));
-    if !spec_path.exists() {
-        return Ok(None);
-    }
-    let text = std::fs::read_to_string(&spec_path)?;
-    crate::model::yaml::loads(&text)
-        .map(Some)
-        .map_err(|e| CliError::Runtime(e.to_string()))
-}
-
-fn load_team_spec_at(spec_path: &Path) -> Result<Option<crate::model::yaml::Value>, CliError> {
-    if !spec_path.exists() {
-        return Ok(None);
-    }
-    let text = std::fs::read_to_string(spec_path)?;
-    crate::model::yaml::loads(&text)
-        .map(Some)
-        .map_err(|e| CliError::Runtime(e.to_string()))
-}
-
 /// `cmd_approvals`(`commands.py:112`)。
 pub fn cmd_approvals(args: &ApprovalsArgs) -> Result<CmdResult, CliError> {
     let selected = crate::state::selector::resolve_active_team(
@@ -1168,14 +479,6 @@ pub fn cmd_claim_leader(args: &ClaimLeaderArgs) -> Result<CmdResult, CliError> {
     Ok(CmdResult::from_json(value, args.json))
 }
 
-/// `cmd_identity`(`commands.py:160`)。
-pub fn cmd_identity(args: &IdentityArgs) -> Result<CmdResult, CliError> {
-    Ok(CmdResult::from_json(
-        leader_port::leader_identity(&args.workspace, args.team.as_deref())?,
-        args.json,
-    ))
-}
-
 /// `cmd_shutdown`(`commands.py:340`)。
 pub fn cmd_shutdown(args: &ShutdownArgs) -> Result<CmdResult, CliError> {
     Ok(CmdResult::from_json(
@@ -1714,7 +1017,7 @@ mod tests {
     #![allow(clippy::unwrap_used)]
 
     use super::{
-        agent_pane_id, append_send_guidance, format_inbox_human, quickstart_human, send_command,
+        append_send_guidance, format_inbox_human, quickstart_human, send_command,
         split_shell_argv,
     };
     use serde_json::{json, Value};
@@ -1912,49 +1215,4 @@ mod tests {
         );
     }
 
-    #[test]
-    fn agent_pane_id_resolves_session_window_even_with_recorded_pane_id() {
-        let state = json!({
-            "session_name": "team-x",
-            "agents": {
-                "w1": {"pane_id": "%7", "window": "w1"}
-            }
-        });
-        let agent = state
-            .get("agents")
-            .and_then(|agents| agents.get("w1"))
-            .unwrap();
-
-        assert_eq!(
-            agent_pane_id(&state, "w1", agent).unwrap(),
-            (
-                "team-x".to_string(),
-                "w1".to_string(),
-                "team-x:w1".to_string()
-            )
-        );
-    }
-
-    #[test]
-    fn agent_pane_id_falls_back_to_session_window_target() {
-        let state = json!({
-            "session_name": "team-x",
-            "agents": {
-                "w1": {"window": "worker-one"}
-            }
-        });
-        let agent = state
-            .get("agents")
-            .and_then(|agents| agents.get("w1"))
-            .unwrap();
-
-        assert_eq!(
-            agent_pane_id(&state, "w1", agent).unwrap(),
-            (
-                "team-x".to_string(),
-                "worker-one".to_string(),
-                "team-x:worker-one".to_string()
-            )
-        );
-    }
 }