@team-agent/installer 0.3.0 → 0.3.2

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -160,6 +160,71 @@ pub(super) fn agent_rollout_path(agent: &serde_json::Value) -> Option<RolloutPat
         .map(RolloutPath::new)
 }
 
+pub(crate) fn refresh_missing_provider_sessions(
+    state: &mut serde_json::Value,
+) -> Result<bool, LifecycleError> {
+    let Some(agents) = state.get_mut("agents").and_then(serde_json::Value::as_object_mut) else {
+        return Ok(false);
+    };
+    let mut changed = false;
+    for (agent_id, agent) in agents {
+        let Some(agent_obj) = agent.as_object_mut() else {
+            continue;
+        };
+        if agent_obj
+            .get("session_id")
+            .and_then(serde_json::Value::as_str)
+            .is_some_and(|session| !session.is_empty())
+        {
+            continue;
+        }
+        let Some(spawn_cwd) = agent_obj
+            .get("spawn_cwd")
+            .and_then(serde_json::Value::as_str)
+            .filter(|cwd| !cwd.is_empty())
+        else {
+            continue;
+        };
+        let provider = agent_provider(&serde_json::Value::Object(agent_obj.clone()));
+        let adapter = crate::provider::get_adapter(provider);
+        let captured = adapter
+            .capture_session_id(agent_id, Path::new(spawn_cwd), 0)
+            .map_err(|e| LifecycleError::Provider(e.to_string()))?;
+        let Some(captured) = captured else {
+            continue;
+        };
+        if let Some(session_id) = captured.session_id {
+            agent_obj.insert(
+                "session_id".to_string(),
+                serde_json::json!(session_id.as_str()),
+            );
+            changed = true;
+        }
+        if let Some(rollout_path) = captured.rollout_path {
+            agent_obj.insert(
+                "rollout_path".to_string(),
+                serde_json::json!(rollout_path.as_path().to_string_lossy()),
+            );
+            changed = true;
+        }
+        agent_obj.insert(
+            "captured_at".to_string(),
+            serde_json::json!(chrono::Utc::now().to_rfc3339()),
+        );
+        agent_obj.insert(
+            "captured_via".to_string(),
+            serde_json::to_value(captured.captured_via)
+                .map_err(|e| LifecycleError::StatePersist(e.to_string()))?,
+        );
+        agent_obj.insert(
+            "attribution_confidence".to_string(),
+            serde_json::to_value(captured.attribution_confidence)
+                .map_err(|e| LifecycleError::StatePersist(e.to_string()))?,
+        );
+    }
+    Ok(changed)
+}
+
 /// Tools list off an agent's runtime state entry (`tools: [...]`). Restart paths
 /// don't have the full spec object, only the runtime state — so they read tools from
 /// the state row, falling back to an empty list. Contract C requires the worker

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -31,6 +31,12 @@ pub fn restart_with_transport(
     team: Option<&str>,
     transport: &dyn crate::transport::Transport,
 ) -> Result<RestartReport, LifecycleError> {
+    if crate::lifecycle::restart::input_has_no_local_team_context(workspace) {
+        return Err(LifecycleError::TeamSelect(format!(
+            "missing spec for restart: {}",
+            workspace.join("team.spec.yaml").display()
+        )));
+    }
     let run_candidate = crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     if !workspace.join("team.spec.yaml").exists()
@@ -47,7 +53,7 @@ pub fn restart_with_transport(
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
-    let state = selected.state;
+    let mut state = selected.state;
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, None)?;
     let spec_workspace = selected
         .spec_workspace
@@ -55,6 +61,10 @@ pub fn restart_with_transport(
         .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
     let spec = load_team_spec(spec_workspace)?;
     let safety = crate::lifecycle::launch::effective_runtime_config(&spec)?;
+    if refresh_missing_provider_sessions(&mut state)? {
+        crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    }
     let plan = classify_restart_plan(&state, allow_fresh)?;
     write_restart_resume_decision_events(&selected.run_workspace, &state, allow_fresh, &plan.decisions)?;
     if !plan.corrupt_entries.is_empty() {
@@ -117,7 +127,6 @@ fn write_restart_resume_decision_events(
     allow_fresh: bool,
     decisions: &[RestartedAgent],
 ) -> Result<(), LifecycleError> {
-    let log = crate::event_log::EventLog::new(workspace);
     for decision in decisions {
         let agent = state
             .get("agents")
@@ -134,23 +143,56 @@ fn write_restart_resume_decision_events(
             ResumeDecision::FreshStart => "fresh_start",
             ResumeDecision::Refuse => "refuse",
         };
-        log.write(
-            crate::lifecycle::types::event_names::RESTART_RESUME_DECISION,
-            serde_json::json!({
-                "worker_id": decision.agent_id.as_str(),
-                "has_first_send_at": first_send_at.is_some(),
-                "has_session_id": session_id.is_some(),
-                "allow_fresh": allow_fresh,
-                "decision": decision_wire,
-                "first_send_at": first_send_at,
-                "session_id": session_id,
-            }),
-        )
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        write_restart_resume_decision_event(
+            workspace,
+            decision.agent_id.as_str(),
+            first_send_at,
+            session_id,
+            allow_fresh,
+            decision_wire,
+        )?;
     }
     Ok(())
 }
 
+fn write_restart_resume_decision_event(
+    workspace: &Path,
+    worker_id: &str,
+    first_send_at: Option<String>,
+    session_id: Option<String>,
+    allow_fresh: bool,
+    decision: &str,
+) -> Result<(), LifecycleError> {
+    use std::io::Write as _;
+
+    let path = workspace.join(".team").join("logs").join("events.jsonl");
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    }
+    let event = serde_json::json!({
+        "ts": chrono::Utc::now().to_rfc3339(),
+        "event": crate::lifecycle::types::event_names::RESTART_RESUME_DECISION,
+        "worker_id": worker_id,
+        "has_first_send_at": first_send_at.is_some(),
+        "has_session_id": session_id.is_some(),
+        "allow_fresh": allow_fresh,
+        "decision": decision,
+        "first_send_at": first_send_at,
+        "session_id": session_id,
+    });
+    let line = serde_json::to_string(&event)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let mut file = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    file.write_all(line.as_bytes())
+        .and_then(|_| file.write_all(b"\n"))
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
 /// `restart_candidates(workspace)`(`restart/selection.py:12`)。从 snapshot + active
 /// state 收集可重启 team。
 pub fn restart_candidates(workspace: &Path) -> Result<Vec<RestartCandidate>, LifecycleError> {

package/crates/team-agent/src/lifecycle/restart/remove.rs

@@ -169,7 +169,11 @@ fn remove_agent_inner(
     // (team projection) — NOT a raw save, so other teams in a multi-team workspace are preserved.
     let mut removed_state = working_state;
     remove_agent_from_state(&mut removed_state, agent_id)?;
-    crate::state::projection::save_team_scoped_state(paths.run_workspace, &removed_state)
+    crate::state::projection::save_team_scoped_state_with_deleted_agents(
+        paths.run_workspace,
+        &removed_state,
+        &[agent_id.as_str()],
+    )
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     cleared_locations.push(serde_json::json!("state.json:agents"));
     write_remove_step_event(

package/crates/team-agent/src/lifecycle/restart.rs

@@ -33,6 +33,7 @@ mod team_state;
 
 pub use agent::{reset_agent, reset_agent_with_transport, start_agent, start_agent_with_transport, stop_agent, stop_agent_with_transport};
 pub(crate) use agent::start_agent_at_paths;
+pub(crate) use common::refresh_missing_provider_sessions;
 pub use orchestrator::{halt_plan, plan_status};
 pub use rebuild::{restart, restart_candidates, restart_with_transport, select_restart_state};
 pub use remove::{remove_agent, remove_agent_with_transport};
@@ -45,6 +46,13 @@ pub(crate) fn lifecycle_run_workspace(workspace: &Path) -> Result<std::path::Pat
 }
 
 fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePaths, LifecycleError> {
+    if input_has_no_local_team_context(workspace) {
+        return Err(LifecycleError::TeamSelect(format!(
+            "active team spec not found: input_workspace={} expected_spec_path={}",
+            workspace.display(),
+            workspace.join("team.spec.yaml").display()
+        )));
+    }
     let selected = crate::state::selector::resolve_active_team(
         workspace,
         team,
@@ -60,6 +68,18 @@ fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePath
     })
 }
 
+pub(crate) fn input_has_no_local_team_context(workspace: &Path) -> bool {
+    !workspace.join("team.spec.yaml").exists()
+        && !workspace.join(".team").exists()
+        && !crate::state::persist::runtime_state_path(workspace).exists()
+        && workspace.file_name().and_then(|s| s.to_str()) != Some(".team")
+        && workspace
+            .parent()
+            .and_then(|p| p.file_name())
+            .and_then(|s| s.to_str())
+            != Some(".team")
+}
+
 fn selected_state_spec_workspace(state: &serde_json::Value) -> Option<std::path::PathBuf> {
     state
         .get("spec_path")

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

@@ -67,6 +67,58 @@ fn quick_start_compiles_real_spec_to_team_spec_yaml() {
     }
 }
 
+#[test]
+fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_collect() {
+    let workspace = temp_ws();
+    let team = workspace.join(".team").join("current");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+    std::fs::write(team.join("agents").join("implementer.md"), QS_VALID_ROLE).unwrap();
+
+    let transport = OfflineTransport::new();
+    let result = quick_start_with_transport(&team, None, true, true, None, &transport);
+    assert!(matches!(result, Ok(QuickStartReport::Ready { .. })), "quick-start failed: {result:?}");
+
+    let state_path = crate::state::persist::runtime_state_path(&workspace);
+    assert!(state_path.exists(), "quick-start .team/current must persist runtime state under project root");
+    assert!(
+        !workspace.join(".team").join(".team").join("runtime").join("state.json").exists(),
+        "quick-start .team/current must not create nested .team/.team runtime state"
+    );
+
+    for input in [&workspace, &team] {
+        let selected = crate::state::selector::resolve_active_team(
+            input,
+            None,
+            crate::state::selector::SelectorMode::RuntimeOnly,
+        )
+        .expect("status/collect selector should resolve project root");
+        assert_eq!(selected.run_workspace, workspace, "input={}", input.display());
+        assert_eq!(
+            selected.spec_path.as_deref().map(std::fs::canonicalize).transpose().unwrap(),
+            Some(std::fs::canonicalize(team.join("team.spec.yaml")).unwrap()),
+            "input={}",
+            input.display()
+        );
+    }
+
+    let status = crate::cli::cmd_status(&crate::cli::StatusArgs {
+        agent: None,
+        workspace: team.clone(),
+        detail: false,
+        summary: false,
+        json: true,
+    });
+    assert!(status.is_ok(), "status should normalize teamdir to project-root runtime state: {status:?}");
+
+    let collect = crate::cli::cmd_collect(&crate::cli::CollectArgs {
+        result_file: None,
+        workspace: team.clone(),
+        json: true,
+    });
+    assert!(collect.is_ok(), "collect should normalize teamdir to the same project-root state/spec: {collect:?}");
+}
+
 // P0 — quick_start over an INVALID role doc (missing `provider`) must surface the REAL compile
 // error, distinct from the stub's hardcoded "no role docs found". Golden: compile_team raises
 // "missing front matter field provider" (compiler.py:_validate_role_doc), before preflight.

package/crates/team-agent/src/lifecycle/types.rs

@@ -445,6 +445,24 @@ pub struct PermissionSummary {
     pub raw: serde_json::Value,
 }
 
+/// BUG-7 (0.3.1): quick-start cannot honestly report "ready" before the workers'
+/// MCP tool sets have actually loaded — provider-side schema rejections (codex
+/// invalid_function_parameters etc.) happen AFTER spawn and silently disable the
+/// worker. The report must therefore carry a readiness verdict so the CLI surface
+/// never emits bare "ready" while worker capability is unverified or already known
+/// to be degraded.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum QuickStartReadiness {
+    /// At least one agent already failed to materialize a live tmux window (BUG-2
+    /// observable). The team is *not* ready; user must inspect / restart.
+    Degraded { unhealthy_agents: Vec<String> },
+    /// All spawned agents have live windows but their MCP tool set load has NOT
+    /// been verified yet — provider-side schema/auth failures could still leave
+    /// the worker unable to call team_orchestrator tools. CLI must label this
+    /// `pending` / `unverified`, NOT bare `ready`.
+    PendingToolLoad,
+}
+
 /// `quick_start(...)` 报告(`diagnose/quick_start.py:103` typed 版)。`Refused` 区分
 /// existing-context(需 restart 或 --fresh)与 preflight 失败。
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -454,6 +472,13 @@ pub enum QuickStartReport {
         session_name: SessionName,
         launch: Box<LaunchReport>,
         next_actions: Vec<String>,
+        /// BUG-7: real readiness verdict. `Ready` ⇒ the wrapper completed AND the
+        /// caller already verified tool-set availability; the framework itself
+        /// never emits this without an external observable confirming worker
+        /// tool calls succeeded. quick_start_with_transport always defaults to
+        /// [`QuickStartReadiness::PendingToolLoad`] (or `Degraded` if any agent
+        /// failed to spawn) so the CLI surface cannot lie about availability.
+        worker_readiness: QuickStartReadiness,
     },
     /// 已有 runtime state,非 --fresh → 引导用 restart(`quick_start.py:42`)。
     ExistingRuntime {

package/crates/team-agent/src/mcp_server/tests/wire.rs

@@ -68,6 +68,34 @@
         assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));
     }
 
+    #[test]
+    fn tools_contract_input_schemas_are_openai_strict_top_level_objects() {
+        let forbidden = ["oneOf", "anyOf", "allOf", "enum", "not"];
+        for tool in tools_contract() {
+            let schema = tool["inputSchema"].as_object().unwrap();
+            assert_eq!(schema.get("type"), Some(&json!("object")), "schema must be a top-level object: {tool}");
+            for key in forbidden {
+                assert!(
+                    !schema.contains_key(key),
+                    "OpenAI rejects top-level `{key}` in MCP tool schema: {tool}"
+                );
+            }
+            let properties = schema
+                .get("properties")
+                .and_then(Value::as_object)
+                .unwrap_or_else(|| panic!("schema properties must be an object: {tool}"));
+            for required in schema.get("required").and_then(Value::as_array).into_iter().flatten() {
+                let Some(name) = required.as_str() else {
+                    panic!("required entries must be strings: {tool}");
+                };
+                assert!(
+                    properties.contains_key(name),
+                    "required property `{name}` must be declared in properties: {tool}"
+                );
+            }
+        }
+    }
+
     // ════════════════════════════════════════════════════════════════════════
     // handle_mcp — JSON-RPC routing (server.py:46-91)
     // ════════════════════════════════════════════════════════════════════════

package/crates/team-agent/src/mcp_server/wire.rs

@@ -298,13 +298,93 @@ fn tool_contract(tool: McpTool) -> Value {
         "description": description,
         "inputSchema": {
             "type": "object",
-            "properties": {},
+            "properties": tool_properties(tool),
             "required": required,
             "additionalProperties": false
         }
     })
 }
 
