@team-agent/installer 0.3.34 → 0.3.36

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.34"
+version = "0.3.36"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.34"
+version = "0.3.36"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -152,7 +152,7 @@ fn quickstart_human(value: &Value) -> String {
         .map(|items| items.iter().filter_map(Value::as_str).collect())
         .unwrap_or_default();
     if attach.is_empty() {
-        return summary.to_string();
+        return append_reminder(summary.to_string(), crate::cli::QUICK_START_REMINDER);
     }
     let mut out = String::from(summary);
     out.push_str("\n\nattach:");
@@ -160,7 +160,15 @@ fn quickstart_human(value: &Value) -> String {
         out.push_str("\n  ");
         out.push_str(cmd);
     }
-    out
+    append_reminder(out, crate::cli::QUICK_START_REMINDER)
+}
+
+fn append_reminder(text: String, reminder: &str) -> String {
+    if text.is_empty() {
+        reminder.to_string()
+    } else {
+        format!("{text}\n{reminder}")
+    }
 }
 
 /// `cmd_compile`(`commands.py:42`)。
@@ -240,7 +248,10 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
             true,
             false,
         )?;
-        return Ok(CmdResult::human(format_status_summary(&value)));
+        return Ok(CmdResult::human(append_reminder(
+            format_status_summary(&value),
+            crate::cli::STATUS_REMINDER,
+        )));
     }
     if args.json {
         let value = status_port::status_scoped(
@@ -252,12 +263,15 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         )?;
         return Ok(CmdResult::from_json(value, true));
     }
-    Ok(CmdResult::human(status_port::format_status_scoped(
-        &selected.run_workspace,
-        &selected.state,
-        Some(&selected.team_key),
-        args.agent.as_deref(),
-    )?))
+    Ok(CmdResult::human(append_reminder(
+        status_port::format_status_scoped(
+            &selected.run_workspace,
+            &selected.state,
+            Some(&selected.team_key),
+            args.agent.as_deref(),
+        )?,
+        crate::cli::STATUS_REMINDER,
+    )))
 }
 
 fn status_selector_error_payload(error: &str, workspace: &Path) -> Value {
@@ -276,6 +290,7 @@ fn status_selector_error_payload(error: &str, workspace: &Path) -> Value {
         "action": "run `team-agent doctor` or inspect the log path shown here",
         "log": log_path.to_string_lossy().to_string(),
         "workspace": workspace.to_string_lossy().to_string(),
+        "reminder": crate::cli::STATUS_REMINDER,
     })
 }
 
@@ -1583,15 +1598,22 @@ mod tests {
         assert!(out.contains("team started"), "must keep summary; got {out}");
         assert!(out.contains("attach:"), "must render attach block; got {out}");
         assert!(out.contains("team-y:w1") && out.contains("team-y:w2"), "must list each attach cmd; got {out}");
+        assert!(out.ends_with(crate::cli::QUICK_START_REMINDER), "must append harness reminder; got {out}");
     }
 
     #[test]
     fn e13_quickstart_human_summary_only_when_no_attach() {
         let value = json!({"summary": "quick-start complete"});
-        assert_eq!(quickstart_human(&value), "quick-start complete");
+        assert_eq!(
+            quickstart_human(&value),
+            format!("quick-start complete\n{}", crate::cli::QUICK_START_REMINDER)
+        );
         // 空数组也只 summary。
         let value2 = json!({"summary": "s", "attach_commands": []});
-        assert_eq!(quickstart_human(&value2), "s");
+        assert_eq!(
+            quickstart_human(&value2),
+            format!("s\n{}", crate::cli::QUICK_START_REMINDER)
+        );
     }
 
     #[test]

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

@@ -48,6 +48,9 @@ use crate::messaging::{self, AlertType, MessageTarget, SendOptions};
 use crate::model::ids::{TaskId, TeamKey};
 
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
+pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker terminal output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
+pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker to report_result. Do not poll the worker terminal with capture-pane.";
+pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
 
 pub mod adapters;
 pub mod diagnose;
@@ -158,13 +161,7 @@ pub mod lifecycle_port {
             crate::leader::LeaderLaunchStatus::Detached => true,
             crate::leader::LeaderLaunchStatus::NotStarted => false,
         };
