@team-agent/installer 0.5.66 → 0.5.68

package/crates/team-agent/src/lifecycle/tests/lane_ops.rs

@@ -201,7 +201,13 @@ impl crate::transport::Transport for LaneTransport {
         r: crate::transport::CaptureRange,
     ) -> Result<crate::transport::CapturedText, crate::transport::TransportError> {
         Ok(crate::transport::CapturedText {
-            text: String::new(),
+            // A fresh worker has reached the ready prompt by the time this
+            // deterministic lifecycle replay observes its pane.  Returning
+            // the stable ready marker keeps the replay focused on the
+            // single-lock transaction instead of burning the provider's
+            // bounded startup-prompt polling interval on an unobservable
+            // empty screen.
+            text: "OpenAI Codex\n›".to_string(),
             range: r,
         })
     }
@@ -1390,9 +1396,11 @@ fn remove_preserves_external_role_source_for_both_flag_forms() {
     }
 }
 
-// A-28 RED: the role markdown recorded for a seat is still a user asset. The
-// default remove path must unregister the seat without deleting the managed
-// registration-path document.
+// A-28 was: default remove must preserve registered managed markdown.
+// ledger.seat-supply-prereq overturned that for files under
+// `.team/dynamic-role-files/` (framework materialization, not user asset).
+// Keep the test name; flip the assertion. External --role-file is covered
+// by `remove_preserves_external_role_source_for_both_flag_forms`.
 #[test]
 fn remove_agent_preserves_registered_role_markdown_by_default() {
     let ws = lanea_ws_agents(json!({
@@ -1417,15 +1425,13 @@ fn remove_agent_preserves_registered_role_markdown_by_default() {
         None,
         &LaneTransport::new("team-laneateam", &[]),
     );
-    assert!(result.is_ok(), "remove-agent should unregister the seat: {result:?}");
     assert!(
-        role.exists(),
-        "A-28: remove-agent must preserve the registered role markdown by default"
+        result.is_ok(),
+        "remove-agent should unregister the seat: {result:?}"
     );
-    assert_eq!(
-        std::fs::read(&role).unwrap(),
-        original,
-        "A-28: remove-agent must preserve the registered role markdown by default"
+    assert!(
+        !role.exists(),
+        "managed role markdown must be gone after remove-agent so the next same-id clone is not blocked"
     );
 }
 
@@ -1455,7 +1461,35 @@ fn remove_preserves_managed_path_symlink_escape() {
     );
     assert!(result.is_ok(), "remove failed: {result:?}");
     assert_eq!(std::fs::read(&external).unwrap(), b"external target\n");
-    assert!(managed.exists(), "symlink escape must be preserved");
+    assert!(
+        !managed.symlink_metadata().is_ok(),
+        "managed symlink must be unlinked; must not follow and delete the external target"
+    );
+}
+
+#[test]
+fn remove_agent_deletes_unrecorded_default_managed_role() {
+    let ws = lanea_ws_agents(json!({
+        "alpha": { "status": "stopped", "provider": "codex", "window": "alpha" },
+        "bravo": { "status": "stopped", "provider": "codex", "window": "bravo" }
+    }));
+    let role = ws.join(".team").join("dynamic-role-files").join("alpha.md");
+    std::fs::create_dir_all(role.parent().unwrap()).unwrap();
+    std::fs::write(&role, b"unrecorded default managed copy\n").unwrap();
+
+    let result = remove_agent_with_transport(
+        &ws,
+        &aid("alpha"),
+        true,
+        true,
+        None,
+        &LaneTransport::new("team-laneateam", &[]),
+    );
+    assert!(result.is_ok(), "remove failed: {result:?}");
+    assert!(
+        !role.exists(),
+        "default managed path must be cleared even when state.dynamic_role_file is unset"
+    );
 }
 
 #[test]
@@ -1659,9 +1693,8 @@ fn lanea_fork_dup_target_leader_id_is_already_exists() {
         fork_agent_with_transport(&ws, &aid("alpha"), &aid("leader"), None, false, None, &tx)
     );
     assert!(
-        text.contains("already exists"),
-        "golden operations.py:301-302 (_find_agent matches the leader): forking ONTO the leader id must raise \
-         'agent id already exists: leader'; Rust skips the dup guard for the leader id and proceeds. got {text}"
+        text.contains("unverified") || text.contains("未验证") || text.contains("refuses --as"),
+        "codex in-window fork is unverified; leader-id duplicate is not reached. got {text}"
     );
 }
 
@@ -1679,9 +1712,11 @@ fn lanea_fork_window_already_exists_guard_before_spec_mutation() {
         fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx)
     );
     assert!(
-        text.contains("tmux window already exists for fork target: team-laneateam:newfork"),
-        "golden operations.py:310-312: a pre-existing target window must raise 'tmux window already exists for \
-         fork target: team-laneateam:newfork' BEFORE spec mutation; Rust has no guard. got {text}"
+        text.contains("unverified")
+            || text.contains("未验证")
+            || text.contains("refuses --as")
+            || text.contains("tmux window already exists for fork target: team-laneateam:newfork"),
+        "codex in-window fork is unverified; window-exists guard is not reached. got {text}"
     );
     let spec_text = std::fs::read_to_string(ws.join("team.spec.yaml")).unwrap();
     assert!(
@@ -1705,9 +1740,8 @@ fn lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm() {
         fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx);
     let text = format!("{result:?}");
     assert!(
-        text.contains("codex does not support native session fork"),
-        "golden operations.py:329-330: the native-fork gate must raise 'codex does not support native session \
-         fork'; Rust surfaces the generic 'capability unsupported: Codex:fork'. got {text}"
+        text.contains("unverified") || text.contains("未验证"),
+        "codex is unverified (any auth), not 'does not support'. got {text}"
     );
     let spec_text = std::fs::read_to_string(ws.join("team.spec.yaml")).unwrap();
     assert!(
@@ -1736,25 +1770,16 @@ fn lanea_fork_report_session_id_is_not_pane_id() {
         json!(discoverable_source.to_string_lossy().to_string());
     crate::state::persist::save_runtime_state(&ws, &state).unwrap();
     let tx = LaneTransport::new("team-laneateam", &[]);
-    let report =
-        fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx)
-            .expect("fork ok (codex subscription supports fork)");
-    assert_ne!(
-        report.session_id,
-        Some(crate::provider::SessionId::new("%newfork")),
-        "golden operations.py:399,408: report.session_id is the captured provider session id / None, NEVER the \
-         tmux pane id; Rust returns Some(pane_id='%newfork')"
-    );
+    let result =
+        fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx);
+    let err = match result {
+        Err(error) => error.to_string(),
+        Ok(_) => panic!("codex in-window fork is unverified and must refuse"),
+    };
     assert!(
-        report.session_id.is_some(),
-        "a successful fork must carry the verified NEW provider session id"
+        err.contains("unverified") || err.contains("未验证"),
+        "codex must refuse as unverified; got {err}"
     );
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    let row = &state["agents"]["newfork"];
-    assert!(row["spawned_at"]
-        .as_str()
-        .is_some_and(|value| chrono::DateTime::parse_from_rfc3339(value).is_ok()));
-    assert_eq!(row["spawn_epoch"], serde_json::json!(1));
 }
 
 #[test]

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -2638,10 +2638,11 @@ fn fork_refuses_source_with_partial_tuple() {
     );
     let err = result.unwrap_err().to_string();
     assert!(
-        err.contains("source session backing is missing")
+        err.contains("unverified")
+            || err.contains("未验证")
             || err.contains("backing")
             || err.contains("incomplete"),
-        "0.4.6: fork refusal must name backing/incomplete cause; got error={err}"
+        "0.4.6/in-window: unverified providers refuse before backing check; got error={err}"
     );
 }
 

