@team-agent/installer 0.5.98 → 0.5.99

package/crates/team-agent/src/provider/types.rs

@@ -352,11 +352,12 @@ pub struct ProviderCommandContext<'a> {
     /// from role doc / TEAM.md / provider default. `None` means the
     /// framework passes no effort flag (provider default).
     ///   - Claude / ClaudeCode: low|medium|high|xhigh|max → `--effort <level>`
-    ///   - Codex: low|medium|high|xhigh → `-c model_reasoning_effort=<level>`
-    ///   - Grok: low|medium|high|xhigh (NOT max) → `--effort <level>`
-    ///   - Copilot / Gemini / CursorAgent / Fake: ignored, warning event
-    ///     emitted at the caller (lifecycle/launch.rs / lifecycle/restart)
-    ///     before construct.
+    ///   - Codex: low|medium|high|xhigh|max|ultra → `-c model_reasoning_effort=<level>`
+    ///     Ultra enables Codex client delegation on top of max reasoning.
+    ///   - Pi: low|medium|high|xhigh|max → `--thinking <level>`; ultra rejected
+    ///   - Grok: low|medium|high|xhigh → `--effort <level>`; max/ultra rejected
+    ///   - Copilot / Gemini / Fake: low..xhigh ignored with a caller warning;
+    ///     max/ultra rejected. CursorAgent rejects all effort.
     pub effort: Option<crate::model::enums::ProviderEffort>,
 }
 

package/examples/team.spec.yaml

@@ -136,7 +136,6 @@ communication:
     mirror_files: .team/messages
 runtime:
   backend: tmux
-  display_backend: none
   session_name: teamspec-full-example
   auto_launch: true
   require_user_approval_before_launch: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.98",
+  "version": "0.5.99",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.98",
-    "@team-agent/cli-darwin-x64": "0.5.98",
-    "@team-agent/cli-linux-x64": "0.5.98"
+    "@team-agent/cli-darwin-arm64": "0.5.99",
+    "@team-agent/cli-darwin-x64": "0.5.99",
+    "@team-agent/cli-linux-x64": "0.5.99"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/schemas/team.schema.json