-        let leader_attach_command = if plan.is_external_leader {
-            None
-        } else {
-            plan.session_name.as_ref().and_then(|session| {
-                crate::tmux_backend::attach_command_for_workspace(cwd, session, "leader")
-            })
-        };
+        let leader_attach_command = leader_attach_command_for_plan(cwd, &plan);
         Ok(json!({
             "ok": ok,
             "provider": provider,
@@ -182,6 +179,18 @@ pub mod lifecycle_port {
             "session_name": plan.session_name.as_ref().map(|session| session.as_str().to_string()),
         }))
     }
+
+    pub(crate) fn leader_attach_command_for_plan(
+        cwd: &Path,
+        plan: &crate::leader::LeaderStartPlan,
+    ) -> Option<String> {
+        if plan.is_external_leader {
+            return None;
+        }
+        let session = plan.session_name.as_ref()?;
+        let window = plan.leader_window.as_ref()?;
+        crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
+    }
     /// `runtime.shutdown`(`cmd_shutdown`)。
     pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
@@ -2522,6 +2531,7 @@ pub mod lifecycle_port {
                     "display_backend": display_backend,
                     "next_actions": next_actions,
                     "attach_commands": attach_commands,
+                    "reminder": crate::cli::QUICK_START_REMINDER,
                     "readiness": readiness_json.clone(),
                     "worker_readiness": readiness_json,
                 })
@@ -2540,6 +2550,7 @@ pub mod lifecycle_port {
                 "state_path": state_path.map(|p| p.to_string_lossy().to_string()),
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::QuickStartReport::PreflightBlocked {
                 summary,
@@ -2552,6 +2563,7 @@ pub mod lifecycle_port {
                 "blockers": blockers,
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
         }
     }
@@ -2576,6 +2588,10 @@ pub mod lifecycle_port {
                 Some("tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker"),
                 "B-2: ExistingRuntime JSON must preserve attach_commands instead of only next_actions; value={value}"
             );
+            assert_eq!(
+                value.get("reminder").and_then(Value::as_str),
+                Some(crate::cli::QUICK_START_REMINDER)
+            );
         }
 
         #[test]
@@ -2592,6 +2608,20 @@ pub mod lifecycle_port {
                 "B-2: PreflightBlocked JSON must include attach_commands: [] for schema parity with Ready/Restart; value={value}"
             );
         }
+
+        #[test]
+        fn restart_json_includes_harness_reminder() {
+            let value = restart_value(crate::lifecycle::RestartReport::RefusedResumeAtomicity {
+                unresumable: Vec::new(),
+                allow_fresh: false,
+                error: "resume refused".to_string(),
+            });
+
+            assert_eq!(
+                value.get("reminder").and_then(Value::as_str),
+                Some(crate::cli::QUICK_START_REMINDER)
+            );
+        }
     }
 
     fn restart_value(report: crate::lifecycle::RestartReport) -> Value {
@@ -2610,6 +2640,7 @@ pub mod lifecycle_port {
                 "coordinator_started": coordinator_started,
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::Partial {
                 session_name,
@@ -2644,6 +2675,7 @@ pub mod lifecycle_port {
                 "coordinator_started": coordinator_started,
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::Failed {
                 session_name,
@@ -2675,6 +2707,7 @@ pub mod lifecycle_port {
                 })).collect::<Vec<_>>(),
                 "next_actions": next_actions,
                 "attach_commands": attach_commands,
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::RefusedResumeAtomicity {
                 unresumable,
@@ -2686,6 +2719,7 @@ pub mod lifecycle_port {
                 "allow_fresh": allow_fresh,
                 "error": error,
                 "unresumable": unresumable.iter().map(|w| w.agent_id.as_str()).collect::<Vec<_>>(),
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::RefusedResumeNotReady {
                 missing,
@@ -2710,6 +2744,7 @@ pub mod lifecycle_port {
                     "pending_agent_ids": missing.iter().map(|w| w.as_str()).collect::<Vec<_>>(),
                 },
                 "next_action": "rerun restart after session capture completes, or pass --allow-fresh to deliberately discard missing context",
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
             crate::lifecycle::RestartReport::RefusedInvalidFirstSendAt {
                 invalid,
@@ -2721,6 +2756,7 @@ pub mod lifecycle_port {
                 "allow_fresh": allow_fresh,
                 "error": error,
                 "invalid": invalid.iter().map(|w| w.worker_id.as_str()).collect::<Vec<_>>(),
+                "reminder": crate::cli::QUICK_START_REMINDER,
             }),
         }
     }

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

@@ -22,7 +22,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         if content.is_empty() {
             return Err(CliError::Usage("--pane requires a non-empty message".to_string()));
         }
-        let value = send_to_pane_direct(
+        let mut value = send_to_pane_direct(
             &args.workspace,
             pane_id,
             &content,
@@ -31,6 +31,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
             args.team.as_deref(),
             args.json,
         )?;
+        add_send_reminder_if_ok(&mut value);
         return Ok(CmdResult::from_json(value, args.json));
     }
     let selected = crate::state::selector::resolve_active_team(
@@ -60,6 +61,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
             obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
         }
     }
+    add_send_reminder_if_ok(&mut value);
     Ok(CmdResult::from_json(value, args.json))
 }
 
@@ -471,6 +473,15 @@ fn delivery_outcome_json(
     })
 }
 
