@team-agent/installer 0.5.68 → 0.5.70

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -0,0 +1,146 @@
+//! ---
+//! purpose: Pi CLI 的纯工具映射与 fresh/resume argv 构造
+//! contract:
+//!   provides:
+//!     - name: build_pi_command_argv
+//!       what: 仅从已验证输入构造保留 direct Pi 配置的 Team Agent argv
+//! boundary:
+//!   - 不发现 executable、catalog、adapter 或 MCP 配置
+//!   - 除 resume exact backing 存在性外不读文件；不写文件、不启动进程
+//! maturity: wired
+//! ---
+
+use std::path::Path;
+
+use crate::model::enums::ProviderEffort;
+use crate::provider::ProviderError;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum PiToolMapping {
+    Mcp,
+    Builtin(&'static [&'static str]),
+    Unsupported,
+}
+
+/// ---
+/// purpose: 把 Team tool category 映射为 exact Pi builtin/proxy names
+/// returns: 单个或多个 builtin、MCP proxy 或 Unsupported
+/// ---
+pub(crate) fn pi_tool_mapping(category: &str) -> PiToolMapping {
+    match category {
+        "mcp_team" => PiToolMapping::Mcp,
+        "fs_read" => PiToolMapping::Builtin(&["read"]),
+        "fs_list" => PiToolMapping::Builtin(&["grep", "find", "ls"]),
+        "fs_write" => PiToolMapping::Builtin(&["edit", "write"]),
+        "execute_bash" => PiToolMapping::Builtin(&["bash"]),
+        _ => PiToolMapping::Unsupported,
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum PiSessionSelector<'a> {
+    Fresh { session_id: &'a str },
+    Resume { path: &'a Path },
+}
+
+pub(crate) struct PiCommandRequest<'a> {
+    pub executable: &'a Path,
+    pub extension: &'a Path,
+    pub model: Option<&'a str>,
+    pub effort: Option<ProviderEffort>,
+    pub system_prompt: &'a str,
+    pub tool_categories: &'a [&'a str],
+    pub session_dir: &'a Path,
+    pub session: PiSessionSelector<'a>,
+    pub agent_id: &'a str,
+}
+
+/// ---
+/// purpose: 从已验证 semantic request 构造仅追加 Team Agent MCP/提示/session 的 Pi argv
+/// returns: exact ordered fresh/resume argv
+/// errors: 必需字段、mcp_team 或工具 category 非法时返回 ProviderError
+/// ---
+pub(crate) fn build_pi_command_argv(
+    request: PiCommandRequest<'_>,
+) -> Result<Vec<String>, ProviderError> {
+    if request.executable.as_os_str().is_empty()
+        || request.extension.as_os_str().is_empty()
+        || request.session_dir.as_os_str().is_empty()
+        || request.model.is_some_and(|model| model.trim().is_empty())
+        || request.system_prompt.trim().is_empty()
+        || request.agent_id.trim().is_empty()
+    {
+        return Err(ProviderError::Command(
+            "Pi command requires executable, extension, prompt, session directory, and agent id"
+                .to_string(),
+        ));
+    }
+
+    let mut has_mcp = false;
+    for category in request.tool_categories {
+        match pi_tool_mapping(category) {
+            PiToolMapping::Mcp => has_mcp = true,
+            PiToolMapping::Builtin(_) => {}
+            PiToolMapping::Unsupported => {
+                return Err(ProviderError::Command(format!(
+                    "Pi does not support Team Agent tool category {category:?}"
+                )));
+            }
+        }
+    }
+    if !has_mcp {
+        return Err(ProviderError::Command(
+            "Pi command requires mcp_team".to_string(),
+        ));
+    }
+
+    let mut argv = vec![
+        request.executable.to_string_lossy().into_owned(),
+        "-e".to_string(),
+        request.extension.to_string_lossy().into_owned(),
+    ];
+    if let Some(model) = request.model {
+        argv.push("--model".to_string());
+        argv.push(model.to_string());
+    }
+    if let Some(effort) = request.effort {
+        argv.push("--thinking".to_string());
+        argv.push(effort.as_str().to_string());
+    }
+    argv.extend([
+        "--append-system-prompt".to_string(),
+        request.system_prompt.to_string(),
+        "--session-dir".to_string(),
+        request.session_dir.to_string_lossy().into_owned(),
+    ]);
+    // The shared lifecycle materializer always revalidates resume root/path/header.
+    // Keep the pure argv builder usable before a fixture root is materialized, while
+    // refusing a missing exact file once the recorded path's parent exists.
+    match request.session {
+        PiSessionSelector::Fresh { session_id } if !session_id.trim().is_empty() => {
+            argv.push("--session-id".to_string());
+            argv.push(session_id.to_string());
+        }
+        PiSessionSelector::Resume { path }
+            if !path.as_os_str().is_empty()
+                && (!path.parent().is_some_and(Path::is_dir) || path.is_file()) =>
+        {
+            argv.push("--session".to_string());
+            argv.push(path.to_string_lossy().into_owned());
+        }
+        PiSessionSelector::Resume { path } if !path.as_os_str().is_empty() => {
+            return Err(ProviderError::ResumeUnavailable(format!(
+                "Pi exact session backing is missing: {}",
+                path.display()
+            )));
+        }
+        _ => {
+            return Err(ProviderError::Command(
+                "Pi command requires a non-empty session selector".to_string(),
+            ));
+        }
+    }
+    argv.push("--name".to_string());
+    argv.push(request.agent_id.to_string());
+    Ok(argv)
+}

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

@@ -24,6 +24,7 @@ pub(crate) fn provider_bypass_flag(provider: Provider) -> Option<&'static str> {
         Provider::Copilot => Some("--allow-all"),
         Provider::Grok => Some("--always-approve"),
         Provider::CursorAgent => Some("--force"),
+        Provider::Pi => None,
         // TODO: 查 gemini_cli 的等价 bypass 参数;未定义前 fail-loud。
         Provider::GeminiCli => None,
         Provider::Fake => None,

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

@@ -215,7 +215,7 @@ fn latest_explicit_error_fact_for_record(
         Provider::Claude | Provider::ClaudeCode => claude_latest_explicit_error_fact(record),
         // C-3-5 cr verdict: copilot N35 通知不依赖 turn-state 分类;一期 Unknown,
         // 与 GeminiCli/Fake 同精神。二期接 sqlite turns 表后再回填。
-        Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::GeminiCli
+        Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::Pi | Provider::GeminiCli
         | Provider::Fake => None,
     }
 }
