@team-agent/installer 0.5.77 → 0.5.78

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

@@ -159,6 +159,11 @@ pub(crate) struct CommandSpec {
     pub(crate) governance: Option<GovernanceNote>,
 }
 
+/// Visible default-help contract:
+/// - d40 / v0.5.77 published 15 names including `models` and excluding `results`.
+/// - `results` remains a public handler and must stay discoverable.
+/// - Exact composed set is d40 ∪ {results}. This is a frozen name set, not a
+///   numeric slack threshold.
 #[rustfmt::skip]
 pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
@@ -166,7 +171,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models --provider pi [--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "shutdown", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Shutdown), summary: "stop the selected team", usage: "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
@@ -201,7 +206,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "clone-agent", tier: CommandTier::Secondary, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::CloneAgent), summary: "clone a worker role into a fresh session", usage: "usage: team-agent clone-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "allow-peer-talk", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::AllowPeerTalk), summary: "allow direct worker peer talk", usage: "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "capability/config surface" }) },
     CommandSpec { name: "approvals", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Approvals), summary: "inspect provider approval state", usage: "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "approval diagnostics" }) },
-    CommandSpec { name: "profile", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "manage provider profiles", usage: "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "provider/profile setup" }) },
+    CommandSpec { name: "profile", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "manage provider profiles", usage: "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "provider/profile setup" }) },
     CommandSpec { name: "install-skill", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::InstallSkill), summary: "install or uninstall Team Agent skills", usage: "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "capability setup" }) },
     CommandSpec { name: "inbox", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Inbox), summary: "inspect queued messages", usage: "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
 

package/crates/team-agent/src/cli/status_port/compact.rs

@@ -60,19 +60,23 @@ pub(super) fn compact_not_ready(full: &Value) -> Value {
         })
         .unwrap_or_default();
     let mut obj = Map::new();
-    let channel_unbound = reasons
-        .iter()
-        .any(|reason| reason == "leader_receiver_unbound");
     obj.insert(
         "reasons".to_string(),
         Value::Array(reasons.into_iter().map(Value::String).collect()),
     );
     obj.insert("agents".to_string(), Value::Array(agents));
-    if channel_unbound {
-        obj.insert(
-            "next_action".to_string(),
-            Value::String("claim-leader".to_string()),
-        );
+    if let Some(next_action) = full
+        .pointer("/readiness/next_action")
+        .and_then(Value::as_str)
+    {
+        let truly_unbound = full.pointer("/readiness/state").and_then(Value::as_str)
+            == Some("leader_receiver_unbound");
+        if !next_action.contains("claim-leader") || truly_unbound {
+            obj.insert(
+                "next_action".to_string(),
+                Value::String(next_action.to_string()),
+            );
+        }
     }
     Value::Object(obj)
 }

package/crates/team-agent/src/cli/status_port/snapshot.rs

@@ -95,18 +95,21 @@ impl RuntimeSnapshot {
             .filter(|team| !team.is_empty())
             .map(str::to_string)
             .unwrap_or_else(|| crate::state::projection::team_state_key(state));
-        if !team_key.is_empty()
-            && !crate::lifecycle::launch::launched_team_receiver_is_attached(workspace, &team_key)
-        {
-            if let Some(object) = readiness.as_object_mut() {
-                object.insert("all_attached_receiver".to_string(), json!(false));
-                object.insert("ready".to_string(), json!(false));
-                object.insert("state".to_string(), json!("leader_receiver_unbound"));
-                object.insert("next_action".to_string(), json!("claim-leader"));
-                object.insert(
-                    "reason".to_string(),
-                    json!("leader registry does not authorize this workspace"),
-                );
+        if !team_key.is_empty() {
+            let class = crate::lifecycle::launch::classify_leader_binding(workspace, &team_key);
+            if class != crate::lifecycle::launch::LeaderBindingClass::Attached {
+                if let Some(object) = readiness.as_object_mut() {
+                    object.insert("all_attached_receiver".to_string(), json!(false));
+                    object.insert("ready".to_string(), json!(false));
+                    object.insert("state".to_string(), json!(class.issue_id()));
+                    object.insert("reason".to_string(), json!(class.issue_id()));
+                    if class == crate::lifecycle::launch::LeaderBindingClass::Unbound {
+                        object.insert(
+                            "next_action".to_string(),
+                            json!(class.repair()),
+                        );
+                    }
+                }
             }
         }
         let grok_slot = crate::cli::grok_slot_report(workspace, state).to_json();

package/crates/team-agent/src/cli/status_port/store.rs

@@ -230,7 +230,7 @@ pub(super) fn pending_leader_notifications(
             "created_at": row.get::<_, Option<String>>(4)?,
             "delivery_attempts": row.get::<_, i64>(5)?,
             "channel": channel,
-            "action": "run team-agent attach-leader or team-agent takeover",
+            "action": "historical leader mailbox debt; not proof of current unbound owner",
         }))
     };
     let rows = match owner_team_id {

package/crates/team-agent/src/cli/tests/missing_subcommands.rs

@@ -90,6 +90,44 @@ fn seed_self_signed_attached_leader(ws: &std::path::Path) {
     .unwrap();
 }
 
+fn seed_canonical_healthy_leader(ws: &std::path::Path, endpoint: &str) {
+    crate::state::persist::save_runtime_state(
+        ws,
+        &json!({
+            "team_key": "current",
+            "workspace": ws,
+            "teams": {
+                "current": {
+                    "team_owner": {
+                        "pane_id": "%1",
+                        "owner_epoch": 1,
+                        "provider": "codex"
+                    },
+                    "leader_receiver": {
+                        "mode": "direct_tmux",
+                        "status": "attached",
+                        "pane_id": "%1",
+                        "owner_epoch": 1,
+                        "provider": "codex",
+                        "tmux_socket": endpoint
+                    }
+                }
+            }
+        }),
+    )
+    .unwrap();
+    assert_eq!(
+        crate::leader::registry::register_binding_from_state_best_effort(
+            ws,
+            Some("current"),
+            "diagnose-healthy-fixture",
+        )
+        .as_ref()
+        .map(|outcome| outcome.status),
+        Some("registered")
+    );
+}
+
 fn seed_leader_registry_entry(ws: &std::path::Path) {
     let entry = crate::leader::registry::build_entry(
         ws,
@@ -345,17 +383,33 @@ fn dispatch_routes_diagnose_healthy_leader() {
     ]);
     let _home = IsolatedHome::enter("diagnose-healthy");
     let ws = tmp_workspace();
-    seed_self_signed_attached_leader(&ws);
-    seed_leader_registry_entry(&ws);
-    let code = run(
-        &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
+    let endpoint = "/tmp/ta-diagnose-healthy.sock";
+    seed_canonical_healthy_leader(&ws, endpoint);
+    let transport = crate::transport::test_support::OfflineTransport::default()
+        .with_tmux_endpoint(endpoint)
+        .with_targets(vec![crate::transport::PaneInfo {
+            pane_id: crate::transport::PaneId::new("%1"),
+            session: crate::transport::SessionName::new("s"),
+            window_index: None,
+            window_name: None,
+            pane_index: None,
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: Some(ws.clone()),
+            active: true,
+            pane_pid: None,
+            leader_env: Default::default(),
+        }]);
+    let code = crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
+        run(
+            &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
+            &ws,
+        )
+    });
     assert_eq!(
         code,
         ExitCode::Ok,
-        "`diagnose` must be Ok when state.json looks attached AND ~/.team-agent/leaders/ \
-         has a matching attached row; got {code:?}"
+        "`diagnose` must be Ok when canonical owner/receiver, production registry, and live align; got {code:?}"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

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

@@ -234,6 +234,76 @@ fn resolve_name_team_disambiguated() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn resolve_qualified_name_prefers_unique_state_pane_over_same_window_idle_pane() {
+    let ws = named_ws("qualified-state-pane-disambiguation");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "team-a": worker_team("team-a", "qa", "%worker", "qa")
+        })),
+    );
+    let transport = OfflineTransport::new().with_targets(vec![
+        pane("team-a", "qa", "%worker"),
+        pane("team-a", "qa", "%idle"),
+    ]);
+
+    let resolved = resolve_name_with_transport(
+        &ws,
+        &format!("{}::team-a/qa", ws.display()),
+        &transport,
+    )
+    .expect("a qualified worker address should use its unique state pane");
+    assert_eq!(resolved.pane_id, "%worker");
+    assert_eq!(resolved.state_pane_id.as_deref(), Some("%worker"));
+    assert!(!resolved.state_pane_stale);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
+    for scenario in ["missing", "stale", "cross-session", "duplicate"] {
+        let ws = named_ws(&format!("qualified-state-pane-{scenario}"));
+        let mut team = worker_team("team-a", "qa", "%worker", "qa");
+        let targets = match scenario {
+            "missing" => {
+                team["agents"]["qa"]
+                    .as_object_mut()
+                    .unwrap()
+                    .remove("pane_id");
+                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+            }
+            "stale" => {
+                team["agents"]["qa"]["pane_id"] = json!("%stale");
+                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+            }
+            "cross-session" => vec![
+                pane("old-team-a", "qa", "%worker"),
+                pane("team-a", "qa", "%current-one"),
+                pane("team-a", "qa", "%current-two"),
+            ],
+            "duplicate" => {
+                team["agents"]["qa"]["pane_id"] = json!("%duplicate");
+                vec![
+                    pane("team-a", "qa", "%duplicate"),
+                    pane("team-a", "qa", "%duplicate"),
+                ]
+            }
+            _ => unreachable!(),
+        };
+        seed_state(&ws, state_with_teams(json!({"team-a": team})));
+        let transport = OfflineTransport::new().with_targets(targets);
+        let err = resolve_name_with_transport(
+            &ws,
+            &format!("{}::team-a/qa", ws.display()),
+            &transport,
+        )
+        .expect_err("non-unique state pane evidence must remain fail-closed");
+        assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous, "{scenario}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+}
+
 #[test]
 fn resolve_qualified_name_canonicalizes_legacy_session_alias() {
     let ws = named_ws("legacy-session-alias");

package/crates/team-agent/src/cli/tests/verb_profile.rs

@@ -35,7 +35,7 @@ fn seed_official_api_profile(ws: &std::path::Path) {
 
 // Golden source:
 // - cli/parser.py:131-150 registers `profile {init,doctor,show}`:
-//   * init NAME --workspace . --team TEAM --auth-mode choices(sorted AUTH_MODES) --json
+//   * init NAME --workspace . --team TEAM --auth-mode choices(sorted AUTH_MODES) --proxy-mode direct|inherit --json
 //   * doctor NAME --workspace . --team TEAM --json
 //   * show NAME --workspace . --team TEAM --json
 // - cli/commands.py:47-67 resolves scope then delegates to profiles.init_profile/
@@ -52,7 +52,7 @@ fn seed_official_api_profile(ws: &std::path::Path) {
 //   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src \
 //     python3 /tmp/probe_profile_cli.py
 //   profile init codex_sub --auth-mode subscription --json rc=0 and creates:
-//   codex_sub.env = "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n" (mode 0600),
+//   codex_sub.env = "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n" (mode 0600),
 //   codex_sub.example.env with same body, plus AGENTS.md/CLAUDE.md secret boundary files.
 #[test]
 fn profile_init_routes_and_creates_secret_boundary_files() {
@@ -87,12 +87,12 @@ fn profile_init_routes_and_creates_secret_boundary_files() {
     );
     assert_eq!(
         std::fs::read_to_string(dir.join("codex_sub.env")).unwrap(),
-        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n",
+        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n",
         "subscription profile template body must match golden"
     );
     assert_eq!(
         std::fs::read_to_string(dir.join("codex_sub.example.env")).unwrap(),
-        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n",
+        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n",
         "subscription example template body must match golden"
     );
 
@@ -116,7 +116,7 @@ fn profile_init_routes_and_creates_secret_boundary_files() {
     );
     assert_eq!(
         std::fs::read_to_string(dir.join("codex_sub.env")).unwrap(),
-        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\n",
+        "AUTH_MODE=subscription\nPROFILE_NAME=codex_sub\nPROXY_MODE=inherit\n",
         "idempotent init must not rewrite existing profile bytes"
     );
     let _ = std::fs::remove_dir_all(&ws);
@@ -145,7 +145,7 @@ fn compatible_api_profile_init_template_contains_common_five_fields() {
     );
 
     let expected =
-        "AUTH_MODE=compatible_api\nPROFILE_NAME=compat\nBASE_URL=\nAPI_KEY=\nMODEL=\n";
+        "AUTH_MODE=compatible_api\nPROFILE_NAME=compat\nPROXY_MODE=inherit\nBASE_URL=\nAPI_KEY=\nMODEL=\n";
     let dir = profiles_dir(&ws);
     assert_eq!(
         std::fs::read_to_string(dir.join("compat.env")).unwrap(),
@@ -160,6 +160,81 @@ fn compatible_api_profile_init_template_contains_common_five_fields() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn profile_init_accepts_local_proxy_mode_and_rejects_unknown_values() {
+    let ws = tmp_workspace();
+    let direct = run(
+        &profile_argv(&[
+            "profile",
+            "init",
+            "cursor_sub",
+            "--workspace",
+            ".",
+            "--auth-mode",
+            "subscription",
+            "--proxy-mode=direct",
+            "--json",
+        ]),
+        &ws,
+    );
+    assert_eq!(direct, ExitCode::Ok, "direct proxy mode must be accepted");
+    let body = std::fs::read_to_string(profiles_dir(&ws).join("cursor_sub.env")).unwrap();
+    assert!(body.contains("PROXY_MODE=direct\n"));
+
+    let invalid = run(
+        &profile_argv(&[
+            "profile",
+            "init",
+            "bad_proxy",
+            "--workspace",
+            ".",
+            "--proxy-mode",
+            "sideways",
+            "--json",
+        ]),
+        &ws,
+    );
+    assert_eq!(invalid, ExitCode::Error, "unknown proxy mode must fail");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn profile_init_existing_profile_reports_actual_mode_and_show_matches() {
+    let ws = tmp_workspace();
+    let make_args = |command: &str, mode: Option<&str>| ProfileArgs {
+        command: command.to_string(),
+        name: "cursor_sub".to_string(),
+        workspace: ws.clone(),
+        team: None,
+        auth_mode: Some("subscription".to_string()),
+        proxy_mode: mode.map(str::to_string),
+        json: true,
+    };
+    let first = cmd_profile(&make_args("init", Some("direct"))).unwrap();
+    let first = match first.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+    assert_eq!(first["proxy_mode"], "direct");
+    assert_eq!(first["proxy_mode_changed"], true);
+
+    let repeat = cmd_profile(&make_args("init", Some("inherit"))).unwrap();
+    let repeat = match repeat.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+    assert_eq!(repeat["proxy_mode"], "direct");
+    assert_eq!(repeat["proxy_mode_changed"], false);
+
+    let shown = cmd_profile(&make_args("show", None)).unwrap();
+    let shown = match shown.output {
+        CmdOutput::Json(value) => value,
+        other => panic!("expected json output, got {other:?}"),
+    };
+    assert_eq!(shown["proxy_mode"], "direct");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 // Golden source:
 // - profiles/core.py:95-119 doctor_profile returns ok=true for existing profiles and
 //   ok=false for missing profiles; parser.py:506-508 maps result.ok false to exit 1.

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

@@ -667,6 +667,7 @@ pub struct ProfileArgs {
     pub workspace: PathBuf,
     pub team: Option<String>,
     pub auth_mode: Option<String>,
+    pub proxy_mode: Option<String>,
     pub json: bool,
 }