+fn add_send_reminder_if_ok(value: &mut Value) {
+    if value.get("ok").and_then(Value::as_bool) != Some(true) {
+        return;
+    }
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("reminder".to_string(), json!(crate::cli::SEND_REMINDER));
+    }
+}
+
 fn target_json(target: &MessageTarget) -> Value {
     match target {
         MessageTarget::Single(agent) => json!(agent),

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

@@ -53,11 +53,15 @@ use rusqlite::params;
         let leader_attach_command = if is_external_leader {
             None
         } else {
+            let window_name = state
+                .pointer("/leader_receiver/window_name")
+                .and_then(Value::as_str)
+                .unwrap_or("leader");
             session_name.as_str().and_then(|session| {
                 crate::tmux_backend::attach_command_for_workspace(
                     workspace,
                     &crate::transport::SessionName::new(session.to_string()),
-                    "leader",
+                    window_name,
                 )
             })
         };
@@ -95,6 +99,7 @@ use rusqlite::params;
             "readiness": readiness,
             "coordinator": coordinator_health_value(health),
             "runtime": runtime_block,
+            "reminder": crate::cli::STATUS_REMINDER,
             "last_events": Value::Array(
                 crate::event_log::EventLog::new(workspace)
                     .tail(10)
@@ -594,6 +599,7 @@ use rusqlite::params;
             "latest_results": take_array(full.get("latest_results"), 5),
             "readiness": full.get("readiness").cloned().unwrap_or_else(|| json!({})),
             "coordinator": compact_object(full.get("coordinator"), &["status", "pid", "metadata_ok", "schema_ok"]),
+            "reminder": full.get("reminder").cloned().unwrap_or_else(|| json!(crate::cli::STATUS_REMINDER)),
             "last_events": take_array_tail(full.get("last_events"), 10),
         })
     }

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -50,10 +50,15 @@ use super::*;
             "results",
             "latest_results",
             "coordinator",
+            "reminder",
             "last_events",
         ] {
             assert!(obj.contains_key(key), "compact status missing key `{key}`");
         }