@@ -379,7 +379,7 @@ fn extract_lifecycle_facts(
             Provider::Codex => codex_lifecycle_fact(record),
             // C-3-1 cr verdict: copilot lifecycle facts 一期不导出(classify→None,
             // Unknown);二期读 sqlite turns 表(turn_index/assistant_response)。
-            Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::GeminiCli
+            Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::Pi | Provider::GeminiCli
             | Provider::Fake => None,
         })
         .collect()

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

@@ -46,7 +46,7 @@ fn fault_fact(provider: Provider, record: &serde_json::Value) -> Option<FaultFac
     match provider {
         Provider::Claude | Provider::ClaudeCode => claude_fault_fact(record),
         Provider::Codex => codex_fault_fact(record),
-        Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::GeminiCli
+        Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::Pi | Provider::GeminiCli
         | Provider::Fake => None,
     }
 }

package/crates/team-agent/src/provider/session/context_fork.rs

@@ -69,7 +69,7 @@ pub(crate) fn context_fork_convergence_deadline(provider: Provider) -> Duration
     match provider {
         Provider::Claude | Provider::ClaudeCode => Duration::from_secs(45),
         Provider::Codex => Duration::from_secs(10),
-        Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::GeminiCli
+        Provider::Copilot | Provider::Grok | Provider::CursorAgent | Provider::Pi | Provider::GeminiCli
         | Provider::Fake => Duration::from_secs(5),
     }
 }
@@ -252,6 +252,7 @@ fn provider_backing_root(provider: Provider, plan: &CommandPlan) -> PathBuf {
         Provider::Claude | Provider::ClaudeCode => home.join(".claude").join("projects"),
         Provider::Codex => home.join(".codex").join("sessions"),
         Provider::Copilot => home.join(".copilot").join("session-state"),
+        Provider::Pi => PathBuf::new(),
         Provider::Grok | Provider::CursorAgent | Provider::GeminiCli | Provider::Fake => home,
     }
 }

