@team-agent/installer 0.5.8 → 0.5.10

package/Cargo.lock

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

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

@@ -5,12 +5,93 @@ use super::*;
 pub fn cmd_attach_app_server_leader(
     args: &AttachAppServerLeaderArgs,
 ) -> Result<CmdResult, CliError> {
-    let value = crate::leader::attach_app_server_leader(
+    let mut value = crate::leader::attach_app_server_leader(
         &args.workspace,
         args.team.as_deref(),
         &args.socket,
         &args.thread_id,
     )
     .map_err(|error| CliError::Runtime(error.to_string()))?;
+    // E7 register-after-success (host-leader-registry-design §8.4): mirror
+    // the tmux binding flow so app-server bindings appear in the host
+    // discovery index too. Registry write failure is discoverability
+    // degradation, not binding failure.
+    if value.get("ok").and_then(serde_json::Value::as_bool) == Some(true) {
+        register_app_server_binding_in_registry(&args.workspace, args.team.as_deref(), &mut value);
+    }
     Ok(CmdResult::from_json(value, args.json))
 }
+
+fn register_app_server_binding_in_registry(
+    workspace: &std::path::Path,
+    team: Option<&str>,
+    response: &mut serde_json::Value,
+) {
+    let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+        return;
+    };
+    let team_key = match team.filter(|t| !t.is_empty()) {
+        Some(t) => t.to_string(),
+        None => crate::state::projection::team_state_key(&state),
+    };
+    let receiver = state
+        .get("teams")
+        .and_then(|v| v.as_object())
+        .and_then(|teams| teams.get(&team_key))
+        .and_then(|t| t.get("leader_receiver"))
+        .cloned();
+    let Some(receiver) = receiver else {
+        return;
+    };
+    let transport_kind = receiver
+        .get("transport_kind")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("codex_app_server")
+        .to_string();
+    let channel = receiver
+        .get("app_server")
+        .cloned()
+        .unwrap_or(serde_json::Value::Null);
+    let owner_epoch = receiver
+        .get("owner_epoch")
+        .and_then(serde_json::Value::as_u64)
+        .unwrap_or(0);
+    let entry = crate::leader::registry::build_entry(
+        workspace,
+        &team_key,
+        &transport_kind,
+        channel,
+        owner_epoch,
+        "attach-app-server-leader",
+        chrono::Utc::now().to_rfc3339(),
+    );
+    let event_log = crate::event_log::EventLog::new(workspace);
+    let write_result = crate::leader::registry::write_entry_best_effort(&entry);
+    let registry_status = match &write_result {
+        Some(path) => {
+            let _ = event_log.write(
+                crate::leader::registry::EVENT_REGISTERED,
+                serde_json::json!({
+                    "path": path.display().to_string(),
+                    "team_key": team_key,
+                    "workspace_hash": entry.workspace_hash,
+                    "source": "attach-app-server-leader",
+                }),
+            );
+            serde_json::json!({"status": "registered", "path": path.display().to_string()})
+        }
+        None => {
+            let _ = event_log.write(
+                crate::leader::registry::EVENT_WRITE_FAILED,
+                serde_json::json!({
+                    "team_key": team_key,
+                    "source": "attach-app-server-leader",
+                }),
+            );
+            serde_json::json!({"status": "write_failed"})
+        }
+    };
+    if let Some(obj) = response.as_object_mut() {
+        obj.insert("leader_registry".to_string(), registry_status);
+    }
+}

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

@@ -122,6 +122,14 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "doctor" => cmd_doctor(&doctor_args(args, cwd)).map(emit_result),
         "watch" => cmd_watch(&watch_args(args, cwd)).map(emit_result),
         "sessions" => cmd_sessions(&sessions_args(args, cwd)).map(emit_result),
+        // 0.5.9 E7 host-leader-registry: `leaders` is the host-level derived
+        // discovery command. It reads ~/.team-agent/leaders, validates each
+        // entry against canonical state, and reports LIVE/STALE/AMBIGUOUS
+        // status. `--to-leader NAME` on `send` uses the same registry to
+        // resolve short/qualified/hash-qualified names to a canonical
+        // (workspace, team_key) tuple and delegates to the E6 named-leader
+        // delivery path — no separate route authority.
+        "leaders" => cmd_leaders(&leaders_args(args, cwd)).map(emit_result),
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
         "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
@@ -178,6 +186,8 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "doctor",
     "watch",
     "sessions",
+    // 0.5.9 E7: host leader discovery command surface.
+    "leaders",
     "validate",
     "install-skill",
     "profile",