+        assert_eq!(
+            obj.get("reminder").and_then(|v| v.as_str()),
+            Some(crate::cli::STATUS_REMINDER)
+        );
         // seeded agent surfaces through the projection.
         assert!(
             obj["agents"].as_object().unwrap().contains_key("a1"),
@@ -65,6 +70,27 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn cmd_status_human_appends_harness_reminder() {
+        let ws = seed_status_workspace();
+        let args = StatusArgs {
+            agent: None,
+            workspace: ws.clone(),
+            detail: false,
+            summary: false,
+            json: false,
+        };
+
+        let r = cmd_status_for_team(&args, None).expect("status");
+        let text = match r.output {
+            CmdOutput::Human(text) => text,
+            other => panic!("expected human status output, got {other:?}"),
+        };
+
+        assert!(text.ends_with(crate::cli::STATUS_REMINDER), "{text}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_status_reports_managed_leader_topology_and_attach_command() {
         let ws = seed_status_workspace();
@@ -86,6 +112,59 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn status_port_managed_attach_command_uses_receiver_window_name() {
+        let ws = seed_status_workspace();
+        let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if let Some(obj) = state.as_object_mut() {
+            obj.insert("is_external_leader".to_string(), json!(false));
+            obj.insert("session_name".to_string(), json!("team-current"));
+            obj.insert(
+                "leader_receiver".to_string(),
+                json!({"pane_id": "%3", "window_name": "claude_code", "status": "attached"}),
+            );
+        }
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+
+        let attach = v["leader_attach_command"]
+            .as_str()
+            .expect("managed status includes attach command");
+        assert!(attach.contains("attach -t team-current:claude_code"), "{attach}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn leader_attach_command_for_plan_uses_plan_leader_window() {
+        let ws = tmp_workspace();
+        let plan = crate::leader::LeaderStartPlan {
+            mode: crate::leader::LeaderStartMode::ManagedTmuxClient,
+            provider: crate::provider::Provider::ClaudeCode,
+            workspace: ws.clone(),
+            socket: crate::leader::LeaderLaunchSocket::Workspace,
+            session_name: Some(crate::transport::SessionName::new(
+                "team-agent-leader-claude_code-demo".to_string(),
+            )),
+            argv: Vec::new(),
+            provider_argv: Vec::new(),
+            leader_window: Some(crate::transport::WindowName::new("claude_code")),
+            is_external_leader: false,
+            leader_env: std::collections::BTreeMap::new(),
+            identity: None,
+            detached: false,
+        };
+
+        let attach = lifecycle_port::leader_attach_command_for_plan(&ws, &plan)
+            .expect("managed plan has attach command");
+
+        assert!(
+            attach.contains("attach -t team-agent-leader-claude_code-demo:claude_code"),
+            "{attach}"
+        );
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_missing_topology_marker_defaults_to_managed() {
         let ws = seed_status_workspace();
@@ -202,6 +281,12 @@ use super::*;
         match r.output {
             CmdOutput::Json(ref v) => {
                 assert!(v.get("ok").is_some(), "send result Json must carry `ok`");
+                if v.get("ok").and_then(|ok| ok.as_bool()) == Some(true) {
+                    assert_eq!(
+                        v.get("reminder").and_then(|reminder| reminder.as_str()),
+                        Some(crate::cli::SEND_REMINDER)
+                    );
+                }
             }
             other => panic!("cmd_send must emit Json DeliveryOutcome, got {other:?}"),
         }

package/crates/team-agent/src/leader/start.rs

@@ -7,7 +7,9 @@ use std::process::{Command, Stdio};
 
 use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
-use crate::transport::{PaneId, SessionName, SpawnResult, Target, Transport, WindowName};
+use crate::transport::{
+    PaneId, PaneLiveness, SessionName, SpawnResult, Target, Transport, WindowName,
+};
 
 use super::helpers::{
     provider_wire, resolve_workspace_for_hash, sanitize_session_folder, sha1_hex_prefix,
@@ -405,6 +407,7 @@ fn execute_managed_leader_plan(
                 .unwrap_or_else(|| "signal".to_string())
         )));
     }
+    ensure_managed_provider_live_after_attach(&transport, &spawned)?;
     Ok(LeaderLaunchOutcome {
         status: LeaderLaunchStatus::Exited,
         exit_code: code,
@@ -414,7 +417,7 @@ fn execute_managed_leader_plan(
 }
 
 fn ensure_managed_leader_pane(
-    transport: &TmuxBackend,
+    transport: &dyn Transport,
     session: &SessionName,
     window: &WindowName,
     plan: &LeaderStartPlan,
@@ -455,6 +458,39 @@ fn ensure_managed_leader_pane(
     }
 }
 
+fn ensure_managed_provider_live_after_attach(
+    transport: &dyn Transport,
+    spawned: &SpawnResult,
+) -> Result<(), LeaderError> {
+    let live = match transport.liveness(&spawned.pane_id) {
+        Ok(PaneLiveness::Live) => true,
+        Ok(PaneLiveness::Dead) => false,
+        Ok(PaneLiveness::Unknown) | Err(_) => managed_spawned_pane_in_targets(transport, spawned),
+    };
+    if live {
+        return Ok(());
+    }
+    Err(LeaderError::Start(format!(
+        "managed leader provider pane is not running after tmux client returned: {} {}:{}",
+        spawned.pane_id.as_str(),
+        spawned.session.as_str(),
+        spawned.window.as_str()
+    )))
+}
+
+fn managed_spawned_pane_in_targets(transport: &dyn Transport, spawned: &SpawnResult) -> bool {
+    transport
+        .list_targets()
+        .unwrap_or_default()
+        .iter()
+        .any(|pane| {
+            pane.pane_id.as_str() == spawned.pane_id.as_str()
+                && pane.session.as_str() == spawned.session.as_str()
+                && pane.window_name.as_ref().map(WindowName::as_str)
+                    == Some(spawned.window.as_str())
+        })
+}
+
 fn persist_managed_leader_binding(
     plan: &LeaderStartPlan,
     workspace: &Path,
@@ -911,11 +947,16 @@ mod tests {
         TurnVerification, WindowName,
     };
 
-    use super::{execute_leader_plan, handle_exec_provider_startup_prompts, shlex_quote};
+    use super::{
+        ensure_managed_provider_live_after_attach, execute_leader_plan,
+        handle_exec_provider_startup_prompts, shlex_quote,
+    };
 
     struct ScriptedTransport {
         screens: Mutex<Vec<String>>,
         sent: Mutex<Vec<(Target, Vec<Key>)>>,
+        liveness: PaneLiveness,
+        targets: Vec<PaneInfo>,
     }
 
     impl ScriptedTransport {
@@ -923,6 +964,26 @@ mod tests {
             Self {
                 screens: Mutex::new(screens),
                 sent: Mutex::new(Vec::new()),
+                liveness: PaneLiveness::Unknown,
+                targets: Vec::new(),
+            }
+        }
+
+        fn with_liveness(liveness: PaneLiveness) -> Self {
+            Self {
+                screens: Mutex::new(Vec::new()),
+                sent: Mutex::new(Vec::new()),
+                liveness,
+                targets: Vec::new(),
+            }
+        }
+
+        fn with_liveness_and_targets(liveness: PaneLiveness, targets: Vec<PaneInfo>) -> Self {
+            Self {
+                screens: Mutex::new(Vec::new()),
+                sent: Mutex::new(Vec::new()),
+                liveness,
+                targets,
             }
         }
 
@@ -1024,11 +1085,11 @@ mod tests {
         }
 
         fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-            Ok(PaneLiveness::Unknown)
+            Ok(self.liveness)
         }
 
         fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-            Ok(Vec::new())
+            Ok(self.targets.clone())
         }
 
         fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
@@ -1063,6 +1124,69 @@ mod tests {
         }
     }
 
+    fn managed_spawn_result() -> SpawnResult {
+        SpawnResult {
+            pane_id: PaneId::new("%42"),
+            session: SessionName::new("team-agent-leader-claude_code-demo"),
+            window: WindowName::new("claude_code"),
+            child_pid: Some(1234),
+        }
+    }
+
+    fn managed_pane_info(spawned: &SpawnResult) -> PaneInfo {
+        PaneInfo {
+            pane_id: spawned.pane_id.clone(),
+            session: spawned.session.clone(),
+            window_index: Some(0),
+            window_name: Some(spawned.window.clone()),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("claude".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: spawned.child_pid,
+            leader_env: BTreeMap::new(),
+        }
+    }
+
+    #[test]
+    fn managed_attach_success_requires_live_provider_pane() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness(PaneLiveness::Dead);
+
+        let err = ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect_err("dead provider pane must fail managed launch");
+
+        let text = err.to_string();
+        assert!(
+            text.contains("managed leader provider pane is not running"),
+            "{text}"
+        );
+        assert!(text.contains("%42"), "{text}");
+        assert!(text.contains("claude_code"), "{text}");
+    }
+
+    #[test]
+    fn managed_attach_success_accepts_live_provider_pane() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness(PaneLiveness::Live);
+
+        ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect("live provider pane keeps managed launch successful");
+    }
+
+    #[test]
+    fn managed_attach_success_uses_target_scan_when_liveness_unknown() {
+        let spawned = managed_spawn_result();
+        let transport = ScriptedTransport::with_liveness_and_targets(
+            PaneLiveness::Unknown,
+            vec![managed_pane_info(&spawned)],
+        );
+
+        ensure_managed_provider_live_after_attach(&transport, &spawned)
+            .expect("target scan can prove provider pane is still live");
+    }
+
     struct EnvGuard {
         saved: Vec<(&'static str, Option<String>)>,
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.34",
+  "version": "0.3.36",
   "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.3.34",
-    "@team-agent/cli-darwin-x64": "0.3.34",
-    "@team-agent/cli-linux-x64": "0.3.34"
+    "@team-agent/cli-darwin-arm64": "0.3.36",
+    "@team-agent/cli-darwin-x64": "0.3.36",
+    "@team-agent/cli-linux-x64": "0.3.36"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",