package/crates/team-agent/src/lifecycle/tests/lifecycle_rollback_red.rs

@@ -92,23 +92,31 @@ fn fork_agent_rollback_cleans_spawned_window_spec_state_and_mcp_after_post_spawn
 
     assert!(
         result.is_err(),
-        "failure-injection hook {FAIL_FORK_AFTER_SPAWN}=save_runtime_state must fail after spawn so post-spawn rollback is exercised; result={result:?}"
+        "in-window fork on this fixture must refuse before spawn; result={result:?}"
     );
+    let err = format!("{result:?}");
     assert!(
-        transport
-            .killed()
-            .contains(&"team-rollbackteam:newfork".to_string()),
-        "fork post-spawn rollback must kill the already-spawned window; killed={:?} result={result:?}",
+        err.contains("unverified") || err.contains("未验证") || err.contains("refuses --as"),
+        "codex in-window fork is unverified / --as is refused; no spawn to roll back. result={result:?}"
+    );
+    assert!(
+        transport.killed().is_empty(),
+        "unverified/in-place fork must not spawn a window to kill; killed={:?} result={result:?}",
         transport.killed()
     );
     assert_eq!(
         spec_after, spec_before,
-        "fork post-spawn rollback must restore team.spec.yaml byte-for-byte; result={result:?}"
+        "refused in-window fork must not mutate team.spec.yaml; result={result:?}"
+    );
+    assert!(
+        state_after
+            .pointer("/agents/newfork")
+            .is_none(),
+        "refused in-window fork must not create a newfork row; state={state_after}"
     );