package/crates/team-agent/src/provider/session_scan/common.rs

@@ -122,6 +122,7 @@ pub(super) fn candidate_session_files(
             Provider::Copilot
             | Provider::Grok
             | Provider::CursorAgent
+            | Provider::Pi
             | Provider::GeminiCli
             | Provider::Fake => {}
         }

package/crates/team-agent/src/provider/session_scan/pi.rs

@@ -0,0 +1,172 @@
+//! ---
+//! purpose: 在记录的 Pi 席位 session root 内按真实 header 捕获 exact JSONL backing
+//! contract:
+//!   provides:
+//!     - name: scan_session_store
+//!       what: 只读每个 JSONL 的首个完整 header，并按 id/cwd/spawned_at 返回候选
+//!     - name: validate_exact_backing
+//!       what: restart 前重验 exact path 的 id/cwd header
+//! boundary:
+//!   - 只递归 recorded provider_projects_root，不扫描 HOME 或消息正文
+//!   - 不以文件名、mtime 或唯一文件替代 header 匹配
+//! maturity: wired
+//! ---
+
+use std::io::BufRead;
+use std::path::{Path, PathBuf};
+
+use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
+use crate::provider::ProviderError;
+
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+#[derive(serde::Deserialize)]
+struct PiSessionHeader {
+    #[serde(rename = "type")]
+    record_type: String,
+    version: u64,
+    id: String,
+    cwd: PathBuf,
+    timestamp: String,
+}
+
+fn paths_equal(left: &Path, right: &Path) -> bool {
+    let left = std::fs::canonicalize(left).unwrap_or_else(|_| left.to_path_buf());
+    let right = std::fs::canonicalize(right).unwrap_or_else(|_| right.to_path_buf());
+    left == right
+}
+
+fn read_header(path: &Path) -> Option<PiSessionHeader> {
+    let file = std::fs::File::open(path).ok()?;
+    let mut first_line = String::new();
+    let bytes = std::io::BufReader::new(file)
+        .read_line(&mut first_line)
+        .ok()?;
+    if bytes == 0 || !first_line.ends_with('\n') {
+        return None;
+    }
+    let header: PiSessionHeader = serde_json::from_str(first_line.trim_end()).ok()?;
+    (header.record_type == "session" && header.version == 3).then_some(header)
+}
+
+fn header_matches(
+    header: &PiSessionHeader,
+    expected_session_id: &SessionId,
+    spawn_cwd: &Path,
+    spawned_at: Option<&str>,
+) -> bool {
+    if header.id != expected_session_id.as_str() || !paths_equal(&header.cwd, spawn_cwd) {
+        return false;
+    }
+    let Ok(header_timestamp) = chrono::DateTime::parse_from_rfc3339(&header.timestamp) else {
+        return false;
+    };
+    let Some(spawned_at) = spawned_at else {
+        return true;
+    };
+    let Ok(spawned_at) = chrono::DateTime::parse_from_rfc3339(spawned_at) else {
+        return false;
+    };
+    header_timestamp >= spawned_at
+}
+
+fn collect_jsonl(root: &Path, out: &mut Vec<PathBuf>) -> Result<(), ProviderError> {
+    let entries = std::fs::read_dir(root)
+        .map_err(|error| ProviderError::Io(format!("{}: {error}", root.display())))?;
+    for entry in entries {
+        let entry =
+            entry.map_err(|error| ProviderError::Io(format!("{}: {error}", root.display())))?;
+        let file_type = entry
+            .file_type()
+            .map_err(|error| ProviderError::Io(format!("{}: {error}", entry.path().display())))?;
+        if file_type.is_symlink() {
+            continue;
+        }
+        let path = entry.path();
+        if file_type.is_dir() {
+            collect_jsonl(&path, out)?;
+        } else if file_type.is_file() && path.extension().is_some_and(|ext| ext == "jsonl") {
+            out.push(path);
+        }
+    }
+    Ok(())
+}
+
+/// ---
+/// purpose: restart 前重验调用方给出的 exact Pi JSONL backing
+/// returns: header type/version/id/cwd 全匹配时成功
+/// errors: 文件缺失、header 不完整或 identity 不匹配时返回 ResumeUnavailable
+/// ---
+pub(crate) fn validate_exact_backing(
+    path: &Path,
+    expected_session_id: &SessionId,
+    spawn_cwd: &Path,
+) -> Result<(), ProviderError> {
+    if !path.is_file() {
+        return Err(ProviderError::ResumeUnavailable(format!(
+            "Pi exact session backing is missing: {}",
+            path.display()
+        )));
+    }
+    let header = read_header(path).ok_or_else(|| {
+        ProviderError::ResumeUnavailable(format!(
+            "Pi exact session backing has no complete session header: {}",
+            path.display()
+        ))
+    })?;
+    if !header_matches(&header, expected_session_id, spawn_cwd, None) {
+        return Err(ProviderError::ResumeUnavailable(format!(
+            "Pi exact session backing header does not match id/cwd: {}",
+            path.display()
+        )));
+    }
+    Ok(())
+}
+
+/// ---
+/// purpose: 仅在 recorded seat root 内递归捕获 Pi session header 候选
+/// returns: 每个 id/cwd/timestamp 精确匹配的 JSONL 各返回一个候选
+/// errors: root 内目录枚举失败时返回 ProviderError
+/// ---
+pub(super) fn scan_session_store(
+    context: &CaptureSessionContext,
+) -> Result<Vec<CapturedSessionCandidate>, ProviderError> {
+    let (Some(root), Some(expected_session_id), Some(spawned_at)) = (
+        context.provider_projects_root.as_deref(),
+        context.expected_session_id.as_ref(),
+        context.spawned_at.as_deref(),
+    ) else {
+        return Ok(Vec::new());
+    };
+    if !root.is_dir() {
+        return Ok(Vec::new());
+    }
+
+    let mut paths = Vec::new();
+    collect_jsonl(root, &mut paths)?;
+    paths.sort();
+    Ok(paths
+        .into_iter()
+        .filter_map(|path| {
+            let header = read_header(&path)?;
+            header_matches(
+                &header,
+                expected_session_id,
+                &context.spawn_cwd,
+                Some(spawned_at),
+            )
+            .then(|| CapturedSessionCandidate {
+                captured: CapturedSession {
+                    session_id: Some(expected_session_id.clone()),
+                    rollout_path: Some(RolloutPath::new(path)),
+                    captured_via: CaptureVia::FsWatch,
+                    attribution_confidence: Confidence::High,
+                    spawn_cwd: context.spawn_cwd.clone(),
+                },
+                embedded_agent_id: None,
+                positive_agent_id_match: false,
+                agent_path_match: false,
+            })
+        })
+        .collect())
+}

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