@@ -692,6 +702,11 @@ struct ParsedArgs {
     auth_mode: Option<String>,
     pane: Option<String>,
     to_name: Option<String>,
+    /// E7 (0.5.9 host-leader-registry-design §4.2): `send --to-leader NAME`
+    /// resolves NAME through `~/.team-agent/leaders` to a canonical target
+    /// (workspace, team_key) then delegates to the E6 leader delivery path.
+    /// Mutually exclusive with `--to-name`, TARGET, `--pane`, and `--to`.
+    to_leader: Option<String>,
     provider: Option<String>,
     socket: Option<String>,
     thread_id: Option<String>,
@@ -782,6 +797,7 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--auth-mode" => parsed.auth_mode = next_arg(args, &mut i),
             "--pane" => parsed.pane = next_arg(args, &mut i),
             "--to-name" => parsed.to_name = next_arg(args, &mut i),
+            "--to-leader" => parsed.to_leader = next_arg(args, &mut i),
             "--provider" => parsed.provider = next_arg(args, &mut i),
             "--socket" => parsed.socket = next_arg(args, &mut i),
             "--thread-id" => parsed.thread_id = next_arg(args, &mut i),
@@ -799,6 +815,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             other if other.starts_with("--to-name=") => {
                 parsed.to_name = Some(other.trim_start_matches("--to-name=").to_string());
             }
+            other if other.starts_with("--to-leader=") => {
+                parsed.to_leader = Some(other.trim_start_matches("--to-leader=").to_string());
+            }
             other if other.starts_with("--provider=") => {
                 parsed.provider = Some(other.trim_start_matches("--provider=").to_string());
             }
@@ -933,7 +952,11 @@ fn resolve_cli_path(cwd: &Path, path: &Path) -> PathBuf {
 
 fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     let parsed = parse_args(args);
-    let target = if parsed.targets.is_some() || parsed.pane.is_some() || parsed.to_name.is_some() {
+    let target = if parsed.targets.is_some()
+        || parsed.pane.is_some()
+        || parsed.to_name.is_some()
+        || parsed.to_leader.is_some()
+    {
         None
     } else {
         parsed.positionals.first().cloned()
@@ -962,6 +985,7 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
         message_id: parsed.message_id,
         pane: parsed.pane.clone(),
         to_name: parsed.to_name.clone(),
+        to_leader: parsed.to_leader.clone(),
     })
 }
 
@@ -1351,6 +1375,11 @@ fn sessions_args(args: &[String], cwd: &Path) -> SessionsArgs {
     }
 }
 