-    assert_failed_fork_has_only_target_tombstone(&state_after, "newfork", "rollbackteam");
     assert!(
         !mcp_path.exists(),
-        "fork post-spawn rollback must cleanup the MCP config written for the half-created agent; leaked={}",
+        "refused in-window fork must not write MCP config; leaked={}",
         mcp_path.display()
     );
 

package/crates/team-agent/src/lifecycle/tests/mcp_tool_name_format_red.rs

@@ -0,0 +1,69 @@
+//! purpose: worker 契约里的 MCP 工具名必须按 provider 实测书写形式渲染
+//! contract:
+//!   claude → mcp__team_orchestrator__send_message / mcp__team_orchestrator__report_result
+//!   grok   → team_orchestrator__send_message / team_orchestrator__report_result
+//!   已验证 provider 的渲染结果不得再含 `team_orchestrator.` 点号
+//! boundary: 只钉 compile_worker_system_prompt 字面；未验证 provider 不在此猜形式
+
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use crate::lifecycle::worker_command_context::{compile_worker_system_prompt, WorkerCommandAgent};
+use crate::model::enums::Provider;
+
+fn compiled_prompt(provider: Provider) -> String {
+    let agent = WorkerCommandAgent::from_json(
+        &serde_json::json!({
+            "id": "w",
+            "role": "developer",
+            "tools": ["mcp_team"],
+            "output_contract": {"format": "result_envelope_v1"},
+        }),
+        Some("w"),
+        provider,
+    )
+    .expect("test agent");
+    compile_worker_system_prompt(&agent).expect("compile prompt")
+}
+
+#[test]
+fn claude_runtime_contract_pins_mcp_double_underscore_literals() {
+    for provider in [Provider::Claude, Provider::ClaudeCode] {
+        let prompt = compiled_prompt(provider);
+        assert!(
+            prompt.contains("mcp__team_orchestrator__report_result"),
+            "{provider:?} must render the claude transcript literal mcp__team_orchestrator__report_result; prompt={prompt}"
+        );
+        assert!(
+            prompt.contains("mcp__team_orchestrator__send_message"),
+            "{provider:?} must render the claude transcript literal mcp__team_orchestrator__send_message; prompt={prompt}"
+        );
+    }
+}
+
+#[test]
+fn grok_runtime_contract_pins_server_double_underscore_literals() {
+    let prompt = compiled_prompt(Provider::Grok);
+    assert!(
+        prompt.contains("team_orchestrator__report_result"),
+        "grok must render team_orchestrator__report_result; prompt={prompt}"
+    );
+    assert!(
+        prompt.contains("team_orchestrator__send_message"),
+        "grok must render team_orchestrator__send_message; prompt={prompt}"
+    );
+    assert!(
+        !prompt.contains("mcp__team_orchestrator"),
+        "grok must not use the claude mcp__ prefix; prompt={prompt}"
+    );
+}
+
+#[test]
+fn verified_provider_contracts_do_not_teach_dotted_tool_names() {
+    for provider in [Provider::Claude, Provider::ClaudeCode, Provider::Grok] {
+        let prompt = compiled_prompt(provider);
+        assert!(
+            !prompt.contains("team_orchestrator."),
+            "{provider:?} contract must not contain the dotted form team_orchestrator.; prompt={prompt}"
+        );
+    }
+}

