@team-agent/installer 0.5.43 → 0.5.45

package/Cargo.lock

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

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

@@ -308,7 +308,24 @@ fn command_help(command: Option<&str>) -> String {
         Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.\n\n--backend selects the worker transport (Phase 1d Batch 2): tmux (default on POSIX; unchanged behavior), conpty (Windows-native ConPTY worker transport; requires the shim binary and Windows host).".to_string(),
         Some("start") => compat_hidden_help("start", "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]"),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
-        Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\nMVP: name-based cross-workspace addressing assumes trusted local caller; no auth gate.".to_string(),
+        Some("send") => concat!(
+            "usage: team-agent send TARGET MESSAGE... ",
+            "[--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] ",
+            "[--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] ",
+            "[--watch-result] [--requires-ack|--no-ack] [--no-wait] ",
+            "[--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\n",
+            "TARGET is a short id scoped by --team; MCP `to` is a short id scoped ",
+            "by the worker's owner team.\n",
+            "--to-name accepts: --to-name AGENT, --to-name TEAM/AGENT, or ",
+            "--to-name WORKSPACE::TEAM/AGENT.\n",
+            "--team scopes only a bare --to-name AGENT; qualified forms keep the ",
+            "scope in the address.\n",
+            "TEAM/AGENT and WORKSPACE::TEAM/AGENT are not valid positional TARGET ",
+            "or MCP `to` values.\n\n",
+            "MVP: name-based cross-workspace addressing assumes trusted local ",
+            "caller; no auth gate."
+        )
+        .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
         Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n默认输出: worker,空闲|工作|错误；错误细分走 status --summary".to_string(),
         Some("stop") => compat_hidden_help("stop", "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]"),
@@ -357,43 +374,33 @@ fn emit_unknown_subcommand_usage(command: &str) -> ExitCode {
     if let Some(suggestion) = nearest_subcommand(command) {
         eprintln!("team-agent: did you mean `{suggestion}`?");
     }
-    ExitCode::Usage
+    // 0.5.45 naming-addressing (RED-6): unknown subcommand exits 1
+    // (Error), aligned with the family of typo refusals throughout
+    // send/named. Pre-0.5.45 mapped to Usage (2) argparse-style; the
+    // shared refusal shape ("typo diagnostic + advisory suggestion +
+    // exit 1") is the invariant callers of `team-agent send` /
+    // `--to-name` also see, so keeping unknown-subcommand at 2 was
+    // internal drift.
+    ExitCode::Error
 }
 
-/// 在已知子命令里找与 `input` 最接近的一个(Levenshtein ≤ 阈值)。无足够接近者 → None。
+/// 在已知子命令里找与 `input` 最接近的一个。0.5.45 naming-addressing
+/// (design §3.2/§4.1) 抽公 shared `model::name_similarity` — 距离
+/// 阈值与排序规则跟 CLI `--to-name` typo suggestion 走同一份纯函数,
+/// 避免两套 fuzzy 逻辑漂移。既有 `statu -> status` 行为保留(RED-6
+/// grep guard + prefix-hit priority)。
 fn nearest_subcommand(input: &str) -> Option<&'static str> {
-    let candidates = COMMAND_SPECS
+    use crate::model::name_similarity::{rank, Candidate};
+    let candidates: Vec<Candidate<&'static str>> = COMMAND_SPECS
         .iter()
         .filter(|spec| spec.suggestion_index)
-        .map(|spec| spec.name);
-    // 阈值随长度放宽,但短词收紧,避免 'x' 误配任何东西。
-    let max_distance = match input.chars().count() {
-        0..=3 => 1,
-        4..=6 => 2,
-        _ => 3,
-    };
-    candidates
-        .map(|c| (c, levenshtein(input, c)))
-        .filter(|(_, d)| *d <= max_distance)
-        .min_by_key(|(_, d)| *d)
-        .map(|(c, _)| c)
-}
-
-/// 标准 Levenshtein 编辑距离(纯函数,无依赖;子命令建议用)。
-fn levenshtein(a: &str, b: &str) -> usize {
-    let a: Vec<char> = a.chars().collect();
-    let b: Vec<char> = b.chars().collect();
-    let mut prev: Vec<usize> = (0..=b.len()).collect();
-    let mut curr = vec![0usize; b.len() + 1];
-    for (i, &ca) in a.iter().enumerate() {
-        curr[0] = i + 1;
-        for (j, &cb) in b.iter().enumerate() {
-            let cost = if ca == cb { 0 } else { 1 };
-            curr[j + 1] = (prev[j + 1] + 1).min(curr[j] + 1).min(prev[j] + cost);
-        }
-        std::mem::swap(&mut prev, &mut curr);
-    }
-    prev[b.len()]
+        .map(|spec| Candidate {
+            match_key: spec.name.to_string(),
+            stable_key: spec.name.to_string(),
+            payload: spec.name,
+        })
+        .collect();
+    rank(input, &candidates).into_iter().next()
 }
 
 fn emit_usage_error(message: &str) {
@@ -2011,6 +2018,10 @@ mod tests {
 
     #[test]
     fn e8_levenshtein_basic() {
+        // 0.5.45 naming-addressing: distance function moved to
+        // `crate::model::name_similarity` (shared with --to-name typo
+        // suggestions). Same math, single source.
+        use crate::model::name_similarity::levenshtein;
         assert_eq!(levenshtein("kitten", "sitting"), 3);
         assert_eq!(levenshtein("status", "status"), 0);
         assert_eq!(levenshtein("statu", "status"), 1);

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

@@ -4100,7 +4100,7 @@ pub mod leader_port {
                 "action": "rerun with --confirm to claim ownership of this team",
             }));
         }
