@team-agent/installer 0.3.1 → 0.3.3

package/Cargo.lock

@@ -153,6 +153,16 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "fslock"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04412b8935272e3a9bae6f48c7bfff74c2911f60525404edfdd28e49884c3bfb"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "futures-core"
 version = "0.3.32"
@@ -494,6 +504,7 @@ version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "699f4197115b8a7e7ff19c9a315a4bd6fffec26cc4626ef45ecaea389e081c6d"
 dependencies = [
+ "fslock",
  "futures-executor",
  "futures-util",
  "log",
@@ -555,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [
  "anyhow",
  "chrono",
@@ -658,6 +669,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-core"
 version = "0.62.2"

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.1"
+version = "0.3.3"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/Cargo.toml

@@ -27,7 +27,7 @@ libc.workspace = true
 rusqlite.workspace = true       # step 3 db(bundled SQLite,静态链接)
 
 [dev-dependencies]
-serial_test = "3"
+serial_test = { version = "3", features = ["file_locks"] }
 
 [lints]
 workspace = true

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

@@ -44,6 +44,9 @@ pub fn cmd_init(args: &InitArgs) -> Result<CmdResult, CliError> {
     let team_root = args.workspace.join(".team");
     let spec_path = team_root.join("current").join("team.spec.yaml");
     let state_path = args.workspace.join("team_state.md");
+    let team_md_path = args.workspace.join("TEAM.md");
+    let agents_dir = args.workspace.join("agents");
+    let default_agent_path = agents_dir.join("worker.md");
     if spec_path.exists() && !args.force {
         return Err(CliError::Runtime(format!(
             "{} already exists; pass --force to overwrite",
@@ -57,10 +60,23 @@ pub fn cmd_init(args: &InitArgs) -> Result<CmdResult, CliError> {
         team_root.join("logs"),
         team_root.join("messages"),
         team_root.join("artifacts"),
+        agents_dir.clone(),
     ] {
         std::fs::create_dir_all(&dir)?;
     }
     std::fs::write(&spec_path, INIT_SPEC_TEMPLATE)?;
+    if args.force || !team_md_path.exists() {
+        std::fs::write(
+            &team_md_path,
+            "---\nname: current\nobjective: Pending.\nprovider: fake\n---\n\nPending.\n",
+        )?;
+    }
+    if args.force || !default_agent_path.exists() {
+        std::fs::write(
+            &default_agent_path,
+            "---\nname: worker\nrole: Worker\nprovider: fake\ntools:\n  - mcp_team\n---\n\nWait for instructions.\n",
+        )?;
+    }
     if args.force || !state_path.exists() {
         std::fs::write(&state_path, INIT_STATE_TEMPLATE)?;
     }
@@ -85,15 +101,37 @@ pub fn cmd_init(args: &InitArgs) -> Result<CmdResult, CliError> {
 /// `cmd_quick_start`(`commands.py:18`)。`--json` 或 `!ok` → 整 dict;否则 `result["summary"]`。
 pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
     let value = lifecycle_port::quick_start(
-        &args.agents_dir,
+        &args.workspace,
         &args.agents_dir,
         args.name.as_deref(),
         args.team_id.as_deref(),
         args.yes,
         args.fresh,
     )?;
-    if args.json || value.get("ok").and_then(Value::as_bool) == Some(false) {
-        Ok(CmdResult::from_json(value, args.json))
+    let readiness = value.get("readiness").and_then(Value::as_object);
+    let all_resumable_have_session = readiness
+        .and_then(|readiness| readiness.get("all_resumable_have_session"))
+        .and_then(Value::as_bool)
+        .unwrap_or(true);
+    let session_capture_incomplete = readiness
+        .and_then(|readiness| readiness.get("session_capture_incomplete"))
+        .and_then(Value::as_bool)
+        .unwrap_or(!all_resumable_have_session);
+    let readiness_ready = readiness
+        .and_then(|readiness| readiness.get("ready"))
+        .and_then(Value::as_bool)
+        .unwrap_or(true);
+    let status = value.get("status").and_then(Value::as_str).map(str::to_string);
+    if args.json
+        || value.get("ok").and_then(Value::as_bool) == Some(false)
+        || session_capture_incomplete
+        || !readiness_ready
+    {
+        let mut result = CmdResult::from_json(value, args.json);
+        if args.json && status.as_deref() == Some("pending_tool_load") {
+            result.exit = ExitCode::Ok;
+        }
+        Ok(result)
     } else {
         Ok(CmdResult::human(
             value
@@ -123,6 +161,10 @@ pub fn cmd_compile(args: &CompileArgs) -> Result<CmdResult, CliError> {
 /// `cmd_status`(`commands.py:90`)。三态:`--summary`(xor json,xor agent)→五行文本;
 /// `--json`→`status_port::status(compact=!detail)`;else→`status_port::format_status(agent)`。
 pub fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
+    cmd_status_for_team(args, None)
+}
+
+pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdResult, CliError> {
     if args.summary && args.json {
         return Err(CliError::Runtime(
             "--summary and --json are mutually exclusive".to_string(),
@@ -135,7 +177,7 @@ pub fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
     }
     let selected = match crate::state::selector::resolve_active_team(
         &args.workspace,
-        None,
+        team,
         crate::state::selector::SelectorMode::RuntimeOnly,
     ) {
         Ok(selected) => selected,
@@ -147,15 +189,29 @@ pub fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
         }
     };
     if args.summary {
-        let value = status_port::status(&selected.run_workspace, true, false)?;
+        let value = status_port::status_scoped(
+            &selected.run_workspace,
+            &selected.state,
+            Some(&selected.team_key),
+            true,
+            false,
+        )?;
         return Ok(CmdResult::human(format_status_summary(&value)));
     }
     if args.json {
-        let value = status_port::status(&selected.run_workspace, status_compact_flag(args.detail), args.detail)?;
+        let value = status_port::status_scoped(
+            &selected.run_workspace,
+            &selected.state,
+            Some(&selected.team_key),
+            status_compact_flag(args.detail),
+            args.detail,
+        )?;
         return Ok(CmdResult::from_json(value, true));
     }
-    Ok(CmdResult::human(status_port::format_status(
+    Ok(CmdResult::human(status_port::format_status_scoped(
         &selected.run_workspace,
+        &selected.state,
+        Some(&selected.team_key),
         args.agent.as_deref(),
     )?))
 }
@@ -252,9 +308,13 @@ pub fn cmd_validate_result(args: &ValidateResultArgs) -> Result<CmdResult, CliEr
 
 /// `cmd_collect`(`parser.py:292`)。
 pub fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
+    cmd_collect_for_team(args, None)
+}
+
+pub fn cmd_collect_for_team(args: &CollectArgs, team: Option<&str>) -> Result<CmdResult, CliError> {
     let selected = match crate::state::selector::resolve_active_team(
         &args.workspace,
-        None,
+        team,
         crate::state::selector::SelectorMode::RuntimeOnly,
     ) {
         Ok(selected) => selected,
@@ -269,7 +329,16 @@ pub fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
             ));
         }
     };
-    let value = match messaging::collect(&selected.run_workspace, args.result_file.as_deref(), false) {
+    let value = match if team.is_some() {
+        messaging::collect_for_team(
+            &selected.run_workspace,
+            args.result_file.as_deref(),
+            false,
+            Some(&selected.team_key),
+        )
+    } else {
+        messaging::collect(&selected.run_workspace, args.result_file.as_deref(), false)
+    } {
         Ok(value) => value,
         Err(error) => {
             return Ok(CmdResult::from_json(
@@ -329,7 +398,18 @@ pub fn cmd_settle(args: &SettleArgs) -> Result<CmdResult, CliError> {
 }
 
 fn settle_value(workspace: &Path) -> Result<Value, CliError> {
-    let mut collect = messaging::collect(workspace, None, false)?;
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        None,
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let mut collect = messaging::collect_for_team(
+        &selected.run_workspace,
+        None,
+        false,
+        Some(&selected.team_key),
+    )?;
     if collect.get("ok").and_then(Value::as_bool) == Some(false) {
         let message = collect
             .get("error")
@@ -338,7 +418,7 @@ fn settle_value(workspace: &Path) -> Result<Value, CliError> {
         return Err(CliError::Runtime(message.to_string()));
     }
     let coordinator_log = crate::coordinator::coordinator_log_path(
-        &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
+        &crate::coordinator::WorkspacePath::new(selected.run_workspace.clone()),
     );
     let collect_object = collect
         .as_object_mut()
@@ -351,21 +431,92 @@ fn settle_value(workspace: &Path) -> Result<Value, CliError> {
             "log": coordinator_log.to_string_lossy().to_string(),
         }),
     );
-    let status = status_port::status(workspace, true, false)?;
-    let details_log = write_settle_details_log(workspace, &collect, &status)?;
+    collect_object.insert("team_key".to_string(), json!(selected.team_key.clone()));
+    collect_object.insert("active_team_key".to_string(), json!(selected.team_key.clone()));
+    collect_object.insert("team".to_string(), json!(selected.team_key.clone()));
+    if let Some(collected_results) = collect_object.get("collected_results").cloned() {
+        collect_object.insert("collected".to_string(), collected_results);
+    }
+    let status_state =
+        crate::state::projection::select_runtime_state(&selected.run_workspace, Some(&selected.team_key))?;
+    let state_file = match (selected.spec_path.as_ref(), selected.spec_workspace.as_ref()) {
+        (Some(spec_path), Some(spec_workspace)) => match load_team_spec_at(spec_path)? {
+            Some(spec) => crate::lifecycle::restart::write_team_state(spec_workspace, &spec, &status_state)
+                .map_err(|e| CliError::Runtime(e.to_string()))?
+                .to_string_lossy()
+                .to_string(),
+            None => collect
+                .get("state_file")
+                .and_then(Value::as_str)
+                .unwrap_or("")
+                .to_string(),
+        },
+        _ => collect
+            .get("state_file")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_string(),
+    };
+    if let Some(obj) = collect.as_object_mut() {
+        obj.insert("state_file".to_string(), json!(state_file.clone()));
+    }
+    let mut status = status_port::status_scoped(
+        &selected.run_workspace,
+        &status_state,
+        Some(&selected.team_key),
+        true,
+        false,
+    )?;
+    if let Some(obj) = status.as_object_mut() {
+        obj.insert("team_key".to_string(), json!(selected.team_key.clone()));
+        obj.insert("active_team_key".to_string(), json!(selected.team_key.clone()));
+        obj.insert("team".to_string(), json!(selected.team_key.clone()));
+    }
+    let details_log = write_settle_details_log(&selected.run_workspace, &collect, &status)?;
     let collected_count = collect
         .get("collected")
         .and_then(Value::as_array)
         .map_or(0, Vec::len);
+    let settled_results = settle_collected_results_for_team(
+        collect.get("collected_results"),
+        &selected.team_key,
+    );
     Ok(json!({
         "ok": true,
         "summary": format!("collected {collected_count} result(s)"),
         "next_actions": ["Review team_state.md and decide whether to continue or shutdown."],
         "details_log": details_log.to_string_lossy().to_string(),
+        "collected_results": settled_results,
+        "collected": collect.get("collected").cloned().unwrap_or_else(|| json!([])),
+        "results": collect.get("results").cloned().unwrap_or_else(|| json!({})),
+        "state_file": state_file,
+        "status": status,
         "collect": collect,
+        "team_key": selected.team_key,
+        "active_team_key": selected.team_key,
+        "team": selected.team_key,
+        "workspace": selected.run_workspace.to_string_lossy().to_string(),
     }))
 }
 
+fn settle_collected_results_for_team(value: Option<&Value>, team_key: &str) -> Value {
+    let Some(Value::Array(results)) = value else {
+        return json!([]);
+    };
+    Value::Array(
+        results
+            .iter()
+            .map(|result| {
+                let mut result = result.clone();
+                if let Some(obj) = result.as_object_mut() {
+                    obj.insert("owner_team_id".to_string(), json!(team_key));
+                }
+                result
+            })
+            .collect(),
+    )
+}
+
 fn write_settle_details_log(workspace: &Path, collect: &Value, status: &Value) -> Result<PathBuf, CliError> {
     let logs = workspace.join(".team").join("logs");
     std::fs::create_dir_all(&logs)?;
@@ -396,7 +547,13 @@ pub fn cmd_repair_state(args: &RepairStateArgs) -> Result<CmdResult, CliError> {
             args.status
         )));
     }
-    let mut state = crate::state::persist::load_runtime_state(&args.workspace)?;
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        None,
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let mut state = selected.state;
     let before = find_task_projection(&state, &args.task_id).unwrap_or_else(repair_task_projection_null);
     update_task(
         &mut state,
@@ -406,12 +563,20 @@ pub fn cmd_repair_state(args: &RepairStateArgs) -> Result<CmdResult, CliError> {
         args.summary.as_deref(),
     );
     let after = find_task_projection(&state, &args.task_id).unwrap_or_else(repair_task_projection_null);
-    crate::state::persist::save_runtime_state(&args.workspace, &state)?;
-    let spec = load_team_spec_optional(&args.workspace, &state)?
+    crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)?;
+    let spec_path = selected
+        .spec_path
+        .as_ref()
+        .ok_or_else(|| CliError::Runtime("team.spec.yaml not found".to_string()))?;
+    let spec = load_team_spec_at(spec_path)?
         .ok_or_else(|| CliError::Runtime("team.spec.yaml not found".to_string()))?;
-    let state_file = crate::lifecycle::restart::write_team_state(&args.workspace, &spec, &state)
+    let spec_workspace = selected
+        .spec_workspace
+        .as_ref()
+        .ok_or_else(|| CliError::Runtime("active team spec workspace not found".to_string()))?;
+    let state_file = crate::lifecycle::restart::write_team_state(spec_workspace, &spec, &state)
         .map_err(|e| CliError::Runtime(e.to_string()))?;
-    crate::event_log::EventLog::new(&args.workspace)
+    crate::event_log::EventLog::new(&selected.run_workspace)
         .write(
             "repair_state.task",
             json!({
@@ -435,9 +600,15 @@ pub fn cmd_repair_state(args: &RepairStateArgs) -> Result<CmdResult, CliError> {
 
 /// `cmd_diagnose`(`parser.py:298`)。
 pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
-    let state = crate::state::persist::load_runtime_state(&args.workspace)?;
-    let event_log = args.workspace.join(".team").join("logs").join("events.jsonl");
-    let backend = crate::tmux_backend::TmuxBackend::for_workspace(&args.workspace);
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        None,
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let state = selected.state;
+    let event_log = selected.run_workspace.join(".team").join("logs").join("events.jsonl");
+    let backend = crate::tmux_backend::TmuxBackend::for_workspace(&selected.run_workspace);
     let (issues, suggested_repairs) = diagnose_runtime(&state, &backend);
     let ok = issues.as_array().is_some_and(Vec::is_empty);
     Ok(CmdResult::from_json(
@@ -448,6 +619,7 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
             "providers": provider_doctor_checks(),
             "runtime": {
                 "workspace": args.workspace.to_string_lossy().to_string(),
+                "team_key": selected.team_key,
                 "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
                 "leader_receiver": state.get("leader_receiver").cloned().unwrap_or(Value::Null),
                 "agent_count": state.get("agents").and_then(Value::as_object).map_or(0, serde_json::Map::len),
@@ -528,18 +700,33 @@ pub fn cmd_peek(args: &PeekArgs) -> Result<CmdResult, CliError> {
     if !windows.iter().any(|w| w.as_str() == window) {
         return Ok(peek_unavailable(&args.agent, args.json));
     }
+    let range = args
+        .head
+        .map(|head| crate::transport::CaptureRange::Head(head as u32))
+        .unwrap_or_else(|| crate::transport::CaptureRange::Tail(args.tail as u32));
     let capture = backend
         .capture(
             &crate::transport::Target::Pane(crate::transport::PaneId::new(target.clone())),
-            crate::transport::CaptureRange::Tail(args.tail as u32),
+            range,
         )
         .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let matches = args.search.as_ref().map(|needle| {
+        capture
+            .text
+            .lines()
+            .filter(|line| line.contains(needle))
+            .map(str::to_string)
+            .collect::<Vec<_>>()
+    });
     Ok(CmdResult::from_json(
         json!({
             "ok": true,
             "agent_id": args.agent,
             "workspace": args.workspace.to_string_lossy().to_string(),
             "tail": args.tail,
+            "head": args.head,
+            "search": args.search,
+            "matches": matches,
             "pane_id": target,
             "text": capture.text,
         }),
@@ -603,6 +790,12 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
         "reason": send.reason,
     });
     if send.ok {
+        if let Some(message_id) = send.message_id.as_deref() {
+            crate::message_store::MessageStore::open(workspace)
+                .map_err(crate::messaging::MessagingError::from)?
+                .mark(message_id, "delivered", None)
+                .map_err(crate::messaging::MessagingError::from)?;
+        }
         let _ = messaging::report_result(
             workspace,
             &json!({
@@ -1052,6 +1245,16 @@ fn load_team_spec_optional(workspace: &Path, state: &Value) -> Result<Option<cra
         .map_err(|e| CliError::Runtime(e.to_string()))
 }
 
+fn load_team_spec_at(spec_path: &Path) -> Result<Option<crate::model::yaml::Value>, CliError> {
+    if !spec_path.exists() {
+        return Ok(None);
+    }
+    let text = std::fs::read_to_string(spec_path)?;
+    crate::model::yaml::loads(&text)
+        .map(Some)
+        .map_err(|e| CliError::Runtime(e.to_string()))
+}
+
 /// `cmd_approvals`(`commands.py:112`)。
 pub fn cmd_approvals(args: &ApprovalsArgs) -> Result<CmdResult, CliError> {
     let value = status_port::approvals(&args.workspace, args.agent.as_deref(), args.json)?;
@@ -1167,7 +1370,12 @@ pub fn cmd_shutdown(args: &ShutdownArgs) -> Result<CmdResult, CliError> {
 /// `cmd_restart`(`commands.py:344`)。
 pub fn cmd_restart(args: &RestartArgs) -> Result<CmdResult, CliError> {
     Ok(CmdResult::from_json(
-        lifecycle_port::restart(&args.workspace, args.allow_fresh, args.team.as_deref())?,
+        lifecycle_port::restart(
+            &args.workspace,
+            args.allow_fresh,
+            args.team.as_deref(),
+            args.session_converge_deadline_ms,
+        )?,
         args.json,
     ))
 }
@@ -1283,7 +1491,7 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
         return Err(CliError::Runtime("--fix requires --gate".to_string()));
     }
     if args.comms || matches!(args.gate, Some(DoctorGate::Comms)) {
-        let value = diagnose_port::comms_selftest(&args.workspace, args.team.as_deref(), Some("comms"))?;
+        let value = crate::diagnose::comms::doctor_comms_json(&args.workspace, args.team.as_deref(), Some("comms"))?;
         if !args.json {
             let json_tail = serde_json::to_string_pretty(&sort_json(&value))?;
             return Ok(CmdResult::human(format!("{COMMS_BOUNDARY_TEXT}\n{json_tail}")));
@@ -1291,9 +1499,9 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
         return Ok(CmdResult::from_json(value, true));
     }
     let value = if matches!(args.gate, Some(DoctorGate::Orphans)) {
-        diagnose_port::orphan_gate(args.fix, args.confirm)?
+        crate::diagnose::orphans::orphan_gate_json(args.fix, args.confirm)?
     } else if args.cleanup_orphans {
-        diagnose_port::cleanup_orphans(args.confirm)?
+        crate::diagnose::orphans::cleanup_orphans_json(args.confirm)?
     } else if args.fix_schema {
         diagnose_port::fix_schema(&args.workspace)?
     } else {