package/crates/team-agent/src/lifecycle/tests/phase_b_contracts.rs

@@ -204,17 +204,21 @@ fn add_fork_remove_share_lifecycle_lock_behavior() {
         Duration::from_millis(120),
         Duration::from_secs(5),
     );
-    assert_lock_timeout(
-        crate::lifecycle::fork_agent_with_transport(
-            &fork_workspace,
-            &aid("alpha"),
-            &fork_agent,
-            None,
-            false,
-            None,
-            &fork_transport,
-        ),
-        "fork-agent",
+    let fork_held = crate::lifecycle::fork_agent_with_transport(
+        &fork_workspace,
+        &aid("alpha"),
+        &fork_agent,
+        None,
+        false,
+        None,
+        &fork_transport,
+    );
+    let fork_held_text = format!("{fork_held:?}");
+    assert!(
+        fork_held_text.contains("unverified")
+            || fork_held_text.contains("未验证")
+            || fork_held_text.contains("LifecycleLockTimeout"),
+        "codex in-window fork is unverified (lock is not reached); got {fork_held:?}"
     );
     assert!(
         fork_transport.spawns().is_empty(),
@@ -232,7 +236,7 @@ fn add_fork_remove_share_lifecycle_lock_behavior() {
     );
     drop(override_guard);
     drop(held);
-    crate::lifecycle::fork_agent_with_transport(
+    let fork_after = crate::lifecycle::fork_agent_with_transport(
         &fork_workspace,
         &aid("alpha"),
         &fork_agent,
@@ -240,14 +244,11 @@ fn add_fork_remove_share_lifecycle_lock_behavior() {
         false,
         None,
         &fork_transport,
-    )
-    .expect("fork-agent succeeds after lock release");
+    );
+    let fork_after_text = format!("{fork_after:?}");
     assert!(
-        crate::state::persist::load_runtime_state(&fork_workspace)
-            .unwrap()
-            .pointer("/agents/newfork")
-            .is_some(),
-        "released fork-agent must add the fork row"
+        fork_after_text.contains("unverified") || fork_after_text.contains("未验证"),
+        "codex in-window fork stays unverified after lock release; got {fork_after:?}"
     );
 
     let remove_workspace = lanea_team_ws("stopped");

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -102,18 +102,10 @@ fn phase_b_golden_events_state_status_zero_drift() {
         team_key: "teamdir",
         lifecycle_op: phase_b_reset_discard_session,
     });
-    if std::env::var_os("TEAM_AGENT_UPDATE_GOLDEN").is_some() {
-        std::fs::create_dir_all(baseline.parent().expect("baseline parent")).unwrap();
-        std::fs::write(&baseline, pretty(&actual)).unwrap();
-        return;
-    }
-    let expected = std::fs::read_to_string(&baseline)
-        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", baseline.display()));
-    let expected: Value = serde_json::from_str(&expected).expect("parse golden baseline");
+    let expected = load_phase_golden(&baseline);
     assert_eq!(
-        actual,
-        expected,
-        "phase B golden drift; update intentionally with TEAM_AGENT_UPDATE_GOLDEN=1 only after review"
+        actual, expected,
+        "phase B golden drift; surgical key edits only — do not regenerate the file"
     );
 }
 
@@ -126,18 +118,10 @@ fn phase_c_golden_events_state_status_zero_drift() {
         team_key: "teamdir",
         lifecycle_op: phase_b_reset_discard_session,
     });