+fn tool_properties(tool: McpTool) -> serde_json::Map<String, Value> {
+    let mut properties = serde_json::Map::new();
+    match tool {
+        McpTool::AssignTask => {
+            insert_property(&mut properties, "task", object_property("Task object to add or update."));
+            insert_property(&mut properties, "message", string_property("Optional message to deliver with the task."));
+        }
+        McpTool::SendMessage => {
+            insert_property(&mut properties, "to", string_property("Target agent id, 'leader', or '*' for broadcast."));
+            insert_property(&mut properties, "content", string_property("Message body."));
+            insert_property(&mut properties, "task_id", string_property("Optional task id to associate with the message."));
+            insert_property(&mut properties, "sender", string_property("Optional sender override."));
+            insert_property(&mut properties, "requires_ack", boolean_property("Whether the recipient should acknowledge delivery."));
+            insert_property(&mut properties, "scope", string_property("Optional delivery scope: team or workspace."));
+        }
+        McpTool::ReportResult => {
+            insert_property(&mut properties, "envelope", object_property("Optional full result envelope."));
+            insert_property(&mut properties, "summary", string_property("Short result summary."));
+            insert_property(&mut properties, "status", string_property("Result status."));
+            insert_property(&mut properties, "changes", array_property("Changed files or artifacts."));
+            insert_property(&mut properties, "tests", array_property("Tests or checks performed."));
+            insert_property(&mut properties, "risks", array_property("Risks or blockers."));
+            insert_property(&mut properties, "artifacts", array_property("Artifact references."));
+            insert_property(&mut properties, "next_actions", array_property("Suggested next actions."));
+            insert_property(&mut properties, "task_id", string_property("Optional task id override."));
+            insert_property(&mut properties, "agent_id", string_property("Optional reporting agent id override."));
+        }
+        McpTool::UpdateState => {
+            insert_property(&mut properties, "note", string_property("Note to append to team state."));
+        }
+        McpTool::GetTeamStatus | McpTool::StuckList => {}
+        McpTool::StopAgent => {
+            insert_property(&mut properties, "agent_id", string_property("Agent id to stop."));
+        }
+        McpTool::ResetAgent => {
+            insert_property(&mut properties, "agent_id", string_property("Agent id to reset."));
+            insert_property(&mut properties, "discard_session", boolean_property("Whether to discard the existing provider session."));
+        }
+        McpTool::AddAgent => {
+            insert_property(&mut properties, "new_agent_id", string_property("New agent id."));
+            insert_property(&mut properties, "role_file_path", string_property("Workspace-relative role file path."));
+        }
+        McpTool::ForkAgent => {
+            insert_property(&mut properties, "source_agent_id", string_property("Agent id to fork from."));
+            insert_property(&mut properties, "as_agent_id", string_property("Agent id for the forked worker."));
+            insert_property(&mut properties, "label", string_property("Optional display label."));
+        }
+        McpTool::RequestHuman => {
+            insert_property(&mut properties, "question", string_property("Question to ask the human."));
+            insert_property(&mut properties, "task_id", string_property("Optional related task id."));
+            insert_property(&mut properties, "agent_id", string_property("Optional requesting agent id."));
+        }
+        McpTool::StuckCancel => {
+            insert_property(&mut properties, "agent_id", string_property("Agent id whose stuck alerts should be suppressed."));
+            insert_property(&mut properties, "alert_type", string_property("Alert type to suppress, or all."));
+        }
+    }
+    properties
+}
+
+fn insert_property(properties: &mut serde_json::Map<String, Value>, name: &str, schema: Value) {
+    properties.insert(name.to_string(), schema);
+}
+
+fn string_property(description: &str) -> Value {
+    serde_json::json!({"type": "string", "description": description})
+}
+
+fn boolean_property(description: &str) -> Value {
+    serde_json::json!({"type": "boolean", "description": description})
+}
+
+fn object_property(description: &str) -> Value {
+    serde_json::json!({"type": "object", "description": description, "additionalProperties": true})
+}
+
+fn array_property(description: &str) -> Value {
+    serde_json::json!({"type": "array", "description": description, "items": {"type": "object", "additionalProperties": true}})
+}
+
 pub(crate) fn dispatch_tool(tools: &TeamOrchestratorTools, tool: McpTool, args: &Value) -> ToolResult {
     match tool {
         McpTool::AssignTask => tools.assign_task(args.get("task").unwrap_or(args), args.get("message").and_then(Value::as_str)),