@team-agent/installer 0.5.41 → 0.5.43

package/crates/team-agent/src/diagnose/orphans.rs

@@ -95,32 +95,38 @@ pub fn orphan_gate_json(workspace: &Path, fix: bool, confirm: bool) -> Result<Va
     let scope = OrphanScanScope::current_workspace(workspace);
     let report = scan_orphans_bounded(&scope, false);
     if report.orphans.is_empty() {
-        return Ok(with_ignored_foreign(json!({
-            "ok": true,
-            "gate": "orphans",
-            "status": "passed",
-            "scanned": report.scanned,
-            "dry_run": !fix,
-            "scanned_at": chrono::Utc::now().to_rfc3339(),
-            "action_required": false,
-            "fix": fix,
-            "orphans": [],
-        }), &report));
+        return Ok(with_ignored_foreign(
+            json!({
+                "ok": true,
+                "gate": "orphans",
+                "status": "passed",
+                "scanned": report.scanned,
+                "dry_run": !fix,
+                "scanned_at": chrono::Utc::now().to_rfc3339(),
+                "action_required": false,
+                "fix": fix,
+                "orphans": [],
+            }),
+            &report,
+        ));
     }
     if fix {
         return fix_orphans(&scope, report);
     }
-    Ok(with_ignored_foreign(json!({
-        "ok": false,
-        "gate": "orphans",
-        "status": "failed",
-        "scanned": report.scanned,
-        "dry_run": true,
-        "scanned_at": chrono::Utc::now().to_rfc3339(),
-        "action_required": true,
-        "fix": false,
-        "orphans": orphan_values(&report.orphans),
-    }), &report))
+    Ok(with_ignored_foreign(
+        json!({
+            "ok": false,
+            "gate": "orphans",
+            "status": "failed",
+            "scanned": report.scanned,
+            "dry_run": true,
+            "scanned_at": chrono::Utc::now().to_rfc3339(),
+            "action_required": true,
+            "fix": false,
+            "orphans": orphan_values(&report.orphans),
+        }),
+        &report,
+    ))
 }
 
 pub fn cleanup_orphans_json(workspace: &Path, confirm: bool) -> Result<Value, CliError> {
@@ -128,26 +134,32 @@ pub fn cleanup_orphans_json(workspace: &Path, confirm: bool) -> Result<Value, Cl
     let report = scan_orphans_bounded(&scope, false);
     if confirm {
         if report.orphans.is_empty() {
-            return Ok(with_ignored_foreign(json!({
-                "ok": true,
-                "scanned": report.scanned,
-                "orphans": [],
-                "dry_run": false,
-                "scanned_at": chrono::Utc::now().to_rfc3339(),
-                "killed": [],
-                "failed": [],
-            }), &report));
+            return Ok(with_ignored_foreign(
+                json!({
+                    "ok": true,
+                    "scanned": report.scanned,
+                    "orphans": [],
+                    "dry_run": false,
+                    "scanned_at": chrono::Utc::now().to_rfc3339(),
+                    "killed": [],
+                    "failed": [],
+                }),
+                &report,
+            ));
         }
         return cleanup_confirmed(&scope, report);
     }
-    Ok(with_ignored_foreign(json!({
-        "ok": true,
-        "scanned": report.scanned,
-        "orphans": orphan_values(&report.orphans),
-        "dry_run": true,
-        "scanned_at": chrono::Utc::now().to_rfc3339(),
-        "action_required": "re-run with --confirm to send SIGTERM",
-    }), &report))
+    Ok(with_ignored_foreign(
+        json!({
+            "ok": true,
+            "scanned": report.scanned,
+            "orphans": orphan_values(&report.orphans),
+            "dry_run": true,
+            "scanned_at": chrono::Utc::now().to_rfc3339(),
+            "action_required": "re-run with --confirm to send SIGTERM",
+        }),
+        &report,
+    ))
 }
 
 pub fn has_orphan_residue(workspace: &Path) -> bool {
@@ -188,33 +200,39 @@ pub fn orphan_blocker_detail(workspace: &Path) -> String {
 fn fix_orphans(scope: &OrphanScanScope, report: ScanReport) -> Result<Value, CliError> {
     let cleanup = cleanup_report(report, scope);
     let residual = scan_orphans(scope, false);
-    Ok(with_ignored_foreign(json!({
-        "ok": residual.orphans.is_empty() && cleanup.failed.is_empty(),
-        "gate": "orphans",
-        "status": if residual.orphans.is_empty() && cleanup.failed.is_empty() { "fixed" } else { "failed" },
-        "scanned": cleanup.scanned,
-        "dry_run": false,
-        "scanned_at": chrono::Utc::now().to_rfc3339(),
-        "action_required": !residual.orphans.is_empty() || !cleanup.failed.is_empty(),
-        "fix": true,
-        "orphans": orphan_values(&residual.orphans),
-        "killed": cleanup.killed,
-        "failed": cleanup.failed,
-    }), &residual))
+    Ok(with_ignored_foreign(
+        json!({
+            "ok": residual.orphans.is_empty() && cleanup.failed.is_empty(),
+            "gate": "orphans",
+            "status": if residual.orphans.is_empty() && cleanup.failed.is_empty() { "fixed" } else { "failed" },
+            "scanned": cleanup.scanned,
+            "dry_run": false,
+            "scanned_at": chrono::Utc::now().to_rfc3339(),
+            "action_required": !residual.orphans.is_empty() || !cleanup.failed.is_empty(),
+            "fix": true,
+            "orphans": orphan_values(&residual.orphans),
+            "killed": cleanup.killed,
+            "failed": cleanup.failed,
+        }),
+        &residual,
+    ))
 }
 
 fn cleanup_confirmed(scope: &OrphanScanScope, report: ScanReport) -> Result<Value, CliError> {
     let cleanup = cleanup_report(report, scope);
     let residual = scan_orphans(scope, false);
-    Ok(with_ignored_foreign(json!({
-        "ok": residual.orphans.is_empty() && cleanup.failed.is_empty(),
-        "scanned": cleanup.scanned,
-        "orphans": orphan_values(&residual.orphans),
-        "dry_run": false,
-        "scanned_at": chrono::Utc::now().to_rfc3339(),
-        "killed": cleanup.killed,
-        "failed": cleanup.failed,
-    }), &residual))
+    Ok(with_ignored_foreign(
+        json!({
+            "ok": residual.orphans.is_empty() && cleanup.failed.is_empty(),
+            "scanned": cleanup.scanned,
+            "orphans": orphan_values(&residual.orphans),
+            "dry_run": false,
+            "scanned_at": chrono::Utc::now().to_rfc3339(),
+            "killed": cleanup.killed,
+            "failed": cleanup.failed,
+        }),
+        &residual,
+    ))
 }
 
 struct CleanupReport {

package/crates/team-agent/src/event_log.rs

@@ -48,14 +48,22 @@ pub enum EventLogError {
 struct PythonFormatter;
 
 impl serde_json::ser::Formatter for PythonFormatter {
-    fn begin_array_value<W: ?Sized + std::io::Write>(&mut self, w: &mut W, first: bool) -> std::io::Result<()> {
+    fn begin_array_value<W: ?Sized + std::io::Write>(
+        &mut self,
+        w: &mut W,
+        first: bool,
+    ) -> std::io::Result<()> {
         if first {
             Ok(())
         } else {
             w.write_all(b", ")
         }
     }
-    fn begin_object_key<W: ?Sized + std::io::Write>(&mut self, w: &mut W, first: bool) -> std::io::Result<()> {
+    fn begin_object_key<W: ?Sized + std::io::Write>(
+        &mut self,
+        w: &mut W,
+        first: bool,
+    ) -> std::io::Result<()> {
         if first {
             Ok(())
         } else {
@@ -114,7 +122,9 @@ pub struct EventLog {
 impl EventLog {
     /// `EventLog(workspace)`:路径 = `<workspace>/.team/logs/events.jsonl`。
     pub fn new(workspace: &Path) -> Self {
-        Self { path: logs_dir(workspace).join("events.jsonl") }
+        Self {
+            path: logs_dir(workspace).join("events.jsonl"),
+        }
     }
 
     /// 直接指定 events.jsonl 路径(测试 / 非标准布局)。
@@ -142,7 +152,10 @@ impl EventLog {
         // 单次 write_all(line+"\n"):POSIX O_APPEND 对 <PIPE_BUF 写原子,避免并发写者交错(对抗 P1)。
         let mut bytes = to_python_json(&sort_value(&event)).into_bytes();
         bytes.push(b'\n');
-        let mut file = std::fs::OpenOptions::new().create(true).append(true).open(&self.path)?;
+        let mut file = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&self.path)?;
         file.write_all(&bytes)?;
         Ok(event)
     }
@@ -155,7 +168,11 @@ impl EventLog {
         let text = std::fs::read_to_string(&self.path)?;
         let lines: Vec<&str> = text.lines().collect();
         // Python lines[-limit:]:limit==0 → lines[0:] = 全部(负零切片怪癖);limit>len → 全部。
-        let start = if limit == 0 { 0 } else { lines.len().saturating_sub(limit) };
+        let start = if limit == 0 {
+            0
+        } else {
+            lines.len().saturating_sub(limit)
+        };
         let mut out = Vec::new();
         for line in &lines[start..] {
             match serde_json::from_str::<Value>(line) {
@@ -194,7 +211,10 @@ impl EventLog {
     }
 
     fn archive_path(&self, index: u32) -> PathBuf {
-        let name = self.path.file_name().map_or_else(String::new, |n| n.to_string_lossy().into_owned());
+        let name = self
+            .path
+            .file_name()
+            .map_or_else(String::new, |n| n.to_string_lossy().into_owned());
         self.path.with_file_name(format!("{name}.{index}"))
     }
 }
@@ -223,7 +243,10 @@ mod tests {
             r#"{"event": "u", "msg": "héllo🦀\n世界", "nested": {"a": [1, 2], "b": 2}}"#
         );
         // 空 fields。
-        assert_eq!(to_python_json(&sort_value(&json!({"event":"empty"}))), r#"{"event": "empty"}"#);
+        assert_eq!(
+            to_python_json(&sort_value(&json!({"event":"empty"}))),
+            r#"{"event": "empty"}"#
+        );
         // 类型:bool/null/int 与 Python 一致。
         assert_eq!(
             to_python_json(&sort_value(&json!({"missing":false,"x":null,"n":2}))),
@@ -235,7 +258,11 @@ mod tests {
     fn write_sorts_keys_and_has_ts_event() {
         let ws = temp_ws();
         let log = EventLog::new(&ws);
-        log.write("schema.layout_rebuild", json!({"table":"messages","row_count_before":2,"row_count_after":2,"missing":false})).unwrap();
+        log.write(
+            "schema.layout_rebuild",
+            json!({"table":"messages","row_count_before":2,"row_count_after":2,"missing":false}),
+        )
+        .unwrap();
         let line = std::fs::read_to_string(ws.join(".team/logs/events.jsonl")).unwrap();
         let line = line.trim_end();
         // 键全排序:event < missing < row_count_after < row_count_before < table < ts。
@@ -243,7 +270,10 @@ mod tests {
         // ts 是合法 rfc3339 UTC。
         let v: Value = serde_json::from_str(line).unwrap();
         let ts = v["ts"].as_str().unwrap();
-        assert!(chrono::DateTime::parse_from_rfc3339(ts).is_ok(), "ts 非合法 rfc3339: {ts}");
+        assert!(
+            chrono::DateTime::parse_from_rfc3339(ts).is_ok(),
+            "ts 非合法 rfc3339: {ts}"
+        );
         assert!(ts.ends_with("+00:00"));
     }
 
@@ -276,7 +306,11 @@ mod tests {
         // 预置 current >= 5MiB + 已有 .1..=.5 archive(各带标记内容)。
         std::fs::write(&p, vec![b'x'; EVENT_LOG_ROTATE_BYTES as usize]).unwrap();
         for i in 1..=EVENT_LOG_ARCHIVE_KEEP {
-            std::fs::write(p.with_file_name(format!("events.jsonl.{i}")), format!("arc{i}")).unwrap();
+            std::fs::write(
+                p.with_file_name(format!("events.jsonl.{i}")),
+                format!("arc{i}"),
+            )
+            .unwrap();
         }
         // 下一次 write 触发轮转:.5 丢弃,.4→.5 ... .1→.2,current→.1。
         log.write("after.rotate", json!({})).unwrap();
@@ -285,10 +319,21 @@ mod tests {
         assert_eq!(new_current.lines().count(), 1);
         assert!(new_current.contains("after.rotate"));
         // .1 = 旧 current(5MiB 的 x)。
-        assert_eq!(std::fs::metadata(p.with_file_name("events.jsonl.1")).unwrap().len(), EVENT_LOG_ROTATE_BYTES);
+        assert_eq!(
+            std::fs::metadata(p.with_file_name("events.jsonl.1"))
+                .unwrap()
+                .len(),
+            EVENT_LOG_ROTATE_BYTES
+        );
         // .2 = 旧 .1(内容 "arc1");.5 = 旧 .4("arc4");旧 .5("arc5")被丢弃。
-        assert_eq!(std::fs::read_to_string(p.with_file_name("events.jsonl.2")).unwrap(), "arc1");
-        assert_eq!(std::fs::read_to_string(p.with_file_name("events.jsonl.5")).unwrap(), "arc4");
+        assert_eq!(
+            std::fs::read_to_string(p.with_file_name("events.jsonl.2")).unwrap(),
+            "arc1"
+        );
+        assert_eq!(
+            std::fs::read_to_string(p.with_file_name("events.jsonl.5")).unwrap(),
+            "arc4"
+        );
     }
 
     #[test]
@@ -319,7 +364,11 @@ mod tests {
         for i in 0..3 {
             log.write("e", json!({ "i": i })).unwrap();
         }
-        assert_eq!(log.tail(0).unwrap().len(), 3, "tail(0) == 全部(Python [-0:])");
+        assert_eq!(
+            log.tail(0).unwrap().len(),
+            3,
+            "tail(0) == 全部(Python [-0:])"
+        );
         assert_eq!(log.tail(2).unwrap().len(), 2);
         assert_eq!(log.tail(99).unwrap().len(), 3);
     }
@@ -349,7 +398,8 @@ mod tests {
         assert_eq!(lines.len(), 8 * 50, "无半行/丢行");
         for line in &lines {
             // 每行完整合法 JSON 且含 event 键 → 未交错。
-            let v: Value = serde_json::from_str(line).unwrap_or_else(|e| panic!("交错坏行: {line:?} ({e})"));
+            let v: Value =
+                serde_json::from_str(line).unwrap_or_else(|e| panic!("交错坏行: {line:?} ({e})"));
             assert_eq!(v["event"], json!("concurrent"));
         }
     }
@@ -367,7 +417,11 @@ mod tests {
                 continue;
             }
             let v: Value = serde_json::from_str(line).unwrap();
-            assert_eq!(to_python_json(&sort_value(&v)), line, "第 {n} 行 round-trip 不字节一致");
+            assert_eq!(
+                to_python_json(&sort_value(&v)),
+                line,
+                "第 {n} 行 round-trip 不字节一致"
+            );
             n += 1;
         }
         assert_eq!(n, 60, "fixture 应 60 行");

package/crates/team-agent/src/layout/manager.rs

@@ -99,7 +99,11 @@ pub fn next_worker_window(
         .iter()
         .any(|w| w.as_str() == window.as_str());
     let action = if window_exists {
-        if force { WorkerSpawnAction::ForceReplace } else { WorkerSpawnAction::Noop }
+        if force {
+            WorkerSpawnAction::ForceReplace
+        } else {
+            WorkerSpawnAction::Noop
+        }
     } else {
         WorkerSpawnAction::NewWindow
     };
@@ -134,7 +138,11 @@ mod worker_placement_tests {
             return WorkerSpawnTarget::new(session, window, WorkerSpawnAction::NewSession);
         }
         let action = if window_exists {
-            if force { WorkerSpawnAction::ForceReplace } else { WorkerSpawnAction::Noop }
+            if force {
+                WorkerSpawnAction::ForceReplace
+            } else {
+                WorkerSpawnAction::Noop
+            }
         } else {
             WorkerSpawnAction::NewWindow
         };
@@ -191,8 +199,11 @@ mod tests {
 
     #[test]
     fn exec_provider_mode_returns_exec_current_pane() {
-        let placement =
-            leader_placement(LeaderStartMode::ExecProvider, Provider::Claude, Path::new("/tmp/x"));
+        let placement = leader_placement(
+            LeaderStartMode::ExecProvider,
+            Provider::Claude,
+            Path::new("/tmp/x"),
+        );
         assert_eq!(placement, LeaderPlacement::ExecCurrentPane);
     }
 

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

@@ -20,15 +20,15 @@
 //!                 (Step 8)
 //!   * `worker_env` — worker_spawn_env whitelist + worker_spawn_cwd (Step 3)
 
-pub mod sessions;
 pub mod manager;
-pub mod worker_window_helpers;
-pub mod worker_env;
+pub mod overlay;
 pub mod placement;
 pub mod recovery;
-pub mod overlay;
 pub mod runtime_sessions;
+pub mod sessions;
 pub mod tmux_endpoint;
+pub mod worker_env;
+pub mod worker_window_helpers;
 
 pub use runtime_sessions::{
     LeaderLauncherSession, LeaderLauncherSessionError, RuntimeSessionAnomaly, RuntimeSessions,

package/crates/team-agent/src/layout/overlay.rs

@@ -22,7 +22,10 @@ pub fn overlay_window_name(session_tag: &str, group_index: usize) -> WindowName
     if group_index == 0 {
         WindowName::new(format!("team-agent:{session_tag}:overview"))
     } else {
-        WindowName::new(format!("team-agent:{session_tag}:overview-{}", group_index + 1))
+        WindowName::new(format!(
+            "team-agent:{session_tag}:overview-{}",
+            group_index + 1
+        ))
     }
 }
 
@@ -113,8 +116,12 @@ mod tests {
 
     #[test]
     fn is_overlay_window_matches_overview_namespace_only() {
-        assert!(is_overlay_window(&WindowName::new("team-agent:alpha:overview")));
-        assert!(is_overlay_window(&WindowName::new("team-agent:alpha:overview-2")));
+        assert!(is_overlay_window(&WindowName::new(
+            "team-agent:alpha:overview"
+        )));
+        assert!(is_overlay_window(&WindowName::new(
+            "team-agent:alpha:overview-2"
+        )));
         assert!(!is_overlay_window(&WindowName::new("developer")));
         assert!(!is_overlay_window(&WindowName::new("team-w1")));
         assert!(!is_overlay_window(&WindowName::new("team-alpha:leader")));

package/crates/team-agent/src/layout/placement.rs

@@ -42,6 +42,10 @@ pub struct WorkerSpawnTarget {
 
 impl WorkerSpawnTarget {
     pub fn new(session: SessionName, window: WindowName, action: WorkerSpawnAction) -> Self {
-        Self { session, window, action }
+        Self {
+            session,
+            window,
+            action,
+        }
     }
 }

package/crates/team-agent/src/layout/recovery.rs

@@ -92,9 +92,11 @@ mod tests {
         match recover_leader_pane(env) {
             RecoveryOutcome::NeedsUserAttach => {} // expected
             RecoveryOutcome::AutobindToPane(_) => {
-                panic!("recovery must not autobind without TMUX_PANE — \
+                panic!(
+                    "recovery must not autobind without TMUX_PANE — \
                         the worker session must NEVER carry a co-located leader \
-                        window in managed mode (E57-3 root)")
+                        window in managed mode (E57-3 root)"
+                )
             }
         }
     }

package/crates/team-agent/src/layout/runtime_sessions.rs

@@ -205,9 +205,12 @@ impl RuntimeSessions {
     /// True if a `state.session_name` looked like a leader launcher session
     /// — the exact 0.3.39 shape unit-3 must refuse before any kill.
     pub fn worker_session_name_is_leader_prefixed(&self) -> bool {
-        self.anomalies
-            .iter()
-            .any(|a| matches!(a, RuntimeSessionAnomaly::WorkerSessionNameIsLeaderPrefixed { .. }))
+        self.anomalies.iter().any(|a| {
+            matches!(
+                a,
+                RuntimeSessionAnomaly::WorkerSessionNameIsLeaderPrefixed { .. }
+            )
+        })
     }
 }
 
@@ -261,10 +264,7 @@ mod tests {
         });
         let r = RuntimeSessions::from_state(&state);
         assert_eq!(r.worker.unwrap().as_str(), "team-foo");
-        assert_eq!(
-            r.leader.unwrap().as_str(),
-            "team-agent-leader-codex-abc"
-        );
+        assert_eq!(r.leader.unwrap().as_str(), "team-agent-leader-codex-abc");
         assert!(r.anomalies.is_empty());
     }
 

package/crates/team-agent/src/layout/sessions.rs

@@ -102,12 +102,13 @@ pub fn assert_topology_invariants(state: &JsonValue, spec: &YamlValue) -> Vec<To
             ),
         });
     }
-    let agents = state
-        .get("agents")
-        .and_then(JsonValue::as_object);
+    let agents = state.get("agents").and_then(JsonValue::as_object);
     if let Some(agents) = agents {
         for (agent_id, agent) in agents {
-            let window = agent.get("window").and_then(JsonValue::as_str).unwrap_or("");
+            let window = agent
+                .get("window")
+                .and_then(JsonValue::as_str)
+                .unwrap_or("");
             if window.eq_ignore_ascii_case("leader") {
                 out.push(TopologyViolation {
                     kind: TopologyViolationKind::WorkerWindowNamedLeader,
@@ -120,7 +121,8 @@ pub fn assert_topology_invariants(state: &JsonValue, spec: &YamlValue) -> Vec<To
             }
         }
         // Pane-id collision among agents.
-        let mut by_pane: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
+        let mut by_pane: std::collections::HashMap<String, Vec<String>> =
+            std::collections::HashMap::new();
         for (agent_id, agent) in agents {
             if let Some(pane) = agent
                 .get("pane_id")
@@ -229,7 +231,10 @@ mod tests {
             "leader_receiver": { "pane_id": "%0" }
         });
         let v = assert_topology_invariants(&state, &spec_for("alpha"));
-        assert!(v.is_empty(), "clean state should produce no violations; got {v:?}");
+        assert!(
+            v.is_empty(),
+            "clean state should produce no violations; got {v:?}"
+        );
     }
 
     #[test]
@@ -243,7 +248,8 @@ mod tests {
         });
         let v = assert_topology_invariants(&state, &spec_for("alpha"));
         assert!(
-            v.iter().any(|x| matches!(x.kind, TopologyViolationKind::AgentPaneIdCollision)),
+            v.iter()
+                .any(|x| matches!(x.kind, TopologyViolationKind::AgentPaneIdCollision)),
             "must flag AgentPaneIdCollision; got {v:?}"
         );
     }
@@ -258,7 +264,8 @@ mod tests {
         });
         let v = assert_topology_invariants(&state, &spec_for("alpha"));
         assert!(
-            v.iter().any(|x| matches!(x.kind, TopologyViolationKind::LeaderPaneIdCollidesWithAgent)),
+            v.iter()
+                .any(|x| matches!(x.kind, TopologyViolationKind::LeaderPaneIdCollidesWithAgent)),
             "must flag LeaderPaneIdCollidesWithAgent; got {v:?}"
         );
     }
@@ -272,7 +279,8 @@ mod tests {
         });
         let v = assert_topology_invariants(&state, &spec_for("alpha"));
         assert!(
-            v.iter().any(|x| matches!(x.kind, TopologyViolationKind::WorkerWindowNamedLeader)),
+            v.iter()
+                .any(|x| matches!(x.kind, TopologyViolationKind::WorkerWindowNamedLeader)),
             "must flag WorkerWindowNamedLeader; got {v:?}"
         );
     }

package/crates/team-agent/src/layout/tmux_endpoint.rs

@@ -17,8 +17,8 @@
 //! policy here mirrors it byte-for-byte (verified by `endpoint_priority_matches_backend`
 //! contract tests).
 
-use std::path::Path;
 use serde_json::Value;
+use std::path::Path;
 
 /// Which state field (or fallback) supplied the chosen endpoint.
 ///