+fn leaders_args(args: &[String], _cwd: &Path) -> LeadersArgs {
+    let parsed = parse_args(args);
+    LeadersArgs { json: parsed.json }
+}
+
 fn validate_args(args: &[String], cwd: &Path) -> ValidateArgs {
     let parsed = parse_args(args);
     ValidateArgs {

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

@@ -0,0 +1,94 @@
+//! E7 (0.5.9 host-leader-registry-design §4.1): `team-agent leaders` command.
+//!
+//! Enumerates entries under `~/.team-agent/leaders`, re-validates each
+//! against the target workspace's canonical runtime state, and emits a
+//! LIVE / STALE / AMBIGUOUS classification. Leaders-only — worker rows,
+//! task rows, and result rows are deliberately absent from the output.
+//!
+//! The command is a **discovery** surface, not a route authority. Callers
+//! that consume `send_hint` must still re-validate via
+//! `named_address::resolve_name_for_cli` before delivery — this file only
+//! reports what registry sees now.
+
+use super::{types::LeadersArgs, CliError, CmdResult};
+use serde_json::{json, Value};
+
+/// E7 CLI entry point (E7 test 2 marker: `cmd_leaders`).
+///
+/// Reads registry entries, canonical-validates each, and groups by
+/// delivery_name to classify each as LIVE / STALE / AMBIGUOUS. Terminal
+/// stale entries (canonical workspace/team gone) are pruned as GC side
+/// effect. Leader-detached-but-team-alive stays visible as STALE so the
+/// operator can decide.
+pub fn cmd_leaders(args: &LeadersArgs) -> Result<CmdResult, CliError> {
+    let dir = crate::leader::registry::registry_dir()
+        .map(|p| p.display().to_string())
+        .unwrap_or_else(|| "~/.team-agent/leaders".to_string());
+    let classified = crate::leader::registry::list_validated_with_gc();
+    let mut name_counts: std::collections::HashMap<String, Vec<Value>> =
+        std::collections::HashMap::new();
+    for (entry, _status, _reason) in &classified {
+        name_counts
+            .entry(entry.delivery_name.clone())
+            .or_default()
+            .push(json!({
+                "name": entry.qualified_name,
+                "workspace": entry.workspace.display().to_string(),
+                "team_key": entry.team_key,
+                "workspace_hash": entry.workspace_hash,
+                "stable_qualified_name": entry.stable_qualified_name,
+            }));
+    }
+    let ambiguous_map: std::collections::HashMap<String, Vec<Value>> = name_counts
+        .iter()
+        .filter(|(_, list)| list.len() > 1)
+        .map(|(k, v)| (k.clone(), v.clone()))
+        .collect();
+    let mut leaders: Vec<Value> = Vec::new();
+    for (entry, status, reason) in &classified {
+        let final_status = if ambiguous_map.contains_key(&entry.delivery_name) {
+            "AMBIGUOUS"
+        } else {
+            *status
+        };
+        let send_hint = format!(
+            "team-agent send --to-leader {} MESSAGE",
+            entry.qualified_name
+        );
+        leaders.push(json!({
+            "name": entry.delivery_name,
+            "delivery_name": entry.delivery_name,
+            "qualified_name": entry.qualified_name,
+            "stable_qualified_name": entry.stable_qualified_name,
+            "workspace": entry.workspace.display().to_string(),
+            "workspace_hash": entry.workspace_hash,
+            "workspace_short": entry.workspace_short,
+            "team_key": entry.team_key,
+            "transport_kind": entry.transport_kind,
+            "owner_epoch": entry.owner_epoch,
+            "status": final_status,
+            "stale_reason": reason.clone(),
+            "send_hint": send_hint,
+        }));
+    }
+    let ambiguous_names: Vec<Value> = ambiguous_map
+        .into_iter()
+        .map(|(name, candidates)| {
+            json!({
+                "name": name,
+                "candidates": candidates,
+            })
+        })
+        .collect();
+    let value = json!({
+        "ok": true,
+        "registry_dir": dir,
+        "leaders": leaders,
+        "ambiguous_names": ambiguous_names,
+        // Status vocabulary pinned by E7 RED: LIVE / STALE / AMBIGUOUS.
+        // "stale_reason" is null for LIVE and carries a machine-readable
+        // reason for STALE/AMBIGUOUS entries.
+        "status_wire_values": ["LIVE", "STALE", "AMBIGUOUS"],
+    });
+    Ok(CmdResult::from_json(value, args.json))
+}

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

@@ -58,6 +58,7 @@ pub mod diagnose;
 pub mod emit;
 pub mod helpers;
 pub mod leader;
+pub mod leaders;
 pub mod named_address;
 pub mod profile;
 pub mod send;
@@ -69,6 +70,7 @@ pub use attach_app_server_leader::*;
 pub use diagnose::*;
 pub use emit::*;
 pub use leader::*;
+pub use leaders::*;
 pub use named_address::*;
 pub use profile::*;
 pub use send::*;
@@ -989,6 +991,14 @@ pub mod lifecycle_port {
         {
             let _ = &run_workspace;
         }
+        // E7 unregister-after-success (host-leader-registry-design §14 step 6):
+        // Only prune the derived registry entry when the canonical shutdown
+        // succeeded and there was no dirty_state / verification degradation.
+        // Failed/degraded shutdowns leave the entry STALE so operators can
+        // decide.
+        if ok && !verification_degraded && !probe_degraded {
+            let _ = crate::cli::leader_port::unregister_after_shutdown_success(&run_workspace, team);
+        }
         Ok(response)
     }
 
@@ -3939,7 +3949,11 @@ pub mod leader_port {
         }
         let result = crate::leader::claim_leader(workspace, team, true)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        Ok(lease_value(result))
+        let mut value = lease_value(result);
+        if value.get("ok").and_then(Value::as_bool) == Some(true) {
+            register_after_binding_success(workspace, team, "takeover", &mut value);
+        }
+        Ok(value)
     }
     /// `runtime.claim_leader(...)` 的 CLI `--json` 投影(`cmd_claim_leader`;含 inbox_hint)。
     pub fn claim_leader(
@@ -3968,7 +3982,11 @@ pub mod leader_port {
         }
         let result = crate::leader::claim_leader(workspace, team, confirm)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        Ok(lease_value(result))
+        let mut value = lease_value(result);
+        if value.get("ok").and_then(Value::as_bool) == Some(true) {
+            register_after_binding_success(workspace, team, "claim-leader", &mut value);
+        }
+        Ok(value)
     }
 
     /// `runtime.attach_leader(...)` 的 CLI `--json` 投影。
@@ -3990,6 +4008,11 @@ pub mod leader_port {
                 obj.insert("team_key".to_string(), json!(team));
             }
         }
