@team-agent/installer 0.5.106 → 0.5.107

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.106"
+version = "0.5.107"
 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.106"
+version = "0.5.107"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -13,33 +13,19 @@ use serde_json::json;
 // =========================================================================
 
 #[test]
-fn provider_args_strips_leading_dashdash() {
-    // golden: _provider_args(["--","-x"]) == ["-x"]
-    assert_eq!(
-        provider_args(&["--".into(), "-x".into()]),
-        vec!["-x".to_string()]
-    );
-}
-
-#[test]
-fn provider_args_keeps_when_no_leading_dashdash() {
-    // golden: _provider_args(["-x","-y"]) == ["-x","-y"]
-    assert_eq!(
-        provider_args(&["-x".into(), "-y".into()]),
-        vec!["-x".to_string(), "-y".to_string()]
-    );
-}
-
-#[test]
-fn provider_args_empty_is_empty() {
-    // golden: _provider_args([]) == []
-    assert_eq!(provider_args(&[]), Vec::<String>::new());
-}
-
-#[test]
-fn provider_args_lone_dashdash_yields_empty() {
-    // golden: _provider_args(["--"]) == []  (values[1:] of single-elem list)
-    assert_eq!(provider_args(&["--".into()]), Vec::<String>::new());
+fn provider_args_cases() {
+    // (old case-id, input, Python golden); values[1:] of a lone "--" is empty.
+    const CASES: &[(&str, &[&str], &[&str])] = &[
+        ("provider_args_strips_leading_dashdash", &["--", "-x"], &["-x"]),
+        ("provider_args_keeps_when_no_leading_dashdash", &["-x", "-y"], &["-x", "-y"]),
+        ("provider_args_empty_is_empty", &[], &[]),
+        ("provider_args_lone_dashdash_yields_empty", &["--"], &[]),
+    ];
+    for (id, input, expected) in CASES {
+        let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
+        let expected: Vec<String> = expected.iter().map(|arg| (*arg).to_string()).collect();
+        assert_eq!(provider_args(&argv), expected, "{id}");
+    }
 }
 
 // =========================================================================
@@ -47,118 +33,72 @@ fn provider_args_lone_dashdash_yields_empty() {
 // =========================================================================
 
 #[test]
-fn leader_launcher_args_empty_all_default() {
-    // golden: {'provider_args': [], 'attach_existing': False, 'confirm_attach': False, 'attach_session': None}
-    let got = leader_launcher_args(&[]).expect("empty should parse");
-    assert_eq!(got, LeaderLauncherArgs::default());
-    assert!(got.provider_args.is_empty());
-    assert!(!got.attach_existing);
-    assert!(!got.confirm_attach);
-    assert_eq!(got.attach_session, None);
-    assert!(!got.external_leader);
-}
-
-#[test]
-fn leader_launcher_args_attach_and_confirm() {
-    // golden: ["--attach","--confirm"] -> attach_existing=True, confirm_attach=True
-    let got = leader_launcher_args(&["--attach".into(), "--confirm".into()]).unwrap();
-    assert!(got.attach_existing);
-    assert!(got.confirm_attach);
-    assert!(got.provider_args.is_empty());
-    assert_eq!(got.attach_session, None);
-}
-
-#[test]
-fn leader_launcher_args_attach_existing_alias() {
-    // golden: ["--attach-existing"] -> attach_existing=True (alias of --attach)
-    let got = leader_launcher_args(&["--attach-existing".into()]).unwrap();
-    assert!(got.attach_existing);
-    assert!(!got.confirm_attach);
-}
-
-#[test]
-fn leader_launcher_args_external_leader_opt_out() {
-    let got = leader_launcher_args(&[
-        "--external-leader".into(),
-        "--".into(),
-        "--model".into(),
-        "opus".into(),
-    ])
-    .unwrap();
-    assert!(got.external_leader);
-    assert!(!got.attach_existing);
-    assert_eq!(
-        got.provider_args,
-        vec!["--model".to_string(), "opus".to_string()]
-    );
-}
-
-#[test]
-fn leader_launcher_args_external_leader_after_dashdash_errors() {
-    let err = leader_launcher_args(&["--".into(), "--external-leader".into()])
-        .expect_err("Team Agent flags after -- must not be silently passed to provider");
-    assert!(
-        err.to_string()
-            .contains("Team Agent launcher flag --external-leader must appear before --"),
-        "unexpected error: {err}"
-    );
-}
-
-#[test]
-fn leader_launcher_args_attach_session_spaced() {
-    // golden: ["--attach-session","mysess"] -> attach_session="mysess"
-    let got = leader_launcher_args(&["--attach-session".into(), "mysess".into()]).unwrap();
-    assert_eq!(got.attach_session, Some("mysess".to_string()));
-    assert!(!got.attach_existing);
-}
-
-#[test]
-fn leader_launcher_args_attach_session_equals() {
-    // golden: ["--attach-session=mysess"] -> attach_session="mysess"
-    let got = leader_launcher_args(&["--attach-session=mysess".into()]).unwrap();
-    assert_eq!(got.attach_session, Some("mysess".to_string()));
-}
-
-#[test]
-fn leader_launcher_args_dashdash_passthrough_strips_separator() {
-    // ["--attach","--","-x","--provider-confirm"] ->
-    //   provider_args=["-x","--provider-confirm"], attach_existing=True, confirm_attach=False
-    // Known Team Agent launcher flags after `--` are rejected by a separate guard.
-    let got = leader_launcher_args(&[
-        "--attach".into(),
-        "--".into(),
-        "-x".into(),
-        "--provider-confirm".into(),
-    ])
-    .unwrap();
-    assert!(got.attach_existing);
-    assert!(!got.confirm_attach);
-    assert_eq!(
-        got.provider_args,
-        vec!["-x".to_string(), "--provider-confirm".to_string()]
-    );
-}
-
-#[test]
-fn leader_launcher_args_unknown_tokens_collect_as_provider_args() {
-    // golden: ["foo","--attach","bar"] -> provider_args=["foo","bar"], attach_existing=True
-    let got = leader_launcher_args(&["foo".into(), "--attach".into(), "bar".into()]).unwrap();
-    assert_eq!(
-        got.provider_args,
-        vec!["foo".to_string(), "bar".to_string()]
-    );
-    assert!(got.attach_existing);
-}
-
-#[test]
-fn leader_launcher_args_attach_session_missing_value_errors() {
-    // golden: ["--attach-session"] raises RuntimeError("--attach-session requires a tmux session name")
-    let err = leader_launcher_args(&["--attach-session".into()]).unwrap_err();
-    let msg = err.to_string();
-    assert!(
-        msg.contains("--attach-session requires a tmux session name"),
-        "expected exact missing-value message, got: {msg}"
-    );
+fn leader_launcher_args_success_cases() {
+    // (old case-id, argv, complete expected structure), including default false flags.
+    let cases: &[(&str, &[&str], LeaderLauncherArgs)] = &[
+        ("leader_launcher_args_empty_all_default", &[], LeaderLauncherArgs::default()),
+        ("leader_launcher_args_attach_and_confirm", &["--attach", "--confirm"], LeaderLauncherArgs {
+            attach_existing: true,
+            confirm_attach: true,
+            ..Default::default()
+        }),
+        // --attach-existing is an alias of --attach.
+        ("leader_launcher_args_attach_existing_alias", &["--attach-existing"], LeaderLauncherArgs {
+            attach_existing: true,
+            ..Default::default()
+        }),
+        ("leader_launcher_args_external_leader_opt_out", &["--external-leader", "--", "--model", "opus"], LeaderLauncherArgs {
+            provider_args: vec!["--model".to_string(), "opus".to_string()],
+            external_leader: true,
+            ..Default::default()
+        }),
+        ("leader_launcher_args_attach_session_spaced", &["--attach-session", "mysess"], LeaderLauncherArgs {
+            attach_session: Some("mysess".to_string()),
+            ..Default::default()
+        }),
+        ("leader_launcher_args_attach_session_equals", &["--attach-session=mysess"], LeaderLauncherArgs {
+            attach_session: Some("mysess".to_string()),
+            ..Default::default()
+        }),
+        // Known Team Agent launcher flags after `--` are rejected by the error table.
+        ("leader_launcher_args_dashdash_passthrough_strips_separator", &["--attach", "--", "-x", "--provider-confirm"], LeaderLauncherArgs {
+            provider_args: vec!["-x".to_string(), "--provider-confirm".to_string()],
+            attach_existing: true,
+            ..Default::default()
+        }),
+        ("leader_launcher_args_unknown_tokens_collect_as_provider_args", &["foo", "--attach", "bar"], LeaderLauncherArgs {
+            provider_args: vec!["foo".to_string(), "bar".to_string()],
+            attach_existing: true,
+            ..Default::default()
+        }),
+    ];
+    for (id, input, expected) in cases {
+        let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
+        let got = leader_launcher_args(&argv).unwrap_or_else(|err| panic!("{id}: {err}"));
+        assert_eq!(got, *expected, "{id}");
+    }
+}
+
+#[test]
+fn leader_launcher_args_error_cases() {
+    // Preserve the original error-substring contract, rather than requiring exact equality.
+    const CASES: &[(&str, &[&str], &str)] = &[
+        (
+            "leader_launcher_args_external_leader_after_dashdash_errors",
+            &["--", "--external-leader"],
+            "Team Agent launcher flag --external-leader must appear before --",
+        ),
+        (
+            "leader_launcher_args_attach_session_missing_value_errors",
+            &["--attach-session"],
+            "--attach-session requires a tmux session name",
+        ),
+    ];
+    for (id, input, expected) in CASES {
+        let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
+        let err = leader_launcher_args(&argv).expect_err(id);
+        assert!(err.to_string().contains(*expected), "{id}: unexpected error: {err}");
+    }
 }
 
 // =========================================================================
@@ -166,37 +106,22 @@ fn leader_launcher_args_attach_session_missing_value_errors() {
 // =========================================================================
 
 #[test]
-fn send_target_fanout_strips_and_filters_empty() {
-    // golden: _send_target(targets="a, b ,,c") == ["a","b","c"]
-    let got = send_target(Some("a, b ,,c"), None);
-    assert_eq!(
-        got,
-        MessageTarget::Fanout(vec!["a".to_string(), "b".to_string(), "c".to_string()])
-    );
-}
-
-#[test]
-fn send_target_single_target() {
-    // golden: _send_target(target="agent_x") == "agent_x"
-    assert_eq!(
-        send_target(None, Some("agent_x")),
-        MessageTarget::Single("agent_x".to_string())
-    );
-}
-
-#[test]
-fn send_target_broadcast_star() {
-    // skeleton contract: bare "*" target -> Broadcast (send.py interprets "*" as全队广播)
-    assert_eq!(send_target(None, Some("*")), MessageTarget::Broadcast);
-}
-
-#[test]
-fn send_target_empty_targets_falls_through_to_target() {
-    // golden: targets="" is falsy in Python -> returns args.target ("fallback")
-    assert_eq!(
-        send_target(Some(""), Some("fallback")),
-        MessageTarget::Single("fallback".to_string())
-    );
+fn send_target_cases() {
+    // (old case-id, targets, target, complete expected enum).
+    let cases: &[(&str, Option<&str>, Option<&str>, MessageTarget)] = &[
+        (
+            "send_target_fanout_strips_and_filters_empty", Some("a, b ,,c"), None,
+            MessageTarget::Fanout(vec!["a".to_string(), "b".to_string(), "c".to_string()]),
+        ),
+        ("send_target_single_target", None, Some("agent_x"), MessageTarget::Single("agent_x".to_string())),
+        // A bare "*" means broadcast to the whole team.
+        ("send_target_broadcast_star", None, Some("*"), MessageTarget::Broadcast),
+        // targets="" is falsy in Python, so it falls through to args.target.
+        ("send_target_empty_targets_falls_through_to_target", Some(""), Some("fallback"), MessageTarget::Single("fallback".to_string())),
+    ];
+    for (id, targets, target, expected) in cases {
+        assert_eq!(send_target(*targets, *target), *expected, "{id}");
+    }
 }
 
 // =========================================================================
@@ -205,61 +130,23 @@ fn send_target_empty_targets_falls_through_to_target() {
 // =========================================================================
 
 #[test]
-fn classify_failed_takes_priority() {
-    // raw in {failed,error} OR hstatus in {failed,error} -> Failed
-    assert_eq!(classify_agent_bucket("failed", ""), SummaryBucket::Failed);
-    assert_eq!(classify_agent_bucket("error", ""), SummaryBucket::Failed);
-    assert_eq!(
-        classify_agent_bucket("running", "error"),
-        SummaryBucket::Failed
-    );
-}
-
-#[test]
-fn classify_stopped() {
-    // raw in {stopped,done} OR hstatus==done -> Stopped
-    assert_eq!(classify_agent_bucket("stopped", ""), SummaryBucket::Stopped);
-    assert_eq!(classify_agent_bucket("done", ""), SummaryBucket::Stopped);
-    assert_eq!(
-        classify_agent_bucket("running", "done"),
-        SummaryBucket::Stopped
-    );
-}
-
-#[test]
-fn classify_busy() {
-    // raw==busy OR hstatus in {running,working} -> Busy
-    assert_eq!(classify_agent_bucket("busy", ""), SummaryBucket::Busy);
-    assert_eq!(classify_agent_bucket("", "running"), SummaryBucket::Busy);
-    assert_eq!(classify_agent_bucket("", "working"), SummaryBucket::Busy);
-}
-
-#[test]
-fn classify_hstatus_idle_beats_raw_running() {
-    // golden: raw=running, h=idle -> idle  (hstatus==idle branch precedes raw==running branch)
-    assert_eq!(
-        classify_agent_bucket("running", "idle"),
-        SummaryBucket::Idle
-    );
-}
-
-#[test]
-fn classify_pure_running() {
-    // raw==running, no overriding hstatus -> Running
-    assert_eq!(classify_agent_bucket("running", ""), SummaryBucket::Running);
-}
-
-#[test]
-fn classify_blocked_and_unmatched_are_unknown_never_idle() {
-    // bug-071/077/085: blocked/stuck/missing AND any unmatched value -> Unknown, NOT idle.
-    assert_eq!(classify_agent_bucket("blocked", ""), SummaryBucket::Unknown);
-    assert_eq!(classify_agent_bucket("stuck", ""), SummaryBucket::Unknown);
-    assert_eq!(classify_agent_bucket("", "missing"), SummaryBucket::Unknown);
-    assert_eq!(
-        classify_agent_bucket("weird_value", ""),
-        SummaryBucket::Unknown
-    );
-    assert_eq!(classify_agent_bucket("", ""), SummaryBucket::Unknown);
+fn classify_agent_bucket_cases() {
+    // (old case-id, all original (raw, health) inputs, expected bucket).
+    const CASES: &[(&str, &[(&str, &str)], SummaryBucket)] = &[
+        ("classify_failed_takes_priority", &[("failed", ""), ("error", ""), ("running", "error")], SummaryBucket::Failed),
+        ("classify_stopped", &[("stopped", ""), ("done", ""), ("running", "done")], SummaryBucket::Stopped),
+        ("classify_busy", &[("busy", ""), ("", "running"), ("", "working")], SummaryBucket::Busy),
+        // hstatus==idle precedes the raw==running branch.
+        ("classify_hstatus_idle_beats_raw_running", &[("running", "idle")], SummaryBucket::Idle),
+        ("classify_pure_running", &[("running", "")], SummaryBucket::Running),
+        // bug-071/077/085: unmatched and blocked/stuck/missing are Unknown, NEVER idle.
+        ("classify_blocked_and_unmatched_are_unknown_never_idle", &[("blocked", ""), ("stuck", ""), ("", "missing"), ("weird_value", ""), ("", "")], SummaryBucket::Unknown),
+    ];
+    for (id, inputs, expected) in CASES {
+        for &(raw, health) in inputs.iter() {
+            assert_eq!(classify_agent_bucket(raw, health), *expected, "{id}: raw={raw:?}, health={health:?}");
+        }
+    }
 }
 
 #[test]

package/crates/team-agent/src/compiler/tests.rs

@@ -119,65 +119,52 @@ Implement bounded tasks and report result_envelope_v1.
 // ───────────────────────────── read_front_matter ─────────────────────────────
 
 #[test]
-fn front_matter_no_marker_returns_empty_meta_and_full_text() {
-    // No leading "---\n" → ({}, text) verbatim (compiler.py:175-176).
-    let p = write_tmp("no_marker.md", "hello\nworld\n");
-    let (meta, body) = read_front_matter(&p).unwrap();
-    assert_eq!(meta, Value::Map(vec![]));
-    assert_eq!(body, "hello\nworld\n");
-}
-
-#[test]
-fn front_matter_basic_splits_meta_and_lstrips_body() {
-    let p = write_tmp("basic.md", "---\nname: x\nrole: R\n---\n\nbody line\n");
-    let (meta, body) = read_front_matter(&p).unwrap();
-    assert_eq!(
-        meta,
-        Value::Map(vec![
-            ("name".to_string(), Value::Str("x".to_string())),
-            ("role".to_string(), Value::Str("R".to_string())),
-        ])
-    );
-    assert_eq!(body, "body line\n");
-}
-
-#[test]
-fn front_matter_empty_block_is_empty_map() {
-    // "---\n\n---\nbody\n": closing marker at the blank line → raw "" → {} ; body "body\n".
-    let p = write_tmp("empty.md", "---\n\n---\nbody\n");
-    let (meta, body) = read_front_matter(&p).unwrap();
-    assert_eq!(meta, Value::Map(vec![]));
-    assert_eq!(body, "body\n");
-}
-
-#[test]
-fn front_matter_body_lstrip_strips_only_newlines() {
-    // body.lstrip("\n") removes leading NEWLINES but keeps the 2-space indent.
-    let p = write_tmp("lstrip.md", "---\nname: x\n---\n\n\n  indented body\n");
-    let (meta, body) = read_front_matter(&p).unwrap();
-    assert_eq!(
-        meta,
-        Value::Map(vec![("name".to_string(), Value::Str("x".to_string()))])
-    );
-    assert_eq!(body, "  indented body\n");
-}
-
-#[test]
-fn front_matter_unterminated_falls_back_to_plain_text() {
-    let text = "---\nname: x\n";
-    let p = write_tmp("unterminated.md", text);
-    let (meta, body) = read_front_matter(&p).expect("unterminated front matter is plain text");
-    assert_eq!(meta, Value::Map(Vec::new()));
-    assert_eq!(body, text);
-}
-
-#[test]
-fn front_matter_non_object_falls_back_to_plain_text() {
-    let text = "---\n- a\n- b\n---\nbody\n";
-    let p = write_tmp("list.md", text);
-    let (meta, body) = read_front_matter(&p).expect("non-object front matter is plain text");
-    assert_eq!(meta, Value::Map(Vec::new()));
-    assert_eq!(body, text);
+fn front_matter_cases() {
+    struct Case {
+        id: &'static str,
+        file: &'static str,
+        text: &'static str,
+        meta: &'static [(&'static str, &'static str)],
+        body: &'static str,
+    }
+    const CASES: &[Case] = &[
+        // No leading "---\n" → ({}, text) verbatim (compiler.py:175-176).
+        Case {
+            id: "front_matter_no_marker_returns_empty_meta_and_full_text", file: "no_marker.md",
+            text: "hello\nworld\n", meta: &[], body: "hello\nworld\n",
+        },
+        Case {
+            id: "front_matter_basic_splits_meta_and_lstrips_body", file: "basic.md",
+            text: "---\nname: x\nrole: R\n---\n\nbody line\n", meta: &[("name", "x"), ("role", "R")], body: "body line\n",
+        },
+        // Closing marker at the blank line → raw "" → {}; body "body\n".
+        Case {
+            id: "front_matter_empty_block_is_empty_map", file: "empty.md",
+            text: "---\n\n---\nbody\n", meta: &[], body: "body\n",
+        },
+        // body.lstrip("\n") removes leading NEWLINES but keeps the 2-space indent.
+        Case {
+            id: "front_matter_body_lstrip_strips_only_newlines", file: "lstrip.md",
+            text: "---\nname: x\n---\n\n\n  indented body\n", meta: &[("name", "x")], body: "  indented body\n",
+        },
+        Case {
+            id: "front_matter_unterminated_falls_back_to_plain_text", file: "unterminated.md",
+            text: "---\nname: x\n", meta: &[], body: "---\nname: x\n",
+        },
+        Case {
+            id: "front_matter_non_object_falls_back_to_plain_text", file: "list.md",
+            text: "---\n- a\n- b\n---\nbody\n", meta: &[], body: "---\n- a\n- b\n---\nbody\n",
+        },
+    ];
+    for case in CASES {
+        let p = write_tmp(case.file, case.text);
+        let (meta, body) = read_front_matter(&p).unwrap_or_else(|err| panic!("{}: {err}", case.id));
+        let expected_meta = Value::Map(case.meta.iter().map(|(key, value)| {
+            ((*key).to_string(), Value::Str((*value).to_string()))
+        }).collect());
+        assert_eq!(meta, expected_meta, "{}: metadata", case.id);
+        assert_eq!(body, case.body, "{}: body", case.id);
+    }
 }
 
 // ───────────────────────────── compile_team: full dict parity ─────────────────────────────

package/crates/team-agent/src/leader/tests/byte_findings.rs

@@ -54,8 +54,7 @@ fn d1_claim_team_owner_includes_os_user() {
 // fingerprint/requested_provider/warning. Golden _receiver_from_claim_target (__init__.py:861-877).
 // Rust LeaderReceiver serializes all 17 (no skip_serializing_if) -> 3 always-null extras leak. RED.
 // (The POPULATED tmux values session_name/window_*/pane_* come from the caller-target scan — a
-// deferred real-tmux seam, see d2_receiver_populated_from_caller_target_seam; the KEY-SET + ORDER
-// locked here are unchanged by that scan.)
+// deferred real-tmux seam; the KEY-SET + ORDER locked here are unchanged by that scan.)
 #[test]
 #[serial_test::serial(env)]
 fn d2_claim_leader_receiver_is_fifteen_golden_keys_in_order_no_extras() {
@@ -98,18 +97,6 @@ fn d2_claim_leader_receiver_is_fifteen_golden_keys_in_order_no_extras() {
         ], "golden _receiver_from_claim_target 15-key set + ORDER (__init__.py:861-877 + BUG-4 socket-qualified receiver)");
 }
 
-// D2 seam — the caller-target SCAN that fills session_name/window_index/window_name/pane_index/
-// pane_tty/pane_current_command from core_list_targets (golden _receiver_from_claim_target reads
-// target[...]). Rust make_receiver leaves them None (no scan). Real-tmux: needs core_list_targets.
-#[test]
-#[ignore = "real-tmux seam: leader_receiver session_name/window_*/pane_* are populated from the \
-                caller target via core_list_targets (golden _receiver_from_claim_target); Rust has no \
-                scan (values null). Porter wires the target scan; this asserts the populated values."]
-fn d2_receiver_populated_from_caller_target_seam() {
-    // Golden contract: new_receiver.session_name == caller_target.session_name, etc. Needs a live
-    // tmux target list (core_list_targets) — out of in-process scope.
-}
-
 // D3 [BLOCK] — bound_pane is RECEIVER-first (golden :624 receiver.pane_id OR owner.pane_id). PROBE-B
 // (receiver=%9, owner=%1, caller=%9): golden ok=True already_bound. Rust derives OWNER-first
 // (owner %1 != caller %9) -> owner live + !confirm -> refused force_confirm_required. RED.