@team-agent/installer 0.5.50 → 0.5.52

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.50"
+version = "0.5.52"
 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.50"
+version = "0.5.52"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -841,8 +841,8 @@ fn provider_command(provider: &str) -> &str {
 }
 
 fn seed_fake_e2e_state(workspace: &Path) -> Result<(), CliError> {
-    crate::state::persist::save_runtime_state(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::FakeE2eSeed,
         &json!({
             "leader": {"id": "leader"},
             "session_name": "team-agent-fake-e2e",
@@ -876,7 +876,8 @@ fn fake_shutdown(workspace: &Path) -> Result<Value, CliError> {
             }
         }
     }
-    crate::state::persist::save_runtime_state(workspace, &state)?;
+    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),
@@ -1353,6 +1354,7 @@ pub fn cmd_add_agent(args: &AddAgentArgs) -> Result<CmdResult, CliError> {
             &args.role_file,
             !args.no_display,
             args.team.as_deref(),
+            args.force,
         )?,
         args.json,
     ))

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

@@ -329,7 +329,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("reset-agent") => "usage: team-agent reset-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--no-display] [--json]".to_string(),
         Some("start-agent") => "usage: team-agent start-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--force] [--allow-fresh] [--no-display] [--json]".to_string(),
         Some("stop-agent") => "usage: team-agent stop-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("add-agent") => "usage: team-agent add-agent AGENT --role-file FILE [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
+        Some("add-agent") => "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
         Some("fork-agent") => "usage: team-agent fork-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
         Some("remove-agent") => "usage: team-agent remove-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--from-spec] [--confirm] [--force] [--json]".to_string(),
         // 0.5.26 (§7.6): removed from help; dispatch was never wired.
@@ -1345,6 +1345,7 @@ fn add_agent_args(args: &[String], cwd: &Path) -> Result<AddAgentArgs, CliError>
         role_file: parsed
             .role_file
             .ok_or_else(|| CliError::Usage("missing --role-file".to_string()))?,
+        force: parsed.force,
         no_display: parsed.no_display,
         json: parsed.json,
     })

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

