@team-agent/installer 0.5.14 → 0.5.15

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.14"
+version = "0.5.15"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.14"
+version = "0.5.15"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -255,6 +255,7 @@ pub(crate) fn start_agent_at_paths(
         Some(&safety),
         layout_placement.as_ref(),
         None,
+        None,
         Some(resolved_team_key.as_str()),
     )?;
     verify_spawned_pane_matches_target(

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -26,6 +26,7 @@ pub(super) fn spawn_agent_window(
     safety: Option<&DangerousApproval>,
     layout_placement: Option<&crate::lifecycle::launch::LayoutPlacement>,
     spawn_cwd_override: Option<&Path>,
+    tmux_endpoint_source: Option<&str>,
     // Issue 2 (Round 3b gate review §6): explicit owner_team_id override.
     // When `Some`, callers (restart/rebuild.rs, restart/agent.rs) thread the
     // resolved `selected.team_key` through here so the worker's MCP env /
@@ -205,6 +206,7 @@ pub(super) fn spawn_agent_window(
         let tmux_start_mode_pre_spawn =
             predict_tmux_start_mode(layout_placement, into_existing_session);
         let spawn_epoch = state_spawn_epoch_for_agent(workspace, agent_id);
+        let tmux_endpoint = transport.tmux_endpoint();
         let event_log = crate::event_log::EventLog::new(workspace);
         let _ = event_log.write(
             "provider.worker.spawn_argv",
@@ -220,6 +222,8 @@ pub(super) fn spawn_agent_window(
                 "tmux_start_mode": tmux_start_mode_pre_spawn,
                 "spawn_epoch": spawn_epoch,
                 "source": "restart",
+                "tmux_endpoint": tmux_endpoint,
+                "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
             }),
         );
     }
@@ -564,6 +568,27 @@ pub(crate) fn lifecycle_worker_transport_for_selected_state(
         .map_err(|e| LifecycleError::TeamSelect(e.to_string()))
 }
 
+pub(super) fn lifecycle_worker_tmux_backend_selection_for_state(
+    run_workspace: &Path,
+    state: &serde_json::Value,
+) -> Result<crate::tmux_backend::RuntimeTmuxBackendSelection, LifecycleError> {
+    if let Some(kind) = state.pointer("/transport/kind").and_then(|v| v.as_str()) {
+        if kind.eq_ignore_ascii_case("conpty") {
+            return Err(LifecycleError::TeamSelect(format!(
+                "backend_kind_mismatch: state.transport.kind={kind:?} but the legacy \
+                 tmux-typed lifecycle resolver was invoked; caller must migrate to \
+                 `lifecycle_worker_transport_for_selected_state` (Phase 1d Batch 2/3)"
+            )));
+        }
+    }
+    Ok(
+        crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+            run_workspace,
+            Some(state),
+        ),
+    )
+}
+
 pub(super) fn lifecycle_worker_tmux_backend_for_state(
     run_workspace: &Path,
     state: &serde_json::Value,

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -23,16 +23,51 @@ pub fn restart_with_session_convergence_deadline(
     team: Option<&str>,
     session_converge_deadline_ms: Option<u64>,
 ) -> Result<RestartReport, LifecycleError> {
-    let paths = lifecycle_paths(workspace, team)?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
-    restart_with_transport_with_session_convergence_deadline(
-        workspace,
+    let context = resolve_restart_context(workspace, team)?;
+    restart_with_selected_team_and_transport(
+        context.selected,
         allow_fresh,
-        team,
-        &transport,
+        &context.transport,
         session_converge_deadline_ms,
         None,
+        Some(context.tmux_endpoint_source),
+    )
+}
+
+struct ResolvedRestartContext {
+    selected: crate::state::selector::SelectedTeam,
+    transport: crate::tmux_backend::TmuxBackend,
+    tmux_endpoint_source: &'static str,
+}
+
+fn resolve_restart_context(
+    workspace: &Path,
+    team: Option<&str>,
+) -> Result<ResolvedRestartContext, LifecycleError> {
+    let resolved_ws = crate::model::paths::canonical_run_workspace(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if crate::lifecycle::restart::input_has_no_local_team_context(&resolved_ws) {
+        return Err(LifecycleError::TeamSelect(format!(
+            "active team spec not found: input_workspace={} expected_runtime_dir={}",
+            workspace.display(),
+            crate::model::paths::runtime_dir(&resolved_ws).display()
+        )));
+    }
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RequireSpec,
     )
+    .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    let transport_selection = lifecycle_worker_tmux_backend_selection_for_state(
+        &selected.run_workspace,
+        &selected.state,
+    )?;
+    Ok(ResolvedRestartContext {
+        selected,
+        transport: transport_selection.backend,
+        tmux_endpoint_source: transport_selection.tmux_endpoint_source.as_str(),
+    })
 }
 
 /// `restart` with an injected transport (tests: recording mock; prod: real TmuxBackend). The Route-B
@@ -129,6 +164,24 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             expected.display()
         )));
     }