@@ -16,6 +16,7 @@ pub(crate) mod common;
 pub(crate) mod copilot;
 pub(crate) mod cursor;
 pub(crate) mod grok;
+pub(crate) mod pi;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CaptureSessionContext {
@@ -49,6 +50,9 @@ pub(crate) fn scan_session_candidates_once(
     if matches!(provider, Provider::CursorAgent) {
         return Ok(cursor::scan_session_store(context));
     }
+    if matches!(provider, Provider::Pi) {
+        return pi::scan_session_store(context);
+    }
     if matches!(provider, Provider::Claude | Provider::ClaudeCode)
         && context.expected_session_id.is_some()
     {

package/crates/team-agent/src/provider/tests/adapter.rs

@@ -565,3 +565,83 @@ fn test_grok_unknown_tool_mapping_is_explicitly_unsupported() {
         "known tools must stay mapped"
     );
 }
+
+#[test]
+fn pi_wire_roundtrip_requires_backing_and_has_no_builtin_model() {
+    use crate::provider::wire::{
+        aliases, builtin_provider_model, command_name, parse_canonical_provider, parse_provider,
+        provider_wire, requires_resume_backing,
+    };
+
+    let provider = Provider::Pi;
+    assert_eq!(provider_wire(provider), "pi");
+    assert_eq!(parse_provider("pi"), Some(provider));
+    assert_eq!(parse_canonical_provider("pi"), Some(provider));
+    assert_eq!(aliases(provider), &["pi"]);
+    assert_eq!(command_name(provider), "pi");
+    assert!(requires_resume_backing(provider));
+    assert_eq!(builtin_provider_model(provider), None);
+}
+
+#[test]
+fn pi_caps_resume_true_fork_false_native_mcp_false_auth_unknown() {
+    let adapter = get_adapter(Provider::Pi);
+    assert_eq!(
+        adapter.caps(),
+        ProviderCaps {
+            resume: true,
+            fork: false,
+            native_mcp_config: false,
+            writes_global_settings: false,
+        }
+    );
+    assert_eq!(
+        adapter.auth_hint(AuthMode::Subscription),
+        AuthHintStatus::Unknown
+    );
+}
+
+#[test]
+fn pi_fork_is_typed_capability_unsupported() {
+    let adapter = get_adapter(Provider::Pi);
+    let source = SessionId::new("7dcfed9a-88ce-45bf-b1e3-161696acfe89");
+    let result = adapter.fork(Some(&source), AuthMode::Subscription, None);
+    assert!(
+        matches!(result, Err(ProviderError::CapabilityUnsupported(_))),
+        "Pi fork must be a typed capability refusal, got {result:?}"
+    );
+    if let Err(error) = result {
+        let text = error.to_string();
+        assert!(text.contains("pi") && text.contains("fork"), "got {text}");
+        assert!(!text.to_ascii_lowercase().contains("clone"), "got {text}");
+    }
+}
+
+#[test]
+fn pi_classify_has_no_lifecycle_facts() {
+    let transcript = concat!(
+        r#"{"type":"turn_started","turn_id":"turn-1"}"#,
+        "\n",
+        r#"{"type":"turn_completed","turn_id":"turn-1"}"#,
+    );
+    let classified = crate::provider::classify::classify(
+        Provider::Pi,
+        transcript,
+        ProcessLiveness::Alive,
+        60.0,
+    )
+    .expect("Pi classification must preserve unknown without a turn reader");
+    assert_eq!(classified.state, TurnState::Unknown);
+    assert_eq!(classified.reason, "no_turn_lifecycle_fact");
+
+    let records = [serde_json::json!({
+        "type": "system",
+        "subtype": "api_error",
+        "level": "error",
+        "sessionId": "pi-session"
+    })];
+    assert!(
+        crate::provider::faults::read_fault_facts(&records, Provider::Pi).is_empty(),
+        "Pi has no JSONL lifecycle/fault reader"
+    );
+}

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

@@ -36,6 +36,7 @@ pub(crate) fn provider_wire(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini_cli",
         Provider::Grok => "grok",
         Provider::CursorAgent => "cursor_agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }
@@ -83,6 +84,7 @@ pub(crate) fn requires_resume_backing(provider: Provider) -> bool {
             | Provider::Copilot
             | Provider::Grok
             | Provider::CursorAgent
+            | Provider::Pi
     )
 }
 
@@ -95,6 +97,7 @@ pub(crate) fn provider_model_keys(provider: Provider) -> &'static [&'static str]
         Provider::GeminiCli => &["gemini_cli"],
         Provider::Grok => &["grok"],
         Provider::CursorAgent => &["cursor_agent"],
+        Provider::Pi => &["pi"],
         Provider::Fake => &["fake"],
     }
 }