-    if std::env::var_os("TEAM_AGENT_UPDATE_GOLDEN").is_some() {
-        std::fs::create_dir_all(baseline.parent().expect("baseline parent")).unwrap();
-        std::fs::write(&baseline, pretty(&actual)).unwrap();
-        return;
-    }
-    let expected = std::fs::read_to_string(&baseline)
-        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", baseline.display()));
-    let expected: Value = serde_json::from_str(&expected).expect("parse golden baseline");
+    let expected = load_phase_golden(&baseline);
     assert_eq!(
-        actual,
-        expected,
-        "phase C golden drift; update intentionally with TEAM_AGENT_UPDATE_GOLDEN=1 only after review"
+        actual, expected,
+        "phase C golden drift; surgical key edits only — do not regenerate the file"
     );
 }
 
@@ -150,18 +134,10 @@ fn phase_d_golden_events_state_status_zero_drift() {
         team_key: "teamdir",
         lifecycle_op: phase_b_reset_discard_session,
     });
-    if std::env::var_os("TEAM_AGENT_UPDATE_GOLDEN").is_some() {
-        std::fs::create_dir_all(baseline.parent().expect("baseline parent")).unwrap();
-        std::fs::write(&baseline, pretty(&actual)).unwrap();
-        return;
-    }
-    let expected = std::fs::read_to_string(&baseline)
-        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", baseline.display()));
-    let expected: Value = serde_json::from_str(&expected).expect("parse golden baseline");
+    let expected = load_phase_golden(&baseline);
     assert_eq!(
-        actual,
-        expected,
-        "phase D golden drift; update intentionally with TEAM_AGENT_UPDATE_GOLDEN=1 only after review"
+        actual, expected,
+        "phase D golden drift; surgical key edits only — do not regenerate the file"
     );
 }
 
@@ -174,18 +150,10 @@ fn phase_e_golden_events_state_status_zero_drift() {
         team_key: "teamdir",
         lifecycle_op: phase_b_reset_discard_session,
     });
-    if std::env::var_os("TEAM_AGENT_UPDATE_GOLDEN").is_some() {
-        std::fs::create_dir_all(baseline.parent().expect("baseline parent")).unwrap();
-        std::fs::write(&baseline, pretty(&actual)).unwrap();
-        return;
-    }
-    let expected = std::fs::read_to_string(&baseline)
-        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", baseline.display()));
-    let expected: Value = serde_json::from_str(&expected).expect("parse golden baseline");
+    let expected = load_phase_golden(&baseline);
     assert_eq!(
-        actual,
-        expected,
-        "phase E golden drift; update intentionally with TEAM_AGENT_UPDATE_GOLDEN=1 only after review"
+        actual, expected,
+        "phase E golden drift; surgical key edits only — do not regenerate the file"
     );
 }
 
@@ -198,18 +166,39 @@ fn phase_f_golden_events_state_status_zero_drift() {
         team_key: "teamdir",
         lifecycle_op: phase_b_reset_discard_session,
     });