+    restart_with_selected_team_and_transport(
+        selected,
+        allow_fresh,
+        transport,
+        session_converge_deadline_ms,
+        readiness_deadline_ms,
+        None,
+    )
+}
+
+fn restart_with_selected_team_and_transport(
+    selected: crate::state::selector::SelectedTeam,
+    allow_fresh: bool,
+    transport: &dyn crate::transport::Transport,
+    session_converge_deadline_ms: Option<u64>,
+    readiness_deadline_ms: Option<u64>,
+    tmux_endpoint_source: Option<&str>,
+) -> Result<RestartReport, LifecycleError> {
     let lifecycle_lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &selected.run_workspace,
         operation: "restart",
@@ -381,6 +434,13 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             &raw_agent,
         );
         if has_endpoint_convergence_marker(&state) && is_fake_model_harness_agent(&agent) {
+            write_fake_harness_spawn_argv_event(
+                &selected.run_workspace,
+                decision,
+                &agent,
+                transport,
+                tmux_endpoint_source,
+            );
             mark_fake_harness_agent_respawned(
                 &mut state,
                 &decision.agent_id,
@@ -438,6 +498,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             Some(&safety),
             layout_placement.as_ref(),
             None,
+            tmux_endpoint_source,
             // Issue 2 (Round 3b gate review §6): thread the resolved
             // selected.team_key so the worker MCP env carries the right
             // owner_team_id even when top-level active_team_key is stale.
@@ -783,7 +844,14 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         restart_readiness_poll_interval(),
     )?;
     let attach_commands =
-        crate::tmux_backend::attach_command_for_session(&selected.run_workspace, &session_name)
+        crate::tmux_backend::attach_command_for_transport_session(transport, &session_name)
+            .or_else(|| {
+                crate::tmux_backend::attach_command_for_runtime_state_session_or_workspace(
+                    &selected.run_workspace,
+                    Some(&state),
+                    &session_name,
+                )
+            })
             .into_iter()
             .collect::<Vec<_>>();
     let mut next_actions = Vec::new();
@@ -1719,6 +1787,29 @@ fn mark_fake_harness_agent_respawned(
     agent.insert("owner_team_id".to_string(), serde_json::json!(team_key));
 }
 
+fn write_fake_harness_spawn_argv_event(
+    workspace: &Path,
+    decision: &RestartedAgent,
+    agent: &serde_json::Value,
+    transport: &dyn crate::transport::Transport,
+    tmux_endpoint_source: Option<&str>,
+) {
+    let _ = crate::event_log::EventLog::new(workspace).write(
+        "provider.worker.spawn_argv",
+        serde_json::json!({
+            "agent_id": decision.agent_id.as_str(),
+            "provider": agent_provider(agent),
+            "argv": [],
+            "session_id_in_argv": null,
+            "expected_session_id": decision.session_id.as_ref().map(|s| s.as_str()),
+            "tmux_start_mode": "fake_harness",
+            "source": "restart",
+            "tmux_endpoint": transport.tmux_endpoint(),
+            "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
+        }),
+    );
+}
+
 fn restart_failed_agent(
     decision: &RestartedAgent,
     phase: impl Into<String>,

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -524,7 +524,7 @@ fn normalize_string(text: String, ctx: &mut NormalizeCtx, key: Option<&str>) ->
     if key_is_timestamp(key) {
         return json!("<TS>");
     }
-    if key.contains("endpoint") {
+    if key.contains("endpoint") && value_looks_like_endpoint_path(&text) {
         return json!("<SOCKET>");
     }
     if key_is_id(key, &text) {
@@ -557,6 +557,13 @@ fn normalize_path_string(text: &str, ctx: &NormalizeCtx) -> String {
     normalize_socket_token(&out)
 }
 
+fn value_looks_like_endpoint_path(text: &str) -> bool {
+    text.starts_with('/')
+        || text.starts_with("ta-")
+        || text.contains("/tmux-")
+        || text.contains("tmux-")
+}
+
 fn normalize_team_agent_binary_path(text: &str) -> String {
     let mut out = text.to_string();
     // 0.5.0 hermetic 教训「环境路径类 token 化」的直接延伸

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

@@ -566,6 +566,14 @@ pub(crate) fn attach_command_for_session(
     ))
 }
 
+pub(crate) fn attach_command_for_transport_session(
+    transport: &dyn crate::transport::Transport,
+    session_name: &SessionName,
+) -> Option<String> {
+    let endpoint = transport.tmux_endpoint()?;
+    Some(attach_command_for_endpoint_session(&endpoint, session_name))
+}
+
 /// Bug #7 (prerelease 0.4.0 gate review §6): when the runtime state carries a
 /// persisted `tmux_endpoint` / `tmux_socket` (e.g. `/private/tmp/tmux-501/default`),
 /// the attach command MUST point at THAT endpoint, not the workspace-hash
@@ -591,6 +599,26 @@ pub(crate) fn attach_command_for_runtime_state_or_workspace(
     attach_command_for_workspace(workspace, session_name, window_name)
 }
 
+pub(crate) fn attach_command_for_runtime_state_session_or_workspace(
+    workspace: &Path,
+    state: Option<&serde_json::Value>,
+    session_name: &SessionName,
+) -> Option<String> {
+    if let Some((endpoint, _source)) = runtime_tmux_endpoint_from_state(state) {
+        return Some(attach_command_for_endpoint_session(endpoint, session_name));
+    }
+    attach_command_for_session(workspace, session_name)
+}
+
+fn attach_command_for_endpoint_session(endpoint: &str, session_name: &SessionName) -> String {
+    let flag = if Path::new(endpoint).is_absolute() {
+        "-S"
+    } else {
+        "-L"
+    };
+    format!("tmux {flag} {endpoint} attach -t {}", session_name.as_str())
+}
+
 pub(crate) fn attach_commands_for_windows<'a>(
     workspace: &Path,
     session_name: &SessionName,

package/package.json

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