@@ -106,7 +109,7 @@ pub(crate) fn builtin_provider_model(provider: Provider) -> Option<&'static str>
         // grok: compiler 另有缺 model 硬闸，这里的 builtin 不再被 grok 角色吃到。
         // cursor_agent: 禁止隐式默认（本机 shim 会剥 sonnet-4-thinking）；缺 model 编译失败。
         Provider::Grok => Some("grok-4"),
-        Provider::CursorAgent => None,
+        Provider::CursorAgent | Provider::Pi => None,
         Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
     }
 }
@@ -130,6 +133,7 @@ pub(crate) fn aliases(provider: Provider) -> &'static [&'static str] {
         // 是 exec 二进制名, 仅作 alias (不参与 command-text 子串匹配, 见
         // leader/provider_attribution.rs TODO)。
         Provider::CursorAgent => &["cursor_agent", "agent"],
+        Provider::Pi => &["pi"],
         Provider::Fake => &["fake"],
     }
 }
@@ -146,6 +150,7 @@ pub(crate) fn command_name(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini",
         Provider::Grok => "grok",
         Provider::CursorAgent => "agent",
+        Provider::Pi => "pi",
         Provider::Fake => "team-agent",
     }
 }
@@ -158,6 +163,7 @@ const ALL_PROVIDERS: &[Provider] = &[
     Provider::GeminiCli,
     Provider::Grok,
     Provider::CursorAgent,
+    Provider::Pi,
     Provider::Fake,
 ];
 