@@ -59,11 +59,11 @@
     },
     "runtime": {
       "type": "object",
-      "required": ["backend", "display_backend", "session_name", "auto_launch", "require_user_approval_before_launch", "max_active_agents", "startup_order"],
+      "required": ["backend", "session_name", "auto_launch", "require_user_approval_before_launch", "max_active_agents", "startup_order"],
       "additionalProperties": false,
       "properties": {
         "backend": { "enum": ["tmux", "pty"] },
-        "display_backend": { "enum": ["none", "tmux_attach", "iterm", "ghostty", "ghostty_window", "ghostty_workspace"] },
+        "display_backend": {},
         "session_name": { "type": "string", "minLength": 1 },
         "auto_launch": { "type": "boolean" },
         "require_user_approval_before_launch": { "type": "boolean" },

package/skills/team-agent/SKILL.md

@@ -17,7 +17,7 @@ team-agent --help
 team-agent doctor --help
 ```
 
-**Launch** from a tmux-addressable pane: `team-agent claude` or `team-agent codex`, then `team-agent quick-start .team/current`. Do not start a real team from a naked terminal. Existing tmux/Ghostty layouts are valid if `quick-start` runs from the leader pane.
+**Launch** from a tmux-addressable pane: `team-agent claude` or `team-agent codex`, then `team-agent quick-start .team/current`. Do not start a real team from a naked terminal. Workers always run in independent background windows on the workspace-scoped tmux server.
 
 **Operate**
 

package/skills/team-agent/references/team-agent-operator.md

@@ -43,7 +43,7 @@ team-agent codex
 team-agent claude
 ```
 
-Pass provider flags after the provider name, for example `team-agent codex --dangerously-bypass-approvals-and-sandbox`. Existing tmux layouts are valid too, including Finder/Ghostty launchers, as long as `team-agent quick-start` is invoked from the leader's current tmux pane. Do not start a real team from a naked terminal that Team Agent cannot address through tmux.
+Pass provider flags after the provider name, for example `team-agent codex --dangerously-bypass-approvals-and-sandbox`. Run `team-agent quick-start` from the leader's current tmux pane. Do not start a real team from a naked terminal that Team Agent cannot address through tmux.
 
 **0.5.66:** leader `--dangerously-*` flags no longer inherit bypass to workers. Per-worker bypass is the role field `dangerously_skip_permissions` (see Permissions).
 
@@ -98,14 +98,7 @@ team-agent quick-start .team/current
 
 YAML lists must be block style. Use `tools:\n  - fs_read`; do not use `tools: [fs_read, mcp_team]`.
 
-Display choices (set `display_backend:` in `TEAM.md` to opt in):
-
-- `none` (default): headless / no GUI window manager. The team runs entirely in the per-workspace tmux server; this is what the demo above uses.
-- `adaptive`: framework picks an available GUI layout for the local platform.
-- `ghostty_workspace`: one Ghostty window. Workers are shown in tmux tabs/windows, up to 3 side-by-side panes per tab. Four workers become `3 + 1`; eight become `3 + 3 + 2`.
-- `ghostty_window`: one Ghostty window per worker.
-
-**Omitting `display_backend` defaults to `none`** (changed in 0.3.4). Set `display_backend: adaptive` (or one of the explicit ghostty variants) in `TEAM.md` only when the user wants GUI windows.
+Workers always run headlessly in independent windows on the per-workspace tmux server. No GUI display backend is configured in `TEAM.md`.
 
 ## Private Tmux Socket
 
@@ -267,7 +260,7 @@ Observed (all exit 0):
 
 ```text
 usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]
-usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]
+usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--json]
 usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]
 ```
 

package/crates/team-agent/src/lifecycle/display.rs

@@ -1,550 +0,0 @@
-//! ---
-//! purpose: team 显示面的能力探测、后端解析、开关与 rebind 后重建
-//! contract:
-//!   provides:
-//!     - name: resolve_display_backend
-//!       what: 按 requested 优先于 recorded 优先于 adaptive 选后端，并标出是否偏离默认
-//!     - name: probe_display_capabilities
-//!       what: 探测当前进程能否开 adaptive 显示，给出被挡原因
-//!     - name: open_worker_displays
-//!       what: 按后端为各 worker 打开显示，返回 agent 到 WorkerDisplay 的映射
-//!     - name: close_team_display_backends
-//!       what: 关闭本 team 的显示后端
-//!     - name: rebuild_adaptive_display_after_rebind
-//!       what: leader rebind 之后重建 adaptive 窗口
-//!   depends:
-//!     - crate::transport
-//!     - crate::state::persist
-//! boundary:
-//!   - 不 spawn 也不 kill worker 进程，只管显示面
-//!   - 显示失败不阻塞 team readiness
-//!   - tmux 操作一律走 workspace 作用域的 TmuxBackend，不用继承 $TMUX 的 ambient 调用
-//!   - ambient leader-pane 探测不属于本文件
-//! maturity: wired
-//! ---
-//!
-//! lifecycle::display —— 能力门 / 后端解析 / 开关 / rebind 后重建。
-//!
-//! 0.5.39 Slice 1 (tmux-server-death-locate §7 Slice 1): all tmux
-//! session/window/pane operations here MUST go through the workspace's
-//! scoped `TmuxBackend` — raw `Command::new("tmux")` / ambient
-//! `run_tmux(...)` helpers in this file inherit ambient `$TMUX` and can
-//! kill sessions on the wrong socket. Ambient leader-pane env probes
-//! (`display-message` reading $TMUX to discover which session invoked
-//! us) live in `tmux_backend::probe_ambient_leader_pane_info` — that
-//! probe is definitionally ambient (its whole job is "which session am I
-//! in") and stays outside this module.
-
-use std::collections::BTreeMap;
-use std::path::Path;
-
-use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
-
-use super::*;
-
-// ── lifecycle::display —— 能力门 / 后端解析 / 开关 / rebind 后重建 ────────────
-
-/// ---
-/// purpose: 定出本次使用的显示后端
-/// params:
-///   requested: 本次命令显式请求的后端，None 表示未指定
-///   recorded: state 里记录的上次后端
-/// returns: 选中的后端，附带它是否偏离默认 adaptive
-/// ---
-///
-/// `resolve_display_backend(requested, recorded, source)`(`display/backend.py`)。默认
-/// adaptive;显式 none 是逃生口。
-pub fn resolve_display_backend(
-    requested: Option<DisplayBackend>,
-    recorded: Option<DisplayBackend>,
-) -> ResolvedBackend {
-    let backend = requested.or(recorded).unwrap_or(DisplayBackend::Adaptive);
-    ResolvedBackend {
-        backend,
-        non_default: backend != DisplayBackend::Adaptive,
-    }
-}
-
-/// ---
-/// purpose: 探测当前环境是否具备 adaptive 显示能力
-/// params:
-///   _workspace: 未参与判定，仅保留签名
-/// returns: 平台名、leader 所在 tmux session 与 pane、能力位、状态与被挡原因
-/// errors: 当前实现不产生 Err
-/// ---
-///
-/// `probe_display_capabilities(...)`(`display/adaptive.py:31`,C13)。能力探测,分支只看
-/// 结果不看 `cfg!(target_os)`;Windows/WSL → `NotImplementedThisPlatform`。
-pub fn probe_display_capabilities(_workspace: &Path) -> Result<DisplayProbe, LifecycleError> {
-    let platform = std::env::consts::OS.to_string();
-    let platform_supported = !matches!(platform.as_str(), "windows") && !in_wsl();
-    let live_tmux_info = current_leader_tmux_info();
-    let in_tmux = platform_supported && (running_inside_tmux() || live_tmux_info.is_some());
-    let tmux_info = live_tmux_info.or_else(env_leader_tmux_info);
-    let opened = in_tmux && platform_supported;
-    let reason = if opened {
-        None
-    } else if platform_supported {
-        Some(AdaptiveBlockReason::LeaderNotInTmux)
-    } else {
-        Some(AdaptiveBlockReason::NotImplementedThisPlatform)
-    };
-    Ok(DisplayProbe {
-        in_tmux,
-        platform,
-        leader_session: tmux_info
-            .as_ref()
-            .map(|info| SessionName::new(info.session.clone())),
-        leader_pane: tmux_info.and_then(|info| info.pane.map(PaneId::new)),
-        caps: CapsFlags {
-            tmux_append_windows: opened,
-            adaptive_display: opened,
-        },
-        adaptive_status: if opened {
-            DisplayStatus::Opened
-        } else {
-            DisplayStatus::Blocked
-        },
-        reason,
-    })
-}
-
-/// ---
-/// purpose: 按已解析的后端为各 worker 打开显示
-/// params:
-///   backend: 已解析的显示后端；不带 worker 视图的后端得到空映射
-///   probe: 能力探测结果，adaptive 分支据此决定开还是记 blocked
-/// returns: 后端与 agent_id 到 WorkerDisplay 的映射
-/// errors: adaptive 开窗或读取显示目标失败时返回 LifecycleError
-/// ---
-///
-/// `open_worker_displays(workspace, session_name, jobs, backend, capability_probe)`
-/// (`display/worker_window.py`)。按后端分派 adaptive / ghostty_workspace / ghostty_window;
-/// 显示失败**不阻塞** team readiness(C14)。
-pub(crate) fn open_worker_displays(
-    workspace: &Path,
-    session_name: &SessionName,
-    backend: DisplayBackend,
-    probe: &DisplayProbe,
-) -> Result<OpenDisplaysReport, LifecycleError> {
-    let displays = match backend {
-        DisplayBackend::Adaptive => open_adaptive_worker_displays(workspace, session_name, probe)?,
-        backend if backend.has_worker_views() => worker_display_targets(workspace, session_name)?
-            .into_iter()
-            .map(|target| {
-                let display = display_for_target(&target, backend, probe);
-                (target.agent_id, display)
-            })
-            .collect(),
-        _ => BTreeMap::new(),
-    };
-    Ok(OpenDisplaysReport { backend, displays })
-}
-
-/// ---
-/// purpose: 关闭本 team 的显示，当前实现只处理 adaptive
-/// returns: 关闭报告
-/// errors: 底层 tmux 操作失败时返回 LifecycleError
-/// ---
-///
-/// `close_team_display_backends(state, event_log)`(`display/close.py`,C9)。按 state
-/// 记录的后端关显示;adaptive 只删带 team tag 的窗口(C2 leader pane 安全)+ orphan 清理。
-pub fn close_team_display_backends(
-    workspace: &Path,
-    session_name: &SessionName,
-) -> Result<CloseDisplaysReport, LifecycleError> {
-    close_adaptive_displays(workspace, session_name)
-}
-
-/// ---
-/// purpose: leader rebind 完成之后重建 adaptive worker 窗口
-/// returns: 重新打开的显示映射
-/// errors: 同 open_worker_displays
-/// ---
-///
-/// `rebuild_adaptive_display_after_rebind(...)`(`display/rebuild.py`,C12)。restart 在
-/// leader rebind **之后**重建 adaptive 窗口(读 `leader_receiver.rebind_applied` 事件)。
-pub fn rebuild_adaptive_display_after_rebind(
-    workspace: &Path,
-    session_name: &SessionName,
-    probe: &DisplayProbe,
-) -> Result<OpenDisplaysReport, LifecycleError> {
-    open_worker_displays(workspace, session_name, DisplayBackend::Adaptive, probe)
-}
-
-#[derive(Debug, Clone)]
-struct DisplayTarget {
-    agent_id: String,
-    window: Option<WindowName>,
-    pane_id: Option<PaneId>,
-    role: Option<String>,
-}
-
-fn worker_display_targets(
-    workspace: &Path,
-    session_name: &SessionName,
-) -> Result<Vec<DisplayTarget>, LifecycleError> {
-    let state = match crate::state::persist::load_runtime_state(workspace) {
-        Ok(state) => state,
-        Err(_) => return Ok(Vec::new()),
-    };
-    let Some(agents) = state.get("agents").and_then(serde_json::Value::as_object) else {
-        return Ok(Vec::new());
-    };
-    let mut targets = Vec::new();
-    for (agent_id, agent) in agents {
-        let window = agent
-            .get("window")
-            .and_then(serde_json::Value::as_str)
-            .unwrap_or(agent_id);
-        targets.push(DisplayTarget {
-            agent_id: agent_id.clone(),
-            window: Some(WindowName::new(window)),
-            pane_id: agent
-                .get("pane_id")
-                .and_then(serde_json::Value::as_str)
-                .filter(|pane| !pane.is_empty())
-                .map(PaneId::new),
-            role: agent
-                .get("role")
-                .and_then(serde_json::Value::as_str)
-                .map(str::to_string),
-        });
-    }
-    let _ = session_name;
-    targets.sort_by(|a, b| a.agent_id.cmp(&b.agent_id));
-    Ok(targets)
-}
-
-fn display_for_target(
-    target: &DisplayTarget,
-    backend: DisplayBackend,
-    probe: &DisplayProbe,
-) -> WorkerDisplay {
-    match backend {
-        DisplayBackend::Adaptive if probe.adaptive_status == DisplayStatus::Opened => {
-            WorkerDisplay::Adaptive {
-                status: DisplayStatus::Opened,
-                window: target.window.clone(),
-                workspace_window: target.window.clone(),
-                pane_id: None,
-                pane_title: target.window.as_ref().map(|_| display_pane_title(target)),
-                target: target
-                    .window
-                    .as_ref()
-                    .map(|window| window.as_str().to_string()),
-                target_worker_session: target
-                    .window
-                    .as_ref()
-                    .map(|window| window.as_str().to_string()),
-                linked_session: None,
-                leader_session: probe.leader_session.clone(),
-                display_session: probe.leader_session.clone(),
-                fallback: Some("tmux_headless".to_string()),
-            }
-        }
-        DisplayBackend::Adaptive => WorkerDisplay::Blocked {
-            reason: probe
-                .reason
-                .unwrap_or(AdaptiveBlockReason::AggregatorRebuildFailed),
-        },
-        DisplayBackend::Ghostty
-        | DisplayBackend::GhosttyWindow
-        | DisplayBackend::GhosttyWorkspace => WorkerDisplay::Blocked {
-            reason: AdaptiveBlockReason::NotImplementedThisPlatform,
-        },
-        DisplayBackend::None | DisplayBackend::TmuxAttach | DisplayBackend::Iterm => {
-            WorkerDisplay::Blocked {
-                reason: AdaptiveBlockReason::NotImplementedThisPlatform,
-            }
-        }
-    }
-}
-
-fn open_adaptive_worker_displays(
-    workspace: &Path,
-    session_name: &SessionName,
-    probe: &DisplayProbe,
-) -> Result<BTreeMap<String, WorkerDisplay>, LifecycleError> {
-    let targets = worker_display_targets(workspace, session_name)?;
-    Ok(targets
-        .into_iter()
-        .map(|target| {
-            let agent_id = target.agent_id.clone();
-            (
-                agent_id.clone(),
-                WorkerDisplay::Adaptive {
-                    status: probe.adaptive_status,
-                    window: target.window.clone(),
-                    workspace_window: target.window.clone(),
-                    pane_id: target.pane_id.clone(),
-                    pane_title: Some(agent_id),
-                    target: target
-                        .pane_id
-                        .as_ref()
-                        .map(|pane| pane.as_str().to_string()),
-                    target_worker_session: Some(session_name.as_str().to_string()),
-                    linked_session: None,
-                    leader_session: Some(session_name.clone()),
-                    display_session: Some(session_name.clone()),
-                    fallback: None,
-                },
-            )
-        })
-        .collect())
-}
-
-fn close_adaptive_displays(
-    workspace: &Path,
-    session_name: &SessionName,
-) -> Result<CloseDisplaysReport, LifecycleError> {
-    let state = match crate::state::persist::load_runtime_state(workspace) {
-        Ok(state) => state,
-        Err(_) => {
-            return Ok(CloseDisplaysReport {
-                closed: Vec::new(),
-                orphans_cleaned: Vec::new(),
-            })
-        }
-    };
-    let Some(agents) = state.get("agents").and_then(serde_json::Value::as_object) else {
-        return Ok(CloseDisplaysReport {
-            closed: Vec::new(),
-            orphans_cleaned: Vec::new(),
-        });
-    };
-    // 0.5.39 Slice 1: build workspace-scoped tmux transport once and
-    // route every destructive tmux op below through it (no ambient
-    // $TMUX). The kill_* Transport methods carry the workspace socket
-    // (`tmux -L <socket>`) so display cleanup cannot cross-kill a session
-    // on the user's default tmux server.
-    let transport = crate::transport_factory::tmux_workspace_transport(workspace);
-    let mut closed = Vec::new();
-    let mut orphans_cleaned = Vec::new();
-    let mut seen = std::collections::BTreeSet::new();
-    for (agent_id, agent) in agents {
-        let Some(display) = agent.get("display").and_then(serde_json::Value::as_object) else {
-            continue;
-        };
-        if display.get("backend").and_then(serde_json::Value::as_str) != Some("adaptive") {
-            continue;
-        }
-        if display
-            .get("status")
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|status| status.eq_ignore_ascii_case("stopped"))
-        {
-            continue;
-        }
-        for target in display_identifiers(display, agent, agent_id, session_name, &state) {
-            if seen.insert(target.clone()) {
-                kill_display_target(&transport, &target);
-                closed.push(target);
-            }
-        }
-    }
-    if let Some(leader_session) = adaptive_leader_session(&state) {
-        for target in
-            close_adaptive_windows(&transport, leader_session.as_str(), session_name.as_str())
-        {
-            orphans_cleaned.push(target.clone());
-            if seen.insert(target.clone()) {
-                closed.push(target);
-            }
-        }
-    }
-    closed.sort();
-    if orphans_cleaned.is_empty() {
-        let overview_prefix = format!(":team-agent:{}:overview", session_name.as_str());
-        orphans_cleaned.extend(
-            closed
-                .iter()
-                .filter(|target| target.contains(&overview_prefix))
-                .cloned(),
-        );
-    }
-    orphans_cleaned.sort();
-    orphans_cleaned.dedup();
-    Ok(CloseDisplaysReport {
-        closed,
-        orphans_cleaned,
-    })
-}
-
-fn display_identifiers(
-    display: &serde_json::Map<String, serde_json::Value>,
-    agent: &serde_json::Value,
-    agent_id: &str,
-    session_name: &SessionName,
-    state: &serde_json::Value,
-) -> Vec<String> {
-    let mut targets = Vec::new();
-    let leader_session = display
-        .get("leader_session")
-        .and_then(serde_json::Value::as_str)
-        .filter(|s| !s.is_empty())
-        .map(str::to_string)
-        .or_else(|| adaptive_leader_session(state));
-    let window = display
-        .get("workspace_window")
-        .or_else(|| display.get("window"))
-        .or_else(|| agent.get("window"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|s| !s.is_empty());
-    if let (Some(leader_session), Some(window)) = (leader_session, window) {
-        if adaptive_window_is_tagged(session_name.as_str(), window) {
-            targets.push(format!("{leader_session}:{window}"));
-        } else {
-            targets.push(format!(
-                "{leader_session}:{}",
-                adaptive_window_name(session_name.as_str(), 0)
-            ));
-        }
-    }
-    for key in ["linked_session", "pane_id"] {
-        if let Some(value) = string_field(display, key) {
-            targets.push(value);
-        }
-    }
-    if targets.is_empty() {
-        let window = agent
-            .get("window")
-            .and_then(serde_json::Value::as_str)
-            .filter(|s| !s.is_empty())
-            .unwrap_or(agent_id);
-        targets.push(format!("{}:{window}", session_name.as_str()));
-    }
-    targets
-}
-
-fn blocked_displays(
-    targets: Vec<DisplayTarget>,
-    reason: AdaptiveBlockReason,
-) -> BTreeMap<String, WorkerDisplay> {
-    targets
-        .into_iter()
-        .map(|target| (target.agent_id, WorkerDisplay::Blocked { reason }))
-        .collect()
-}
-
-#[derive(Debug, Clone)]
-struct LeaderTmuxInfo {
-    session: String,
-    pane: Option<String>,
-}
-
-fn in_wsl() -> bool {
-    std::env::var("WSL_DISTRO_NAME").is_ok_and(|value| !value.is_empty())
-        || std::env::var("WSL_INTEROP").is_ok_and(|value| !value.is_empty())
-}
-
-fn running_inside_tmux() -> bool {
-    std::env::var("TMUX").is_ok_and(|value| !value.is_empty())
-        || std::env::var("TMUX_PANE").is_ok_and(|value| !value.is_empty())
-}
-
-fn current_leader_tmux_info() -> Option<LeaderTmuxInfo> {
-    // 0.5.39 Slice 1: ambient probe lives in `tmux_backend` — the single
-    // controlled exception to the "all tmux ops through socket-scoped
-    // transport" rule (its whole job is "which session am I in?").
-    crate::tmux_backend::probe_ambient_leader_pane_info()
-        .map(|(session, pane)| LeaderTmuxInfo { session, pane })
-}
-
-fn env_leader_tmux_info() -> Option<LeaderTmuxInfo> {
-    let session = std::env::var("TEAM_AGENT_LEADER_SESSION_NAME")
-        .ok()
-        .filter(|value| !value.is_empty())?;
-    let pane = std::env::var("TEAM_AGENT_LEADER_PANE_ID")
-        .ok()
-        .or_else(|| std::env::var("TMUX_PANE").ok())
-        .filter(|value| !value.is_empty());
-    Some(LeaderTmuxInfo { session, pane })
-}
-
-fn close_adaptive_windows(
-    transport: &dyn Transport,
-    leader_session: &str,
-    session_name: &str,
-) -> Vec<String> {
-    let prefix = format!("team-agent:{session_name}:overview");
-    // 0.5.39 Slice 1: `Transport::list_windows` uses the workspace socket
-    // — if `leader_session` doesn't exist on that socket, list_windows
-    // returns Err/empty and we bail without touching another server.
-    let Ok(windows) = transport.list_windows(&SessionName::new(leader_session.to_string())) else {
-        return Vec::new();
-    };
-    windows
-        .into_iter()
-        .filter_map(|window| {
-            let window = window.as_str().to_string();
-            if window == prefix || window.starts_with(&format!("{prefix}-")) {
-                let target_string = format!("{leader_session}:{window}");
-                let target = Target::SessionWindow {
-                    session: SessionName::new(leader_session.to_string()),
-                    window: WindowName::new(window),
-                };
-                transport.kill_window(&target).ok().map(|_| target_string)
-            } else {
-                None
-            }
-        })
-        .collect()
-}
-
-fn kill_display_target(transport: &dyn Transport, target: &str) {
-    // 0.5.39 Slice 1: only kill window/pane — never fall back to
-    // kill-session on an ambiguous string shape. Locate §7 Slice 1:
-    // "Remove the string-shape `kill-session` fallback unless target is a
-    // proven display-only session." The old code parsed any bare
-    // non-`%`/non-`:` target as a session and issued `kill-session`,
-    // which is exactly the unbounded blast radius we're closing.
-    if let Some((session, window)) = target.split_once(':') {
-        let _ = transport.kill_window(&Target::SessionWindow {
-            session: SessionName::new(session.to_string()),
-            window: WindowName::new(window.to_string()),
-        });
-    } else if target.starts_with('%') {
-        let _ = transport.kill_pane(&PaneId::new(target.to_string()));
-    }
-    // Bare session-name form is intentionally a no-op: display cleanup
-    // must not kill a whole session on shape guesswork.
-}
-
-fn adaptive_leader_session(state: &serde_json::Value) -> Option<String> {
-    state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("session_name"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|s| !s.is_empty())
-        .map(str::to_string)
-}
-
-fn adaptive_window_name(session_name: &str, index: usize) -> String {
-    if index == 0 {
-        format!("team-agent:{session_name}:overview")
-    } else {
-        format!("team-agent:{session_name}:overview-{}", index + 1)
-    }
-}
-
-fn adaptive_window_is_tagged(session_name: &str, window: &str) -> bool {
-    let prefix = format!("team-agent:{session_name}:overview");
-    window == prefix || window.starts_with(&format!("{prefix}-"))
-}
-
-fn display_pane_title(target: &DisplayTarget) -> String {
-    format!(
-        "team-agent:{}:{}",
-        target.agent_id,
-        target.role.as_deref().unwrap_or("")
-    )
-}
-
-fn string_field(display: &serde_json::Map<String, serde_json::Value>, key: &str) -> Option<String> {
-    display
-        .get(key)
-        .and_then(serde_json::Value::as_str)
-        .filter(|s| !s.is_empty())
-        .map(str::to_string)
-}