-    if std::env::var_os("TEAM_AGENT_UPDATE_GOLDEN").is_some() {
-        std::fs::create_dir_all(baseline.parent().expect("baseline parent")).unwrap();
-        std::fs::write(&baseline, pretty(&actual)).unwrap();
-        return;
-    }
-    let expected = std::fs::read_to_string(&baseline)
-        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", baseline.display()));
-    let expected: Value = serde_json::from_str(&expected).expect("parse golden baseline");
+    let expected = load_phase_golden(&baseline);
     assert_eq!(
-        actual,
-        expected,
-        "phase F golden drift; update intentionally with TEAM_AGENT_UPDATE_GOLDEN=1 only after review"
+        actual, expected,
+        "phase F golden drift; surgical key edits only — do not regenerate the file"
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn phase_golden_unbound_not_ready_requires_claim_leader() {
+    // 已废除的行为：旧实现只说不 ready、不说怎么恢复，把人晾在原地。此断言证明它确实没了。
+    // Independent of golden.json so a later regenerate cannot erase it.
+    // Companion status keys grok_slot ← 77bddb95 / 0c319cca; next_action ← 080903a2.
+    let compact = run_compact_status_after_quick_start();
+    let not_ready = compact
+        .get("not_ready")
+        .and_then(Value::as_object)
+        .unwrap_or_else(|| panic!("compact must carry not_ready; got {compact}"));
+    let reasons = not_ready
+        .get("reasons")
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default();
+    assert!(
+        reasons
+            .iter()
+            .any(|reason| reason.as_str() == Some("leader_receiver_unbound")),
+        "tombstone fixture must still produce leader_receiver_unbound; not_ready={not_ready:?}"
+    );
+    assert_eq!(
+        not_ready.get("next_action").and_then(Value::as_str),
+        Some("claim-leader"),
+        "when not_ready.reasons contains leader_receiver_unbound, next_action must be claim-leader; not_ready={not_ready:?}"
     );
 }
 
@@ -466,6 +455,59 @@ fn phase_fixture_path(phase: &str) -> PathBuf {
         .join(phase)
 }
 
+fn load_phase_golden(path: &Path) -> Value {
+    let text = std::fs::read_to_string(path)
+        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", path.display()));
+    let stripped = strip_full_line_json_comments(&text);
+    serde_json::from_str(&stripped).unwrap_or_else(|e| {
+        panic!(
+            "parse golden baseline {} after stripping // review comments: {e}",
+            path.display()
+        )
+    })
+}
+
+fn strip_full_line_json_comments(text: &str) -> String {
+    text.lines()
+        .filter(|line| !line.trim_start().starts_with("//"))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn run_compact_status_after_quick_start() -> Value {
+    let hermetic = HermeticTestEnv::enter("tombstone-claim-leader");
+    let _permission_mode = EnvVarGuard::set(ANCESTRY_ENV, "[]");
+    let team = two_worker_team_dir(&hermetic);
+    let workspace = team.parent().expect("workspace").to_path_buf();
+    seed_healthy_coordinator(&workspace);
+    let launch_transport = codex_ready_transport();
+    quick_start_with_transport_in_workspace_with_display(
+        &workspace,
+        &team,
+        None,
+        true,
+        None,
+        &launch_transport,
+        false,
+    )
+    .expect("tombstone fixture must quick-start");
+    let status = cmd_status(&StatusArgs {
+        agent: None,
+        workspace,
+        detail: false,
+        summary: false,
+        json: true,
+        team: Some("teamdir".to_string()),
+    });
+    match cmd_value(status) {
+        Value::Object(map) => map
+            .get("output")
+            .cloned()
+            .unwrap_or_else(|| panic!("compact status missing output")),
+        other => panic!("compact status must be a JSON object, got {other}"),
+    }
+}
+
 struct EnvVarGuard {
     key: &'static str,
     previous: Option<String>,
@@ -843,12 +885,6 @@ fn key_is_id(key: &str, text: &str) -> bool {
         || text.starts_with("msg_")
 }
 
-fn pretty(value: &Value) -> String {
-    let mut text = serde_json::to_string_pretty(value).unwrap();
-    text.push('\n');
-    text
-}
-
 #[test]
 fn phase_golden_normalizer_maps_custom_cargo_target_deps_binary_before_tmp_aliasing() {
     let ctx = NormalizeCtx {

package/crates/team-agent/src/lifecycle/tests/restart_rebind_hotfix_252_red.rs

@@ -1066,6 +1066,8 @@ fn provider_name(provider: Provider) -> &'static str {
         Provider::Codex => "codex",
         Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini",
+        Provider::Grok => "grok",
+        Provider::CursorAgent => "cursor_agent",
         Provider::Fake => "fake",
     }
 }