package/crates/team-agent/src/tmux_backend.rs

@@ -240,6 +240,8 @@ impl TmuxSocketEndpoint {
 pub(crate) enum RuntimeTmuxEndpointSource {
     StateTmuxEndpoint,
     StateTmuxSocket,
+    LeaderReceiverTmuxEndpoint,
+    LeaderReceiverTmuxSocket,
     WorkspaceFallback,
 }
 
@@ -253,6 +255,8 @@ impl RuntimeTmuxEndpointSource {
         match self {
             Self::StateTmuxEndpoint => "state.tmux_endpoint",
             Self::StateTmuxSocket => "state.tmux_socket",
+            Self::LeaderReceiverTmuxEndpoint => "leader_receiver.tmux_endpoint",
+            Self::LeaderReceiverTmuxSocket => "leader_receiver.tmux_socket",
             Self::WorkspaceFallback => "workspace_fallback",
         }
     }
@@ -608,6 +612,50 @@ fn runtime_tmux_endpoint_from_state(
     })
 }
 
+/// ---
+/// purpose: 读取 selected team's persisted leader receiver endpoint
+/// params:
+///   state: 运行期全量或 selected-team 投影 JSON
+/// returns: nested selected receiver 优先，其次投影顶层 receiver；二者都缺则 None
+/// boundary: 只读 owning receiver，不读取普通 tmux_endpoint，不探活
+/// ---
+pub(crate) fn owning_tmux_endpoint_from_state(
+    state: &serde_json::Value,
+) -> Option<(&str, RuntimeTmuxEndpointSource)> {
+    fn receiver_endpoint(state: &serde_json::Value) -> Option<(&str, RuntimeTmuxEndpointSource)> {
+        state
+            .pointer("/leader_receiver/tmux_endpoint")
+            .and_then(serde_json::Value::as_str)
+            .filter(|endpoint| !endpoint.is_empty())
+            .map(|endpoint| {
+                (
+                    endpoint,
+                    RuntimeTmuxEndpointSource::LeaderReceiverTmuxEndpoint,
+                )
+            })
+            .or_else(|| {
+                state
+                    .pointer("/leader_receiver/tmux_socket")
+                    .and_then(serde_json::Value::as_str)
+                    .filter(|endpoint| !endpoint.is_empty())
+                    .map(|endpoint| {
+                        (
+                            endpoint,
+                            RuntimeTmuxEndpointSource::LeaderReceiverTmuxSocket,
+                        )
+                    })
+            })
+    }
+
+    state
+        .get("active_team_key")
+        .and_then(serde_json::Value::as_str)
+        .filter(|team_key| !team_key.is_empty())
+        .and_then(|team_key| state.get("teams").and_then(|teams| teams.get(team_key)))
+        .and_then(receiver_endpoint)
+        .or_else(|| receiver_endpoint(state))
+}
+
 /// CP-1 socket name: SHORT + DETERMINISTIC per canonical workspace path. `ta-` + 12 hex chars of a
 /// stable FNV-1a hash over the canonicalized path. AF_UNIX `sun_path` is ~104 chars and the socket
 /// lives at `/tmp/tmux-<uid>/<name>`, so we must NOT use the (~88-char) session name. §10: a
@@ -651,6 +699,10 @@ pub fn runtime_tmux_endpoint_from_state_pub(
         let src = match source {
             RuntimeTmuxEndpointSource::StateTmuxEndpoint => "state.tmux_endpoint",
             RuntimeTmuxEndpointSource::StateTmuxSocket => "state.tmux_socket",
+            RuntimeTmuxEndpointSource::LeaderReceiverTmuxEndpoint => {
+                "leader_receiver.tmux_endpoint"
+            }
+            RuntimeTmuxEndpointSource::LeaderReceiverTmuxSocket => "leader_receiver.tmux_socket",
             RuntimeTmuxEndpointSource::WorkspaceFallback => "workspace_fallback",
         };
         (endpoint.to_string(), src)

package/package.json

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