-        let state = crate::state::persist::load_runtime_state(workspace)
+        let state = crate::state::persist::load_runtime_state_without_migrations(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let Some(team_id) = resolve_owner_team_id(&state, team) else {
             return Ok(json!({
@@ -4112,8 +4112,7 @@ pub mod leader_port {
             }));
         };
         let requested_team = team;
-        let explicit_team = requested_team.filter(|team| !team.is_empty());
-        let resolved_team = explicit_team.map(|_| team_id.as_str().to_string());
+        let resolved_team = Some(team_id.as_str().to_string());
         if !positive_caller_pane_env_present() {
             let bind = crate::leader::bind_owner_from_caller_pane(workspace, &team_id, None)
                 .map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -4124,6 +4123,7 @@ pub mod leader_port {
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let mut value = lease_value(result);
         insert_resolved_team(&mut value, requested_team, resolved_team.as_deref());
+        append_team_session_ready(workspace, resolved_team.as_deref(), &mut value);
         if value.get("ok").and_then(Value::as_bool) == Some(true) {
             emit_topology_convergence_event(
                 workspace,
@@ -4137,6 +4137,7 @@ pub mod leader_port {
                 "takeover",
                 &mut value,
             );
+            restore_non_target_teams(workspace, &state, resolved_team.as_deref());
         }
         Ok(value)
     }
@@ -4146,7 +4147,7 @@ pub mod leader_port {
         team: Option<&str>,
         confirm: bool,
     ) -> Result<Value, CliError> {
-        let state = crate::state::persist::load_runtime_state(workspace)
+        let state = crate::state::persist::load_runtime_state_without_migrations(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let Some(team_id) = resolve_owner_team_id(&state, team) else {
             return Ok(json!({
@@ -4165,12 +4166,12 @@ pub mod leader_port {
             }
             return Ok(owner_bind_value(bind));
         }
-        let explicit_team = team.filter(|team| !team.is_empty());
-        let resolved_team = explicit_team.map(|_| team_id.as_str().to_string());
+        let resolved_team = Some(team_id.as_str().to_string());
         let result = crate::leader::claim_leader(workspace, resolved_team.as_deref(), confirm)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let mut value = lease_value(result);
         insert_resolved_team(&mut value, team, resolved_team.as_deref());
+        append_team_session_ready(workspace, resolved_team.as_deref(), &mut value);
         if value.get("ok").and_then(Value::as_bool) == Some(true) {
             emit_topology_convergence_event(
                 workspace,
@@ -4184,6 +4185,7 @@ pub mod leader_port {
                 "claim-leader",
                 &mut value,
             );
+            restore_non_target_teams(workspace, &state, resolved_team.as_deref());
         }
         Ok(value)
     }
@@ -4279,6 +4281,7 @@ pub mod leader_port {
                 "owner_epoch": convergence.get("owner_epoch").cloned().unwrap_or(Value::Null),
                 "persisted": convergence.get("persisted").cloned().unwrap_or(Value::Bool(false)),
                 "checked_paths": convergence.get("checked_paths").cloned().unwrap_or_else(|| json!([])),
+                "team_session_ready": response.get("team_session_ready").cloned().unwrap_or(Value::Null),
             }),
         );
     }
@@ -4344,9 +4347,96 @@ pub mod leader_port {
                     | crate::state::projection::OwnerTeamResolution::Ambiguous { .. } => None,
                 }
             }
-            None => Some(TeamKey::new(crate::state::projection::team_state_key(
-                state,
-            ))),
+            None => Some(TeamKey::new(active_or_derived_team_key(state))),
+        }
+    }
+
+    fn active_or_derived_team_key(state: &Value) -> String {
+        state
+            .get("active_team_key")
+            .and_then(Value::as_str)
+            .filter(|team| !team.is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| crate::state::projection::team_state_key(state))
+    }
+
+    fn append_team_session_ready(workspace: &Path, team: Option<&str>, response: &mut Value) {
+        let Some(obj) = response.as_object_mut() else {
+            return;
+        };
+        let Some(convergence) = obj.get("topology_convergence") else {
+            return;
+        };
+        if convergence.get("status").and_then(Value::as_str) != Some("converged") {
+            return;
+        }
+        let Some(endpoint) = convergence
+            .get("new_tmux_endpoint")
+            .and_then(Value::as_str)
+            .filter(|endpoint| !endpoint.is_empty())
+        else {
+            obj.insert("team_session_ready".to_string(), Value::Null);
+            return;
+        };
+        let session_name = crate::state::persist::load_runtime_state_without_migrations(workspace)
+            .ok()
+            .and_then(|state| target_team_session_name(&state, team));
+        let ready = session_name
+            .as_deref()
+            .and_then(|session| crate::topology::team_session_ready_on_endpoint(endpoint, session));
+        obj.insert(
+            "team_session_ready".to_string(),
+            ready.map(Value::Bool).unwrap_or(Value::Null),
+        );
+    }
+
+    fn target_team_session_name(state: &Value, team: Option<&str>) -> Option<String> {
+        team.and_then(|team| {
+            state
+                .get("teams")
+                .and_then(Value::as_object)
+                .and_then(|teams| teams.get(team))
+        })
+        .and_then(|team_state| team_state.get("session_name"))
+        .and_then(Value::as_str)
+        .filter(|session| !session.is_empty())
+        .or_else(|| state.get("session_name").and_then(Value::as_str))
+        .filter(|session| !session.is_empty())
+        .map(str::to_string)
+    }
+
+    fn restore_non_target_teams(workspace: &Path, before: &Value, target: Option<&str>) {
+        let Some(target) = target.filter(|team| !team.is_empty()) else {
+            return;
+        };
+        let Some(before_teams) = before.get("teams").and_then(Value::as_object) else {
+            return;
+        };
+        let Ok(mut latest) =
+            crate::state::persist::load_runtime_state_without_migrations(workspace)
+        else {
+            return;
+        };
+        let Some(latest_teams) = latest.get_mut("teams").and_then(Value::as_object_mut) else {
+            return;
+        };
+        let mut changed = false;
+        for (team, before_entry) in before_teams {
+            if team == target {
+                continue;
+            }
+            if latest_teams.get(team) != Some(before_entry) {
+                latest_teams.insert(team.clone(), before_entry.clone());
+                changed = true;
+            }
+        }
+        if changed {
+            let _ = crate::state::repository::StateRepository::new(workspace).save(
+                crate::state::repository::StateWriteIntent::LeaderBindingRestoreNonTargetTeams {
+                    target_team_key: target,
+                },
+                &latest,
+            );
         }
     }
 

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

@@ -61,6 +61,11 @@ pub(crate) struct NamedAddressError {
     pub requested_team: Option<String>,
     pub available_team_keys: Vec<String>,
     pub suggested_name: Option<String>,
+    /// 0.5.45 naming-addressing (design §3.4, RED-2/RED-3): echo the
+    /// user's original typo so JSON consumers + N38 human can pair
+    /// `requested_name`/`suggested_name` without re-parsing. Absent
+    /// for exact refusals like empty-workspace.
+    pub requested_name: Option<String>,
 }
 
 impl NamedAddressError {
@@ -74,18 +79,149 @@ impl NamedAddressError {
             requested_team: None,
             available_team_keys: Vec::new(),
             suggested_name: None,
+            requested_name: None,
         }
     }
 
     pub(crate) fn n38_message(&self) -> String {
+        // 0.5.45 naming-addressing (design §3.4, RED-3): the N38 first
+        // line embeds the human-readable `message` (which contains
+        // the original typo like `qa-namng`/`btea`) after the reason.
+        // Pre-0.5.45 the line was `Error: <reason>` only; the typo
+        // hid in the JSON-only `error` field, so the human line
+        // couldn't be scanned to recover the original request.
         format!(
-            "Error: {}\nAction: {}\nLog: {}",
+            "Error: {}: {}\nAction: {}\nLog: {}",
             self.kind.as_str(),
+            self.message,
             self.action,
             self.log
         )
     }
 
+    /// 0.5.45 (design §3.4, RED-2 named-team): rank team-scope typo
+    /// against target workspace `teams.*` keys; candidate `name`
+    /// preserves the qualified `team/entity` shape so the copyable
+    /// token in Action can be pasted back into `--to-name` unchanged.
+    fn with_scoped_suggestions_for_team(
+        self,
+        state: &Value,
+        team_typo: &str,
+        entity: &str,
+        parsed: &ParsedNamedAddress,
+    ) -> Self {
+        use crate::model::name_similarity::{rank, Candidate};
+        let candidates: Vec<Candidate<(String, String)>> = state
+            .get("teams")
+            .and_then(Value::as_object)
+            .map(|teams| {
+                teams
+                    .keys()
+                    .map(|team_key| Candidate {
+                        match_key: team_key.clone(),
+                        stable_key: team_key.clone(),
+                        payload: (team_key.clone(), entity.to_string()),
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+        let ranked = rank(team_typo, &candidates);
+        let requested_display = parsed.display_name();
+        let candidate_values: Vec<Value> = ranked
+            .iter()
+            .map(|(team_key, entity)| {
+                let name = format!("{team_key}/{entity}");
+                json!({
+                    "name": name,
+                    "team_key": team_key,
+                    "agent_id": entity,
+                    "advisory": true,
+                })
+            })
+            .collect();
+        let best = ranked
+            .first()
+            .map(|(team_key, entity)| format!("{team_key}/{entity}"));
+        self.with_scoped_suggestions(requested_display, candidate_values, best)
+    }
+
+    /// 0.5.45 (design §3.4, RED-2 named-agent): rank agent-scope typo
+    /// against the legal `teams[team].agents` keys.
+    fn with_scoped_suggestions_for_agent(
+        self,
+        team_entry: &Value,
+        team: &str,
+        agent_typo: &str,
+        parsed: &ParsedNamedAddress,
+    ) -> Self {
+        use crate::model::name_similarity::{rank, Candidate};
+        let candidates: Vec<Candidate<String>> = team_entry
+            .get("agents")
+            .and_then(Value::as_object)
+            .map(|agents| {
+                agents
+                    .keys()
+                    .map(|agent_id| Candidate {
+                        match_key: agent_id.clone(),
+                        stable_key: agent_id.clone(),
+                        payload: agent_id.clone(),
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+        let ranked = rank(agent_typo, &candidates);
+        let requested_display = parsed.display_name();
+        let candidate_values: Vec<Value> = ranked
+            .iter()
+            .map(|agent_id| {
+                json!({
+                    "name": format!("{team}/{agent_id}"),
+                    "team_key": team,
+                    "agent_id": agent_id,
+                    "advisory": true,
+                })
+            })
+            .collect();
+        let best = ranked
+            .first()
+            .map(|agent_id| format!("{team}/{agent_id}"));
+        self.with_scoped_suggestions(requested_display, candidate_values, best)
+    }
+
+    /// 0.5.45 naming-addressing (design §3.3/§3.4): attach an
+    /// advisory suggestion payload. `requested` is the original typo
+    /// (surfaced verbatim in JSON + N38 Action); `ranked_candidates`
+    /// carry the scope-safe candidate payloads produced by
+    /// `model::name_similarity::rank`. The best candidate populates
+    /// `suggested_name` for convenience; the full list appears as
+    /// `candidates` in the JSON envelope.
+    pub(crate) fn with_scoped_suggestions(
+        mut self,
+        requested: impl Into<String>,
+        ranked_candidates: Vec<Value>,
+        best_copyable: Option<String>,
+    ) -> Self {
+        let requested = requested.into();
+        self.requested_name = Some(requested.clone());
+        self.candidates = ranked_candidates;
+        self.suggested_name = best_copyable.clone();
+        // Rewrite Action so the human line points at the actual
+        // returned candidate (RED-4). Falls back to a status-JSON
+        // hint when no candidate cleared the threshold.
+        if let Some(best) = best_copyable {
+            self.action = format!(
+                "Did you mean `{best}`? Rerun with `--to-name {best}`."
+            );
+        } else {
+            self.action = format!(
+                "No close matches for `{requested}`. \
+                 Run `team-agent status --json` for the current team_key + agent list \
+                 and combine them as `<team>/<agent>` for `--to-name`."
+            );
+        }
+        self
+    }
+
     pub(crate) fn to_json(&self) -> Value {
         let mut obj = serde_json::Map::new();
         obj.insert("ok".to_string(), Value::Bool(false));
@@ -124,6 +260,12 @@ impl NamedAddressError {
                 Value::String(suggested.to_string()),
             );
         }
+        if let Some(requested) = self.requested_name.as_deref() {
+            obj.insert(
+                "requested_name".to_string(),
+                Value::String(requested.to_string()),
+            );
+        }
         Value::Object(obj)
     }
 }
@@ -261,8 +403,20 @@ pub(crate) fn resolve_name_with_workspace_transports(
 pub(crate) fn resolve_name_for_cli(
     sender_workspace: &Path,
     raw_name: &str,
+    bare_team_scope: Option<&str>,
 ) -> Result<(ResolvedNamedAddress, Box<dyn Transport>), NamedAddressError> {
     let parsed = parse_named_address(raw_name)?;
+    // 0.5.45 naming-addressing (design §3.1, RED-1): bare `--to-name`
+    // + explicit `--team` normalizes to `ParsedTarget::TeamEntity`
+    // BEFORE transport selection. Only fires when:
+    //   1. address parsed as bare (no `team/`, no `workspace::`),
+    //   2. caller passed a non-empty `bare_team_scope`.
+    // Qualified addresses keep the scope in the address (design §1
+    // priority: workspace::team/entity > team/entity > bare + --team
+    // > bare workspace-unique). resolve_name_with_transport and the
+    // registry-to-E6 internal helper deliberately pass `None` so
+    // caller-supplied `--team` never overrides a full address.
+    let parsed = normalize_bare_with_team_scope(parsed, bare_team_scope);
     let target_workspace = resolve_workspace(sender_workspace, parsed.workspace.as_deref())?;
     let state = load_state_checked(&target_workspace)?;
     let transport = transport_for_cli_target(&target_workspace, &state, &parsed);
@@ -276,6 +430,34 @@ pub(crate) fn resolve_name_for_cli(
     Ok((resolved, transport))
 }
 
+/// 0.5.45 naming-addressing (design §3.1): apply bare-team scope归一.
+/// Only bare targets with no workspace prefix consume `--team`;
+/// qualified addresses keep the scope embedded in the address.
+fn normalize_bare_with_team_scope(
+    parsed: ParsedNamedAddress,
+    bare_team_scope: Option<&str>,
+) -> ParsedNamedAddress {
+    let Some(scope) = bare_team_scope.map(str::trim).filter(|s| !s.is_empty()) else {
+        return parsed;
+    };
+    if parsed.workspace.is_some() {
+        return parsed;
+    }
+    match parsed.target {
+        ParsedTarget::BareAgent(agent) => ParsedNamedAddress {
+            workspace: parsed.workspace,
+            target: ParsedTarget::TeamEntity {
+                team: scope.to_string(),
+                entity: agent,
+            },
+        },
+        target => ParsedNamedAddress {
+            workspace: parsed.workspace,
+            target,
+        },
+    }
+}
+
 /// E6 wiring helper (`cli::send::maybe_enqueue_offline_leader_mailbox`):
 /// re-parse a `<workspace>::<team>/leader` name and return the resolved
 /// target workspace + canonical team_key so send.rs can enqueue the
@@ -462,12 +644,32 @@ fn resolve_worker(
     parsed: &ParsedNamedAddress,
     transport: &dyn Transport,
 ) -> Result<ResolvedNamedAddress, NamedAddressError> {
-    let team_entry = team_entry(state, team).ok_or_else(|| name_not_resolvable_team(team))?;
-    let agent_entry = team_entry
+    let team_entry = match team_entry(state, team) {
+        Some(entry) => entry,
+        None => {
+            // 0.5.45 naming-addressing (design §3.4, RED-2 named):
+            // typo in team scope. Candidates come from the target
+            // workspace's `teams.*.*` — scope-safe because we're
+            // already inside the requested workspace projection.
+            return Err(name_not_resolvable_team(team)
+                .with_scoped_suggestions_for_team(state, team, agent, parsed));
+        }
+    };
+    let agent_entry = match team_entry
         .get("agents")
         .and_then(Value::as_object)
         .and_then(|agents| agents.get(agent))
-        .ok_or_else(|| name_not_resolvable_agent(team, agent))?;
+    {
+        Some(entry) => entry,
+        None => {
+            // 0.5.45 naming-addressing (design §3.4, RED-2 named):
+            // typo in agent within a legal team. Candidates come from
+            // `teams[team].agents` — scope stays in the requested
+            // team, so sibling teams cannot leak.
+            return Err(name_not_resolvable_agent(team, agent)
+                .with_scoped_suggestions_for_agent(team_entry, team, agent, parsed));
+        }
+    };
     let session = string_field(team_entry, "session_name")
         .ok_or_else(|| name_not_resolvable("team is missing session_name"))?;
     let window = string_field(agent_entry, "window")