@@ -884,7 +884,13 @@ pub mod lifecycle_port {
             if session_killed && !verification_degraded {
                 mark_active_team_shutdown(&mut state, team_shutdown_status);
             }
-            crate::state::projection::save_team_scoped_state(&run_workspace, &state)?;
+            crate::state::repository::StateRepository::new(&run_workspace).save(
+                crate::state::repository::StateWriteIntent::ShutdownTeam {
+                    team_key: team,
+                    clean: session_killed && !verification_degraded,
+                },
+                &state,
+            )?;
             promote_live_sibling_after_scoped_shutdown(&run_workspace, &state)?;
         } else {
             let _changed_keys = mark_matching_session_teams_stopped(
@@ -893,7 +899,13 @@ pub mod lifecycle_port {
                 session_killed && !verification_degraded,
                 team_shutdown_status,
             );
-            crate::state::persist::save_runtime_state(&run_workspace, &state)?;
+            crate::state::repository::StateRepository::new(&run_workspace).save(
+                crate::state::repository::StateWriteIntent::ShutdownTeam {
+                    team_key: None,
+                    clean: session_killed && !verification_degraded,
+                },
+                &state,
+            )?;
         }
         let coordinator_status = if coordinator_timeout {
             "timeout"
@@ -2310,14 +2322,16 @@ pub mod lifecycle_port {
         role_file: &str,
         open_display: bool,
         team: Option<&str>,
+        force: bool,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
-        match crate::lifecycle::add_agent(
+        match crate::lifecycle::add_agent_force(
             workspace,
             &agent_id,
             Path::new(role_file),
             open_display,
             team,
+            force,
         ) {
             Ok(report) => Ok(json!({
                 "ok": true,
@@ -2372,7 +2386,7 @@ pub mod lifecycle_port {
                     ));
                 }
             }
-            Err(error) if confirm => return Ok(error_value(error)),
+            Err(error) if confirm && !force => return Ok(error_value(error)),
             Err(_) => {}
         }
         if !confirm {
@@ -2548,7 +2562,13 @@ pub mod lifecycle_port {
             .and_then(|agents| agents.keys().next().cloned())
             .map(Value::String)
             .unwrap_or(Value::Null);
-        crate::state::persist::save_runtime_state(workspace, &state)
+        crate::state::repository::StateRepository::new(workspace)
+            .save(
+                crate::state::repository::StateWriteIntent::IdleAck {
+                    team_key: Some(&team),
+                },
+                &state,
+            )
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         crate::event_log::EventLog::new(workspace)
             .write(
@@ -3553,7 +3573,13 @@ pub mod lifecycle_port {
             return Ok(());
         };
         let promoted = crate::state::projection::project_top_level_view(&raw, next_key);
-        crate::state::persist::save_runtime_state(workspace, &promoted)?;
+        crate::state::repository::StateRepository::new(workspace).save(
+            crate::state::repository::StateWriteIntent::PromoteLiveSiblingAfterShutdown {
+                stopped_team_key: stopped_key,
+                promoted_team_key: next_key,
+            },
+            &promoted,
+        )?;
         Ok(())
     }
 
@@ -3966,14 +3992,6 @@ pub mod diagnose_port {
         format!("{:012x}", now & 0xffffffffffff)
     }
 
-    fn read_runtime_state(workspace: &Path) -> Value {
-        let path = workspace.join(".team").join("runtime").join("state.json");
-        std::fs::read_to_string(path)
-            .ok()
-            .and_then(|s| serde_json::from_str(&s).ok())
-            .unwrap_or_else(|| json!({}))
-    }
-
     fn which_path(binary: &str) -> Option<String> {
         let path = std::env::var_os("PATH")?;
         for dir in std::env::split_paths(&path) {

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

@@ -505,57 +505,20 @@ enum ParsedTarget {
 }
 
 fn parse_named_address(raw_name: &str) -> Result<ParsedNamedAddress, NamedAddressError> {
-    let raw = raw_name.trim();
-    if raw.is_empty() {
-        return Err(name_invalid("name is empty"));
-    }
-    let (workspace, name) = if let Some((workspace, rest)) = raw.split_once("::") {
-        if workspace.trim().is_empty() || rest.trim().is_empty() {
-            return Err(name_invalid(
-                "workspace-qualified name must include workspace and target",
-            ));
-        }
-        (Some(PathBuf::from(workspace)), rest.trim())
-    } else {
-        (None, raw)
-    };
-
-    if name.contains("//") {
-        return Err(name_invalid("name contains an empty path segment"));
-    }
-
-    let target = if name.contains('/') {
-        let parts = name.split('/').collect::<Vec<_>>();
-        if parts.len() != 2 || !valid_component(parts[0]) || !valid_component(parts[1]) {
-            return Err(name_invalid("expected <team>/<agent> or <team>/leader"));
-        }
-        ParsedTarget::TeamEntity {
-            team: parts[0].to_string(),
-            entity: parts[1].to_string(),
-        }
-    } else if name.contains(':') {
-        let parts = name.split(':').collect::<Vec<_>>();
-        if parts.len() != 2 || parts[0].trim().is_empty() || parts[1].trim().is_empty() {
-            return Err(name_invalid("expected <session>:<window>"));
+    let parsed = crate::messaging::parse_logical_address(raw_name).map_err(name_invalid)?;
+    let target = match parsed.target {
+        crate::messaging::LogicalAddressTarget::Worker(agent) => ParsedTarget::BareAgent(agent),
+        crate::messaging::LogicalAddressTarget::TeamEntity { team, entity } => {
+            ParsedTarget::TeamEntity { team, entity }
         }
-        ParsedTarget::SessionWindow {
-            session: parts[0].to_string(),
-            window: parts[1].to_string(),
+        crate::messaging::LogicalAddressTarget::SessionWindow { session, window } => {
+            ParsedTarget::SessionWindow { session, window }
         }
-    } else {
-        if !valid_component(name) {
-            return Err(name_invalid("expected a non-empty agent id"));
-        }
-        ParsedTarget::BareAgent(name.to_string())
     };
-    Ok(ParsedNamedAddress { workspace, target })
-}
-
-fn valid_component(raw: &str) -> bool {
-    !raw.trim().is_empty()
-        && !raw.contains(char::is_whitespace)
-        && !raw.contains('/')
-        && !raw.contains(':')
+    Ok(ParsedNamedAddress {
+        workspace: parsed.workspace,
+        target,
+    })
 }
 
 fn resolve_workspace(
@@ -976,103 +939,71 @@ fn resolve_leader(
         );
         return Err(err);
     }
-    if crate::codex_app_server::receiver_is_app_server(receiver) {
-        return resolve_app_server_leader(
-            sender_workspace,
-            target_workspace,
-            team,
-            parsed,
-            receiver,
-        );
-    }
-    let pane_id = string_field(receiver, "pane_id")
-        .filter(|pane| !pane.is_empty())
-        .ok_or_else(|| {
-            let mut err = leader_not_attached_third_party(
-                target_workspace,
-                team,
-                None,
-                None,
-                None,
-                transport.tmux_endpoint(),
-            );
-            err.candidates =
-                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
-            err
-        })?;
     let session = string_field(receiver, "session_name");
     let window = string_field(receiver, "window_name");
     let socket = string_field(receiver, "tmux_socket")
         .map(str::to_string)
         .or_else(|| transport.tmux_endpoint());
-    let targets = list_targets(transport)?;
-    let matches = targets
-        .iter()
-        .filter(|target| {
-            target.pane_id.as_str() == pane_id
-                && session.is_none_or(|expected| target.session.as_str() == expected)
-                && window.is_none_or(|expected| {
-                    target
-                        .window_name
-                        .as_ref()
-                        .is_some_and(|name| name.as_str() == expected)
-                })
-        })
-        .collect::<Vec<_>>();
-    let stale_pane_seen = targets
-        .iter()
-        .any(|target| target.pane_id.as_str() == pane_id);
-    match matches.len() {
-        1 => Ok(ResolvedNamedAddress {
+    match crate::messaging::resolve_live_leader_channel(
+        target_workspace,
+        receiver,
+        transport,
+    ) {
+        crate::messaging::LeaderChannelResolution::Live(
+            crate::messaging::LiveLeaderChannel::DirectTmux(channel),
+        ) => Ok(ResolvedNamedAddress {
             raw_name: parsed.display_name(),
             target_kind: NamedTargetKind::Leader,
             sender_workspace: sender_workspace.to_path_buf(),
             target_workspace: target_workspace.to_path_buf(),
             team_key: Some(team.to_string()),
             agent_id: None,
-            pane_id: pane_id.to_string(),
+            pane_id: channel.pane_id.clone(),
             session_name: session.map(str::to_string),
             window_name: window.map(str::to_string),
             tmux_endpoint: socket,
             transport_kind: Some("direct_tmux".to_string()),
             app_server: None,
-            state_pane_id: Some(pane_id.to_string()),
+            state_pane_id: Some(channel.pane_id),
             state_pane_stale: false,
             agent_status: None,
-            warning: None,
+            warning: (!channel.metadata_drift.is_empty()).then(|| {
+                format!(
+                    "leader_channel_metadata_drift:{}",
+                    channel.metadata_drift.join(",")
+                )
+            }),
         }),
-        0 => {
+        crate::messaging::LeaderChannelResolution::Live(
+            crate::messaging::LiveLeaderChannel::CodexAppServer(_),
+        ) => resolve_app_server_leader(sender_workspace, target_workspace, team, parsed, receiver),
+        crate::messaging::LeaderChannelResolution::Unbound(reason) => {
+            let pane_id = string_field(receiver, "pane_id");
             let mut err = leader_not_attached_third_party(
                 target_workspace,
                 team,
-                Some(pane_id),
+                pane_id,
                 session,
                 window,
                 socket,
             );
-            if stale_pane_seen {
-                err.log = format!("{} stale_tuple_mismatch=true", err.log);
-            }
+            err.log = format!("{} channel_unbound={reason:?}", err.log);
             err.candidates =
                 leader_advisory_candidates(state, team, transport, "state_recorded_socket");
             Err(err)
         }
-        _ => Err(name_ambiguous(
-            "multiple live panes matched leader_receiver pane id",
-            matches
-                .into_iter()
-                .map(|pane| {
-                    json!({
-                        "name": format!("{team}/leader"),
-                        "workspace": target_workspace.display().to_string(),
-                        "team_key": team,
-                        "pane_id": pane.pane_id.as_str(),
-                        "session": pane.session.as_str(),
-                        "window": pane.window_name.as_ref().map(|w| w.as_str()),
-                    })
-                })
-                .collect(),
-        )),
+        crate::messaging::LeaderChannelResolution::ProbeFailed(error) => {
+            let mut err = leader_not_attached_third_party(
+                target_workspace,
+                team,
+                string_field(receiver, "pane_id"),
+                session,
+                window,
+                socket,
+            );
+            err.log = format!("{} channel_probe_failed={error}", err.log);
+            Err(err)
+        }
     }
 }
 

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

@@ -0,0 +1,163 @@
+use super::*;
+
+pub(super) fn dirty_topology_refusal_value(
+    selected: &crate::state::selector::SelectedTeam,
+    requested_team: Option<&str>,
+) -> Option<Value> {
+    let issue_ids = crate::topology::restart_dirty_topology_issue_ids(&selected.state);
+    if issue_ids.is_empty() {
+        return None;
+    }
+    let session_name = selected
+        .state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .unwrap_or_default()
+        .to_string();
+    let reason = issue_ids
+        .first()
+        .cloned()
+        .unwrap_or_else(|| "dirty_topology".to_string());
+    let repair_team = requested_team
+        .filter(|team| !team.is_empty())
+        .unwrap_or(selected.team_key.as_str());
+    Some(json!({
+        "ok": false,
+        "status": "refused_dirty_topology",
+        "reason": reason,
+        "session_name": session_name,
+        "error": "send refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before sending",
+        "issues": issue_ids
+            .iter()
+            .map(|id| json!({"id": id}))
+            .collect::<Vec<_>>(),
+        "next_actions": [
+            "team-agent diagnose --json",
+            format!("team-agent claim-leader --team {repair_team} --confirm --json"),
+            format!("team-agent takeover --team {repair_team} --confirm --json")
+        ],
+    }))
+}
+
+pub(super) fn target_has_known_worker(state: &Value, target: &MessageTarget, sender: &str) -> bool {
+    let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+        return false;
+    };
+    match target {
+        MessageTarget::Single(target) => agents.contains_key(target),
+        MessageTarget::Broadcast => agents.keys().any(|agent| agent != sender),
+        MessageTarget::Fanout(recipients) => recipients
+            .iter()
+            .any(|recipient| agents.contains_key(recipient)),
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct LoudEnsureResult {
+    previous_status: String,
+    start: crate::coordinator::StartReport,
+}
+
+pub(super) fn loud_ensure_coordinator(
+    selected: &crate::state::selector::SelectedTeam,
+) -> Result<Option<LoudEnsureResult>, CliError> {
+    if in_process_unit_test() {
+        return Ok(None);
+    }
+    let workspace = crate::coordinator::WorkspacePath::new(selected.run_workspace.clone());
+    let previous = crate::coordinator::coordinator_health(&workspace);
+    if previous.ok {
+        return Ok(None);
+    }
+    if previous.service_available
+        && matches!(
+            previous.binary_identity_relation,
+            crate::coordinator::CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller
+        )
+    {
+        return Ok(None);
+    }
+    let previous_status = coordinator_health_status_wire(previous.status).to_string();
+    let start = crate::coordinator::start_coordinator_with_team(
+        &workspace,
+        Some(selected.team_key.as_str()),
+    )
+    .map_err(|error| CliError::Runtime(error.to_string()))?;
+    if !start.ok {
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    if matches!(
+        start.status,
+        crate::coordinator::StartOutcome::Started
+            | crate::coordinator::StartOutcome::StartedAfterRotation
+    ) {
+        crate::event_log::EventLog::new(&selected.run_workspace)
+            .write(
+                "coordinator.ensure_restarted",
+                json!({
+                    "coordinator_previous_status": previous_status,
+                    "status": start.status,
+                    "pid": start.pid.map(|pid| pid.get()),
+                    "previous_pid": start.previous_pid.map(|pid| pid.get()),
+                    "binary_path": start.binary_path,
+                    "binary_version": start.binary_version,
+                    "rotation_reason": start.rotation_reason,
+                }),
+            )
+            .map_err(|error| CliError::Runtime(error.to_string()))?;
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    Ok(None)
+}
+
+#[cfg(test)]
+pub(super) fn in_process_unit_test() -> bool {
+    true
+}
+
+#[cfg(not(test))]
+pub(super) fn in_process_unit_test() -> bool {
+    false
+}
+
+pub(super) fn append_loud_ensure_fields(value: &mut Value, ensure: Option<&LoudEnsureResult>) {
+    let Some(ensure) = ensure else {
+        return;
+    };
+    if !ensure.start.ok {
+        return;
+    }
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("coordinator_auto_restarted".to_string(), json!(true));
+        obj.insert(
+            "coordinator_previous_status".to_string(),
+            json!(ensure.previous_status),
+        );
+        obj.insert(
+            "coordinator".to_string(),
+            coordinator_start_json(&ensure.start),
+        );
+    }
+}
+
+pub(super) fn coordinator_start_json(report: &crate::coordinator::StartReport) -> Value {
+    let summary = crate::lifecycle::CoordinatorStartSummary::from_start_report(report);
+    crate::lifecycle::coordinator_start_summary_value(&summary)
+}
+
+pub(super) fn coordinator_health_status_wire(
+    status: crate::coordinator::CoordinatorHealthStatus,
+) -> &'static str {
+    match status {
+        crate::coordinator::CoordinatorHealthStatus::Missing => "missing",
+        crate::coordinator::CoordinatorHealthStatus::InvalidPid => "invalid_pid",
+        crate::coordinator::CoordinatorHealthStatus::Running => "running",
+        crate::coordinator::CoordinatorHealthStatus::Stale => "stale",
+    }
+}

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

@@ -0,0 +1,99 @@
+use super::*;
+
+pub(super) fn maybe_enqueue_offline_leader_mailbox(
+    sender_workspace: &Path,
+    to_name: &str,
+    content: &str,
+    sender: &str,
+    task_id: Option<&str>,
+    error: &crate::cli::named_address::NamedAddressError,
+) -> Result<Option<Value>, CliError> {
+    if error.kind != crate::cli::named_address::NamedAddressErrorKind::LeaderNotAttached {
+        return Ok(None);
+    }
+    let parsed = match crate::cli::named_address::parse_leader_target_workspace_and_team(
+        sender_workspace,
+        to_name,
+    ) {
+        Ok(Some(v)) => v,
+        Ok(None) => return Ok(None),
+        Err(_) => return Ok(None),
+    };
+    let (target_workspace, team_key) = parsed;
+    // Owner-scope refusal: sender workspace == target workspace. Keep
+    // the actionable attach hint (owner sees status/diagnose copy that
+    // points at `attach-leader`).
+    let sender_canonical =
+        std::fs::canonicalize(sender_workspace).unwrap_or_else(|_| sender_workspace.to_path_buf());
+    let target_canonical =
+        std::fs::canonicalize(&target_workspace).unwrap_or_else(|_| target_workspace.clone());
+    if sender_canonical == target_canonical {
+        return Ok(None);
+    }
+    // Verify the target team is actually alive on this host — mailbox
+    // is only for `team live + leader unattached`. Fail-closed otherwise
+    // so we never leave a message in a permanently-dead workspace's DB.
+    let state = match crate::state::persist::load_runtime_state(&target_workspace) {
+        Ok(s) => s,
+        Err(_) => return Ok(None),
+    };
+    let team_alive = target_team_is_alive_for_mailbox(&state, &team_key);
+    if !team_alive {
+        return Ok(None);
+    }
+    let event_log = crate::event_log::EventLog::new(&target_workspace);
+    let task = task_id.map(|s| crate::model::ids::TaskId::new(s.to_string()));
+    let outcome = messaging::enqueue_leader_mailbox_until_attach(
+        &target_workspace,
+        &team_key,
+        content,
+        task.as_ref(),
+        sender,
+        &event_log,
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let message_id = outcome.message_id.clone().unwrap_or_else(|| "".to_string());
+    Ok(Some(json!({
+        "ok": true,
+        "status": "queued_until_leader_attach",
+        "message_status": "queued_until_leader_attach",
+        "channel": "leader_mailbox",
+        "delivered": false,
+        "to_name": to_name,
+        "target_workspace": target_workspace.display().to_string(),
+        "team_key": team_key,
+        "recipient": "leader",
+        "leader_attached": false,
+        "message_id": message_id,
+    })))
+}
+
+/// Positive-source liveness heuristic per offline-mailbox-toname-design.md §4:
+/// - target workspace has state and the team key is present + not archived/down;
+/// - AND at least one live tmux fact — a persisted `session_name` OR any
+///   agent with a recorded pane on the recorded socket.
+///
+/// We deliberately do NOT poll coordinator health here — enqueuing is
+/// safe even when the coordinator is transiently down; attach-leader
+/// itself replays via `requeue_blocked_leader_messages` regardless.
+pub(super) fn target_team_is_alive_for_mailbox(state: &Value, team_key: &str) -> bool {
+    let team = state
+        .get("teams")
+        .and_then(|v| v.as_object())
+        .and_then(|teams| teams.get(team_key));
+    let Some(team) = team else {
+        return false;
+    };
+    let status = team
+        .get("status")
+        .and_then(|v| v.as_str())
+        .unwrap_or("alive");
+    if matches!(status, "archived" | "down" | "stopped") {
+        return false;
+    }
+    // A recorded session_name is enough — target's coordinator/attach
+    // path will re-verify tmux presence when the replay fires.
+    team.get("session_name")
+        .and_then(|v| v.as_str())
+        .is_some_and(|s| !s.is_empty())
+}