+        // E7 register-after-success: canonical lease write already
+        // finished inside `crate::leader::attach_leader`.
+        if value.get("ok").and_then(Value::as_bool) == Some(true) {
+            register_after_binding_success(workspace, team, "attach-leader", &mut value);
+        }
         Ok(value)
     }
 
@@ -3999,6 +4022,119 @@ pub mod leader_port {
             .map_err(|e| CliError::Runtime(e.to_string()))
     }
 
+    /// E7 (0.5.9 host-leader-registry-design §14 step 3): after a
+    /// canonical binding command succeeds, write a derived discovery
+    /// entry to `~/.team-agent/leaders`. Registry write failure is
+    /// **never** a binding failure — we only append `leader_registry`
+    /// status to the JSON response so operators can see the degradation.
+    ///
+    /// The receiver payload is read from the JUST-persisted runtime
+    /// state so we capture the canonical fields (pane_id, socket,
+    /// owner_epoch) after the lease writers finished.
+    fn register_after_binding_success(
+        workspace: &Path,
+        team: Option<&str>,
+        source: &str,
+        response: &mut Value,
+    ) {
+        let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
+            return;
+        };
+        let team_key = match team.filter(|t| !t.is_empty()) {
+            Some(t) => t.to_string(),
+            None => crate::state::projection::team_state_key(&state),
+        };
+        let receiver = state
+            .get("teams")
+            .and_then(|v| v.as_object())
+            .and_then(|teams| teams.get(&team_key))
+            .and_then(|t| t.get("leader_receiver"))
+            .or_else(|| state.get("leader_receiver"))
+            .cloned();
+        let Some(receiver) = receiver else {
+            return;
+        };
+        let transport_kind = receiver
+            .get("transport_kind")
+            .and_then(Value::as_str)
+            .unwrap_or("direct_tmux")
+            .to_string();
+        let owner_epoch = receiver
+            .get("owner_epoch")
+            .and_then(Value::as_u64)
+            .or_else(|| {
+                state
+                    .get("teams")
+                    .and_then(|v| v.as_object())
+                    .and_then(|teams| teams.get(&team_key))
+                    .and_then(|t| t.get("owner_epoch"))
+                    .and_then(Value::as_u64)
+            })
+            .unwrap_or(0);
+        let entry = crate::leader::registry::build_entry(
+            workspace,
+            &team_key,
+            &transport_kind,
+            receiver,
+            owner_epoch,
+            source,
+            chrono::Utc::now().to_rfc3339(),
+        );
+        let event_log = crate::event_log::EventLog::new(workspace);
+        let write_result = crate::leader::registry::write_entry_best_effort(&entry);
+        let registry_status = match &write_result {
+            Some(path) => {
+                let _ = event_log.write(
+                    crate::leader::registry::EVENT_REGISTERED,
+                    json!({
+                        "path": path.display().to_string(),
+                        "team_key": team_key,
+                        "workspace_hash": entry.workspace_hash,
+                        "source": source,
+                        "owner_epoch": entry.owner_epoch,
+                    }),
+                );
+                json!({"status": "registered", "path": path.display().to_string()})
+            }
+            None => {
+                let _ = event_log.write(
+                    crate::leader::registry::EVENT_WRITE_FAILED,
+                    json!({
+                        "team_key": team_key,
+                        "workspace_hash": entry.workspace_hash,
+                        "source": source,
+                    }),
+                );
+                json!({"status": "write_failed"})
+            }
+        };
+        if let Some(obj) = response.as_object_mut() {
+            obj.insert("leader_registry".to_string(), registry_status);
+        }
+    }
+
+    /// E7 GC hook: called from shutdown/unbind success paths.
+    pub(crate) fn unregister_after_shutdown_success(
+        workspace: &Path,
+        team: Option<&str>,
+    ) -> Option<PathBuf> {
+        let team_key = team.filter(|t| !t.is_empty()).map(str::to_string).or_else(|| {
+            crate::state::persist::load_runtime_state(workspace)
+                .ok()
+                .map(|s| crate::state::projection::team_state_key(&s))
+        })?;
+        let path = crate::leader::registry::unregister_entry(workspace, &team_key)?;
+        let event_log = crate::event_log::EventLog::new(workspace);
+        let _ = event_log.write(
+            crate::leader::registry::EVENT_UNREGISTERED,
+            json!({
+                "path": path.display().to_string(),
+                "team_key": team_key,
+            }),
+        );
+        Some(path)
+    }
+
     fn owner_bind_value(result: crate::leader::OwnerBindResult) -> Value {
         json!({
             "ok": result.ok,