@team-agent/installer 0.5.105 → 0.5.107

package/crates/team-agent/src/model/yaml/tests.rs

@@ -5,9 +5,11 @@ use super::*;
 /// 把一段 YAML 文本经 `dumps(loads(t))` 往返,断言**逐字节**等于 Python golden。
 /// 这是 §4.2 双跑对该方言的字节锁:golden 由
 /// `PYTHONPATH=src python3 -c "from team_agent.simple_yaml import loads,dumps; ..."` 取得。
-fn roundtrip_eq(input: &str, golden: &str) {
-    let v = loads(input).unwrap();
-    assert_eq!(dumps(&v), golden, "roundtrip mismatch for input:\n{input}");
+fn roundtrip_eq(id: &str, input: &str, golden: &str, note: &str) {
+    let parsed = loads(input);
+    assert!(parsed.is_ok(), "case={id}; {note}; parse failed: {parsed:?}");
+    let v = parsed.unwrap();
+    assert_eq!(dumps(&v), golden, "case={id}; {note}; roundtrip mismatch for input:\n{input}");
 }
 
 // === 真实语料:examples/team.spec.yaml 的 dumps(loads(t)) golden(逐字节) ===
@@ -41,168 +43,47 @@ fn rich_edge_fixture_roundtrip_matches_python_golden() {
     assert_eq!(dumps(&v), golden);
 }
 
-// === SKILL.md front-matter 块(`---` 之间那段)的 loads/dumps ===
-#[test]
-fn skill_front_matter_roundtrip() {
-    // 取自 skills/team-agent/SKILL.md 的 front matter。
-    let input = "name: team-agent\ndescription: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\n";
-    let golden = "name: \"team-agent\"\ndescription: \"Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\"\n";
-    roundtrip_eq(input, golden);
-}
-
-// === 方言怪癖逐一对拍(每个 golden 来自 Python 真相源)===
-
-#[test]
-fn block_scalar_basic() {
-    roundtrip_eq(
-        "msg: |\n  line one\n  line two\n",
-        "msg: |\n  line one\n  line two\n",
-    );
-}
-
-#[test]
-fn block_scalar_blank_line_becomes_padded() {
-    // 空行在 dumps 时产生仅含 pad 的行(尾随空格)—— Python 行为,必须复刻。
-    roundtrip_eq("msg: |\n  a\n\n  b\n", "msg: |\n  a\n  \n  b\n");
-}
-
-#[test]
-fn inline_unquoted_list_stays_string() {
-    // ast.literal_eval('[a, b, c]') 失败 → 原样字符串。
-    roundtrip_eq("tools: [a, b, c]\n", "tools: \"[a, b, c]\"\n");
-}
-
-#[test]
-fn inline_quoted_list_becomes_list() {
-    roundtrip_eq("x: ['a', 'b']\n", "x:\n  - \"a\"\n  - \"b\"\n");
-}
-
-#[test]
-fn ints_canonicalize() {
-    // 007 -> 7,-5 保号。
-    roundtrip_eq("a: 1\nb: -5\nc: 007\n", "a: 1\nb: -5\nc: 7\n");
-}
-
-#[test]
-fn int_plus_and_underscore() {
-    roundtrip_eq("a: +3\nb: 1_000\n", "a: 3\nb: 1000\n");
-}
-
-#[test]
-fn non_ints_stay_strings() {
-    roundtrip_eq(
-        "a: 1.5\nb: 0x1f\nc: 1e3\nd: _1\n",
-        "a: \"1.5\"\nb: \"0x1f\"\nc: \"1e3\"\nd: \"_1\"\n",
-    );
-}
-
-#[test]
-fn bools_and_nulls() {
-    roundtrip_eq(
-        "a: true\nb: False\nc: NULL\nd: ~\n",
-        "a: true\nb: false\nc: null\nd: null\n",
-    );
-}
-
-#[test]
-fn empty_collections() {
-    roundtrip_eq("a: {}\nb: []\n", "a: {}\nb: []\n");
-}
-
-#[test]
-fn quoted_strings_unwrap() {
-    roundtrip_eq("a: \"hello\"\nb: 'world'\n", "a: \"hello\"\nb: \"world\"\n");
-}
-
-#[test]
-fn nested_map() {
-    roundtrip_eq("a:\n  b:\n    c: 1\n", "a:\n  b:\n    c: 1\n");
-}
-
-#[test]
-fn list_of_maps() {
-    roundtrip_eq(
-        "items:\n  - id: x\n    val: 1\n  - id: y\n    val: 2\n",
-        "items:\n  - id: \"x\"\n    val: 1\n  - id: \"y\"\n    val: 2\n",
-    );
-}
-
-#[test]
-fn scalar_list_mixed() {
-    roundtrip_eq(
-        "a:\n  - 1\n  - two\n  - true\n",
-        "a:\n  - 1\n  - \"two\"\n  - true\n",
-    );
-}
-
-#[test]
-fn empty_value_is_null() {
-    roundtrip_eq("a:\nb: 2\n", "a: null\nb: 2\n");
-}
-
-#[test]
-fn inline_comment_not_stripped() {
-    // 整行注释被跳过;行内 `#` 不被当注释,留在值里。
-    roundtrip_eq(
-        "# top\na: 1  # inline?\nb: 2\n",
-        "a: \"1  # inline?\"\nb: 2\n",
-    );
-}
-
-#[test]
-fn key_no_space_after_colon() {
-    roundtrip_eq("a:1\n", "a: 1\n");
-}
-
-#[test]
-fn special_chars_json_escaped() {
-    roundtrip_eq("a: he said \"hi\"\n", "a: \"he said \\\"hi\\\"\"\n");
-}
-
-#[test]
-fn unicode_preserved() {
-    roundtrip_eq("name: café ☕\n", "name: \"café ☕\"\n");
-}
-
-#[test]
-fn list_item_value_has_colon_and_space() {
-    // foo: bar baz —— item_text 看起来是 key-value(key=foo 合法),value = "bar baz"。
-    roundtrip_eq("a:\n  - foo: bar baz\n", "a:\n  - foo: \"bar baz\"\n");
-}
-
-// === JSON 顶层路径(`{`/`[` 开头 → json.loads,保留键序)===
-
-#[test]
-fn json_object_path_preserves_key_order() {
-    roundtrip_eq("{\"a\": 1, \"b\": [1,2]}", "a: 1\nb:\n  - 1\n  - 2\n");
-}
-
-#[test]
-fn json_array_path() {
-    roundtrip_eq("[1, 2, 3]", "- 1\n- 2\n- 3\n");
-}
-
-#[test]
-fn json_leading_whitespace() {
-    roundtrip_eq("   {\"a\": 1}", "a: 1\n");
-}
-
-#[test]
-fn json_float_becomes_quoted_string() {
-    // json.loads -> float 1.5; dumps -> json.dumps(str(1.5)) = "1.5"。
-    roundtrip_eq("{\"a\": 1.5}", "a: \"1.5\"\n");
-}
-
-#[test]
-fn json_string_with_newline_becomes_block_scalar() {
-    roundtrip_eq("{\"x\": \"with\\nnewline\"}", "x: |\n  with\n  newline\n");
-}
-
-#[test]
-fn json_empty_object_and_array_top_level() {
-    // 顶层 {} / [] → _dump 返回空 → "\n"。
-    roundtrip_eq("{}", "\n");
-    roundtrip_eq("[]", "\n");
+// === SKILL front matter、方言怪癖与 JSON 顶层路径:逐字节锁定 Python golden ===
+#[test]
+fn python_golden_roundtrip_cases() {
+    // (旧函数 id, input, golden, Python 语义说明)。26 个旧测试包含 27 次往返。
+    let cases = [
+        (
+            "skill_front_matter_roundtrip",
+            "name: team-agent\ndescription: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\n",
+            "name: \"team-agent\"\ndescription: \"Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\"\n",
+            "取自 skills/team-agent/SKILL.md 的 front matter。SKILL.md front-matter 块(`---` 之间那段)。",
+        ),
+        ("block_scalar_basic", "msg: |\n  line one\n  line two\n", "msg: |\n  line one\n  line two\n", ""),
+        ("block_scalar_blank_line_becomes_padded", "msg: |\n  a\n\n  b\n", "msg: |\n  a\n  \n  b\n", "空行在 dumps 时产生仅含 pad 的行(尾随空格)—— Python 行为,必须复刻。"),
+        ("inline_unquoted_list_stays_string", "tools: [a, b, c]\n", "tools: \"[a, b, c]\"\n", "ast.literal_eval('[a, b, c]') 失败 → 原样字符串。"),
+        ("inline_quoted_list_becomes_list", "x: ['a', 'b']\n", "x:\n  - \"a\"\n  - \"b\"\n", ""),
+        ("ints_canonicalize", "a: 1\nb: -5\nc: 007\n", "a: 1\nb: -5\nc: 7\n", "007 -> 7,-5 保号。"),
+        ("int_plus_and_underscore", "a: +3\nb: 1_000\n", "a: 3\nb: 1000\n", ""),
+        ("non_ints_stay_strings", "a: 1.5\nb: 0x1f\nc: 1e3\nd: _1\n", "a: \"1.5\"\nb: \"0x1f\"\nc: \"1e3\"\nd: \"_1\"\n", ""),
+        ("bools_and_nulls", "a: true\nb: False\nc: NULL\nd: ~\n", "a: true\nb: false\nc: null\nd: null\n", ""),
+        ("empty_collections", "a: {}\nb: []\n", "a: {}\nb: []\n", ""),
+        ("quoted_strings_unwrap", "a: \"hello\"\nb: 'world'\n", "a: \"hello\"\nb: \"world\"\n", ""),
+        ("nested_map", "a:\n  b:\n    c: 1\n", "a:\n  b:\n    c: 1\n", ""),
+        ("list_of_maps", "items:\n  - id: x\n    val: 1\n  - id: y\n    val: 2\n", "items:\n  - id: \"x\"\n    val: 1\n  - id: \"y\"\n    val: 2\n", ""),
+        ("scalar_list_mixed", "a:\n  - 1\n  - two\n  - true\n", "a:\n  - 1\n  - \"two\"\n  - true\n", ""),
+        ("empty_value_is_null", "a:\nb: 2\n", "a: null\nb: 2\n", ""),
+        ("inline_comment_not_stripped", "# top\na: 1  # inline?\nb: 2\n", "a: \"1  # inline?\"\nb: 2\n", "整行注释被跳过;行内 `#` 不被当注释,留在值里。"),
+        ("key_no_space_after_colon", "a:1\n", "a: 1\n", ""),
+        ("special_chars_json_escaped", "a: he said \"hi\"\n", "a: \"he said \\\"hi\\\"\"\n", ""),
+        ("unicode_preserved", "name: café ☕\n", "name: \"café ☕\"\n", ""),
+        ("list_item_value_has_colon_and_space", "a:\n  - foo: bar baz\n", "a:\n  - foo: \"bar baz\"\n", "foo: bar baz —— item_text 看起来是 key-value(key=foo 合法),value = \"bar baz\"。"),
+        ("json_object_path_preserves_key_order", "{\"a\": 1, \"b\": [1,2]}", "a: 1\nb:\n  - 1\n  - 2\n", "JSON 顶层路径保留键序。"),
+        ("json_array_path", "[1, 2, 3]", "- 1\n- 2\n- 3\n", ""),
+        ("json_leading_whitespace", "   {\"a\": 1}", "a: 1\n", ""),
+        ("json_float_becomes_quoted_string", "{\"a\": 1.5}", "a: \"1.5\"\n", "json.loads -> float 1.5; dumps -> json.dumps(str(1.5)) = \"1.5\"。"),
+        ("json_string_with_newline_becomes_block_scalar", "{\"x\": \"with\\nnewline\"}", "x: |\n  with\n  newline\n", ""),
+        ("json_empty_object_and_array_top_level", "{}", "\n", "顶层 {} / [] → _dump 返回空 → \"\\n\"。"),
+        ("json_empty_object_and_array_top_level", "[]", "\n", "顶层 {} / [] → _dump 返回空 → \"\\n\"。"),
+    ];
+    for (id, input, golden, note) in cases {
+        roundtrip_eq(id, input, golden, note);
+    }
 }
 
 // === dumps-only 结构(直接构造 Value,golden 来自 Python dumps)===

package/crates/team-agent/src/provider/tests/adapter.rs

@@ -403,26 +403,6 @@ fn test_cursor_agent_accepts_mcp_config_without_putting_it_on_argv() {
     );
 }
 
-#[test]
-fn test_cursor_agent_refuses_mcp_config_loudly() {
-    // 已废除的行为：旧实现收到 mcp_config 就返回 CapabilityUnsupported
-    // （「MCP is not implemented」），此断言证明它确实没了。
-    let adapter = get_adapter(Provider::CursorAgent);
-    let cfg = McpConfig {
-        raw: serde_json::json!({
-            "team_orchestrator": {
-                "command": "/bin/team-agent",
-                "args": ["mcp-server"]
-            }
-        }),
-    };
-    let result = adapter.build_command(AuthMode::Subscription, Some(&cfg), None, None);
-    assert!(
-        !matches!(result, Err(ProviderError::CapabilityUnsupported(_))),
-        "feeding mcp_config must not return CapabilityUnsupported; got {result:?}"
-    );
-}
-
 #[test]
 fn test_grok_build_command_plan_binds_expected_session_id_to_argv() {
     let adapter = get_adapter(Provider::Grok);

package/crates/team-agent/src/provider/tests/classify.rs

@@ -6,53 +6,113 @@ fn claude_open_turn() -> String {
 }
 
 #[test]
-fn classify_empty_text_is_unknown_never_idle() {
-    // probe empty_text: state=unknown turn_id=None reason=unreadable_or_empty
-    // source=session_file. BLOOD-LINE: unknown is NEVER idle (bug-071/077/085).
-    let c = classify(Provider::ClaudeCode, "", ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Unknown);
-    assert_eq!(c.reason, "unreadable_or_empty");
-    assert_eq!(c.turn_id, None);
-    assert_eq!(c.source, ClassifySource::SessionFile);
-    // The pin the audit demands: classify(unreadable) MUST NOT be treatable as idle.
-    assert!(
-        !c.state.is_idle_for_takeover(),
-        "unreadable/empty input must never be idle (C5)"
+fn classify_state_table() {
+    use ClassifySource::{ProcessGuard, SessionFile};
+    use ProcessLiveness::{Alive, Unverifiable};
+    use Provider::{Claude, ClaudeCode, Codex};
+    use TurnState::{Abnormal, BlockedOnHuman, Idle, IdleInterrupted, Unknown, Working};
+
+    type Input<'a> = (Provider, &'a str, ProcessLiveness, f64);
+    // State, reason, turn ID, source, exact annotations, idle-for-takeover.
+    // None skips an originally absent assertion; Some(None) asserts no turn ID.
+    type Expected<'a> = (
+        TurnState, &'a str, Option<Option<&'a str>>, Option<ClassifySource>,
+        Option<&'a [&'a str]>, Option<bool>,
     );
-}
-
-#[test]
-fn classify_whitespace_only_is_unknown() {
-    // probe whitespace_only → unknown / unreadable_or_empty.
-    let c = classify(Provider::Claude, "   \n  \t \n", ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Unknown);
-    assert_eq!(c.reason, "unreadable_or_empty");
-    assert!(!c.state.is_idle_for_takeover());
-}
-
-#[test]
-fn classify_garbage_jsonl_is_unknown_not_idle() {
-    // probe garbage_jsonl ("not json\n{broken"): parse yields diagnostics but
-    // had_records=false → reason=unreadable_or_empty (the !had_records branch
-    // wins over diagnostics; common.py:72-75). NEVER idle.
-    let c = classify(Provider::Claude, "not json\n{broken", ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Unknown);
-    assert_eq!(c.reason, "unreadable_or_empty");
-    assert!(!c.state.is_idle_for_takeover());
-}
-
-#[test]
-fn classify_unrecognized_format_is_unknown() {
-    // probe '{"foo":"bar"}': had_records=true, no lifecycle fact, NO diagnostics
-    // → reason=no_turn_lifecycle_fact (NOT unrecognized_format — golden-confirmed).
-    let c = classify(Provider::Claude, r#"{"foo":"bar"}"#, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Unknown);
-    assert_eq!(c.reason, "no_turn_lifecycle_fact");
-    assert!(!c.state.is_idle_for_takeover());
+    let open = claude_open_turn();
+    let two = format!(
+        "{}\n{}",
+        r#"{"type":"assistant","requestId":"a","message":{"stop_reason":"tool_use"}}"#,
+        r#"{"type":"assistant","requestId":"b","message":{"stop_reason":"end_turn"}}"#,
+    );
+    let c14 = format!(
+        "{}\n{}",
+        r#"{"type":"assistant","requestId":"a","message":{"stop_reason":"end_turn"}}"#,
+        r#"{"type":"assistant","requestId":"b","message":{"stop_reason":"tool_use"}}"#,
+    );
+    let cases: &[(&str, Input<'_>, Expected<'_>)] = &[
+        // Unknown is NEVER idle (bug-071/077/085, C5).
+        ("empty",
+            (ClaudeCode, "", Unverifiable, 0.0),
+            (Unknown, "unreadable_or_empty", Some(None), Some(SessionFile), None, Some(false))),
+        ("whitespace",
+            (Claude, "   \n  \t \n", Unverifiable, 0.0),
+            (Unknown, "unreadable_or_empty", None, None, None, Some(false))),
+        // !had_records wins over parse diagnostics (common.py:72-75).
+        ("garbage_jsonl",
+            (Claude, "not json\n{broken", Unverifiable, 0.0),
+            (Unknown, "unreadable_or_empty", None, None, None, Some(false))),
+        // Valid record without lifecycle facts: NOT unrecognized_format.
+        ("unrecognized_record",
+            (Claude, r#"{"foo":"bar"}"#, Unverifiable, 0.0),
+            (Unknown, "no_turn_lifecycle_fact", None, None, None, Some(false))),
+        // C4: missing process identity is NEVER optimistically working.
+        ("open_unverifiable_identity",
+            (Claude, &open, Unverifiable, 0.0),
+            (Unknown, "process_identity_unverified", Some(Some("r1")), Some(ProcessGuard), None, Some(false))),
+        ("open_alive",
+            (Claude, &open, Alive, 0.0),
+            (Working, "open_turn", Some(Some("r1")), Some(SessionFile), None, None)),
+        ("open_unverifiable_process",
+            (Claude, &open, Unverifiable, 0.0),
+            (Unknown, "process_identity_unverified", None, None, None, Some(false))),
+        ("last_fact_wins",
+            (Claude, &two, Unverifiable, 0.0),
+            (Idle, "end_turn", Some(Some("b")), None, None, None)),
+        // C14: silence is discarded; only a dead process can demote an open turn.
+        ("open_beats_silence",
+            (Claude, &c14, Alive, 9999.0),
+            (Working, "open_turn", Some(Some("b")), None, None, None)),
+        // C12: idle_interrupted IS idle for take-over, with exact annotations.
+        ("claude_interrupted",
+            (Claude, r#"{"type":"user","uuid":"u1","message":{"content":[{"type":"text","text":"[Request interrupted by user]"}]}}"#, Unverifiable, 0.0),
+            (IdleInterrupted, "user_interrupt", Some(Some("u1")), None, Some(&["interrupted"]), Some(true))),
+        ("claude_stop_sequence",
+            (Claude, r#"{"type":"assistant","requestId":"r1","message":{"stop_reason":"stop_sequence"}}"#, Unverifiable, 0.0),
+            (Idle, "stop_sequence", None, None, None, None)),
+        ("codex_task_complete",
+            (Codex, r#"{"type":"event_msg","payload":{"type":"task_complete","turn_id":"ct1"}}"#, Unverifiable, 0.0),
+            (Idle, "task_complete", Some(Some("ct1")), None, None, None)),
+        ("codex_abort_interrupted",
+            (Codex, r#"{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"ct2","reason":"interrupted"}}"#, Unverifiable, 0.0),
+            (IdleInterrupted, "interrupted", None, None, None, None)),
+        // Raw abort reason must pass through, including non-interrupted errors.
+        ("codex_abort_error",
+            (Codex, r#"{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"ct3","reason":"error"}}"#, Unverifiable, 0.0),
+            (IdleInterrupted, "error", Some(Some("ct3")), None, None, None)),
+        ("codex_turn_failed",
+            (Codex, r#"{"jsonrpc":"2.0","method":"turn/completed","params":{"turn":{"id":"ct4","status":"failed"}}}"#, Unverifiable, 0.0),
+            (Abnormal, "turn_failed", Some(Some("ct4")), None, Some(&["turn_failed"]), Some(false))),
+        // blocked_on_human is NOT idle for take-over.
+        ("codex_approval",
+            (Codex, r#"{"jsonrpc":"2.0","method":"session/requestApproval","params":{"turnId":"ct5"}}"#, Unverifiable, 0.0),
+            (BlockedOnHuman, "approval_required", Some(Some("ct5")), None, Some(&["awaiting_approval"]), Some(false))),
+    ];
+    for &(id, (provider, text, liveness, silence), expected) in cases {
+        let c = classify(provider, text, liveness, silence)
+            .unwrap_or_else(|err| panic!("{id}: classify failed: {err:?}"));
+        let (state, reason, turn_id, source, annotations, idle) = expected;
+        let note = match id {
+            "empty" => "unreadable/empty input must never be idle (C5)",
+            "codex_abort_error" => "raw abort reason must pass through",
+            _ => "",
+        };
+        assert_eq!(c.state, state, "{id}: state");
+        assert_eq!(c.reason, reason, "{id}: reason; {note}");
+        if let Some(turn_id) = turn_id {
+            assert_eq!(c.turn_id.as_ref().map(TurnId::as_str), turn_id, "{id}: turn ID");
+        }
+        if let Some(source) = source {
+            assert_eq!(c.source, source, "{id}: source");
+        }
+        if let Some(annotations) = annotations {
+            let actual: Vec<_> = c.annotations.iter().map(String::as_str).collect();
+            assert_eq!(actual.as_slice(), annotations, "{id}: exact annotations");
+        }
+        if let Some(idle) = idle {
+            assert_eq!(c.state.is_idle_for_takeover(), idle, "{id}: idle-for-takeover; {note}");
+        }
+    }
 }
 
 #[test]
@@ -69,31 +129,6 @@ fn classify_claude_code_alias_normalizes_to_claude_reader() {
     assert_eq!(alias, canon, "claude_code must normalize to the claude reader");
 }
 
-#[test]
-fn classify_open_turn_with_no_process_is_unknown_not_working() {
-    // probe open_turn_process_none: open turn + Unverifiable (None process) →
-    // unknown / process_identity_unverified / source=process_guard, turn_id=r1.
-    // C4: missing identity is NEVER optimistically working.
-    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Unknown);
-    assert_eq!(c.reason, "process_identity_unverified");
-    assert_eq!(c.source, ClassifySource::ProcessGuard);
-    assert_eq!(c.turn_id, Some(TurnId::new("r1")));
-    assert!(!c.state.is_idle_for_takeover());
-}
-
-#[test]
-fn classify_open_turn_alive_is_working() {
-    // probe open_turn_alive: open turn + Alive → working / open_turn / source=session_file.
-    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Alive, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Working);
-    assert_eq!(c.reason, "open_turn");
-    assert_eq!(c.source, ClassifySource::SessionFile);
-    assert_eq!(c.turn_id, Some(TurnId::new("r1")));
-}
-
 #[test]
 fn classify_open_turn_dead_is_abnormal_crashed_mid_turn() {
     // probe open_turn_dead: open turn + Dead → abnormal / crashed_mid_turn /
@@ -106,133 +141,6 @@ fn classify_open_turn_dead_is_abnormal_crashed_mid_turn() {
     assert!(c.annotations.contains(&"crashed_mid_turn".to_string()));
 }
 
-#[test]
-fn classify_open_turn_unverifiable_process_is_unknown() {
-    // probe open_turn_unverifiable: open turn + Unverifiable →
-    // unknown / process_identity_unverified (NOT working). NEVER idle.
-    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Unknown);
-    assert_eq!(c.reason, "process_identity_unverified");
-    assert!(!c.state.is_idle_for_takeover());
-}
-
-#[test]
-fn classify_last_lifecycle_fact_wins() {
-    // probe last_fact_wins_complete (tool_use 'a' then end_turn 'b') →
-    // idle / end_turn, turn_id = the LAST lifecycle fact's id ("b").
-    let two = format!(
-        "{}\n{}",
-        r#"{"type":"assistant","requestId":"a","message":{"stop_reason":"tool_use"}}"#,
-        r#"{"type":"assistant","requestId":"b","message":{"stop_reason":"end_turn"}}"#,
-    );
-    let c = classify(Provider::Claude, &two, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Idle);
-    assert_eq!(c.reason, "end_turn");
-    assert_eq!(c.turn_id, Some(TurnId::new("b")));
-}
-
-#[test]
-fn classify_c14_open_turn_beats_silence() {
-    // probe c14_open_after_complete_alive (end_turn 'a' then tool_use 'b', alive,
-    // file_silence=9999) → working / open_turn, turn_id="b". Silence is DISCARDED:
-    // only a dead process guard can demote an open turn (common.py:93-103, C14).
-    let c14 = format!(
-        "{}\n{}",
-        r#"{"type":"assistant","requestId":"a","message":{"stop_reason":"end_turn"}}"#,
-        r#"{"type":"assistant","requestId":"b","message":{"stop_reason":"tool_use"}}"#,
-    );
-    let c = classify(Provider::Claude, &c14, ProcessLiveness::Alive, 9999.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Working);
-    assert_eq!(c.reason, "open_turn");
-    assert_eq!(c.turn_id, Some(TurnId::new("b")));
-}
-
-#[test]
-fn classify_claude_interrupted_is_idle_interrupted_annotated() {
-    // probe claude_interrupted ("[Request interrupted by user]") →
-    // idle_interrupted / user_interrupt / annotations=["interrupted"], turn_id=u1.
-    let txt = r#"{"type":"user","uuid":"u1","message":{"content":[{"type":"text","text":"[Request interrupted by user]"}]}}"#;
-    let c = classify(Provider::Claude, txt, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::IdleInterrupted);
-    assert_eq!(c.reason, "user_interrupt");
-    assert_eq!(c.annotations, vec!["interrupted".to_string()]);
-    assert_eq!(c.turn_id, Some(TurnId::new("u1")));
-    // C12: idle_interrupted IS idle for take-over (annotated).
-    assert!(c.state.is_idle_for_takeover());
-}
-
-#[test]
-fn classify_claude_stop_sequence_is_idle() {
-    // probe claude_stop_sequence → idle / stop_sequence.
-    let txt = r#"{"type":"assistant","requestId":"r1","message":{"stop_reason":"stop_sequence"}}"#;
-    let c = classify(Provider::Claude, txt, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Idle);
-    assert_eq!(c.reason, "stop_sequence");
-}
-
-#[test]
-fn classify_codex_task_complete_is_idle() {
-    // probe codex_task_complete → idle / task_complete, turn_id from payload (ct1).
-    let txt = r#"{"type":"event_msg","payload":{"type":"task_complete","turn_id":"ct1"}}"#;
-    let c = classify(Provider::Codex, txt, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Idle);
-    assert_eq!(c.reason, "task_complete");
-    assert_eq!(c.turn_id, Some(TurnId::new("ct1")));
-}
-
-#[test]
-fn classify_codex_turn_aborted_interrupted_is_idle_interrupted() {
-    // probe codex_turn_aborted_interrupted → idle_interrupted / interrupted.
-    let interrupted = r#"{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"ct2","reason":"interrupted"}}"#;
-    let c = classify(Provider::Codex, interrupted, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::IdleInterrupted);
-    assert_eq!(c.reason, "interrupted");
-    // probe codex_turn_aborted_other (reason="error") → idle_interrupted with the
-    // RAW reason string passed through ("error"), turn_id=ct3.
-    let other = r#"{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"ct3","reason":"error"}}"#;
-    let c2 = classify(Provider::Codex, other, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c2.state, TurnState::IdleInterrupted);
-    assert_eq!(c2.reason, "error", "raw abort reason must pass through");
-    assert_eq!(c2.turn_id, Some(TurnId::new("ct3")));
-}
-
-#[test]
-fn classify_codex_appserver_failed_is_abnormal() {
-    // probe codex_appserver_failed (turn.status==failed) → abnormal / turn_failed /
-    // annotations=["turn_failed"], source=session_file, turn_id=ct4.
-    let txt = r#"{"jsonrpc":"2.0","method":"turn/completed","params":{"turn":{"id":"ct4","status":"failed"}}}"#;
-    let c = classify(Provider::Codex, txt, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::Abnormal);
-    assert_eq!(c.reason, "turn_failed");
-    assert_eq!(c.annotations, vec!["turn_failed".to_string()]);
-    assert_eq!(c.turn_id, Some(TurnId::new("ct4")));
-    assert!(!c.state.is_idle_for_takeover());
-}
-
-#[test]
-fn classify_codex_appserver_approval_is_blocked_on_human() {
-    // probe codex_appserver_approval (method endswith requestApproval) →
-    // blocked_on_human / approval_required / annotations=["awaiting_approval"], turn_id=ct5.
-    let txt = r#"{"jsonrpc":"2.0","method":"session/requestApproval","params":{"turnId":"ct5"}}"#;
-    let c = classify(Provider::Codex, txt, ProcessLiveness::Unverifiable, 0.0)
-        .expect("classify ok");
-    assert_eq!(c.state, TurnState::BlockedOnHuman);
-    assert_eq!(c.reason, "approval_required");
-    assert_eq!(c.annotations, vec!["awaiting_approval".to_string()]);
-    assert_eq!(c.turn_id, Some(TurnId::new("ct5")));
-    // blocked_on_human is NOT idle for take-over.
-    assert!(!c.state.is_idle_for_takeover());
-}
-
 // ---- (b) idle predicate / evaluate_takeover_reminder (NoPingReason cases) ----
 //
 // Golden via /tmp/probe_idle.py (idle_predicate.evaluate_takeover_reminder).

package/crates/team-agent/src/state/projection.rs

@@ -26,6 +26,21 @@ use crate::state::persist::{
 
 pub(crate) const CURRENT_TEAM_ALIAS: &str = "current";
 
+/// Physical tmux session birth identity, independent of later worker spawns.
+/// Legacy launches did not persist it: freeze their fallback BEFORE respawn.
+pub fn session_generation(state: &Value) -> Option<&str> {
+    state.get("generation").and_then(Value::as_str).or_else(|| {
+        state
+            .get("agents")
+            .and_then(Value::as_object)
+            .and_then(|agents| {
+                agents.values().find_map(|agent| {
+                    agent.get("spawned_at").and_then(Value::as_str)
+                })
+            })
+    })
+}
+
 ///
 /// `team_state_key`(`state.py:93`):从 team_dir(.name)/spec_path(.parent.name)派生 team key,
 /// 跳过 `.team`/`runtime`;兜底 `session_name` 或 `"current"`。