@team-agent/installer 0.3.1 → 0.3.3

package/crates/team-agent/src/messaging/selftest.rs

@@ -3,11 +3,12 @@
 use std::path::Path;
 
 use crate::model::ids::TeamKey;
+use crate::message_store::MessageStore;
 
 use super::helpers::next_run_id;
 use super::{
-    CheckEvidence, CheckKind, CheckStatus, IdleEvaluation, MessagingError, ProviderSdkCalls,
-    SelftestCheck, SelftestReport,
+    CheckEvidence, CheckKind, CheckStatus, ContractSuiteCheck, IdleEvaluation, MessagingError,
+    ProviderSdkCalls, SelftestCheck, SelftestReport,
 };
 
 /// selftest driver (`diagnose/comms.py` `CommsSelftestDriver`):**零 token / 零 provider SDK**
@@ -29,6 +30,7 @@ pub fn run_comms_selftest(
     team: Option<&TeamKey>,
     driver: &dyn CommsSelftestDriver,
 ) -> Result<SelftestReport, MessagingError> {
+    let run_id = driver.run_id().unwrap_or_else(next_run_id);
     let binding = driver.receiver_binding(workspace, team);
     let mismatches = binding
         .get("mismatches")
@@ -43,29 +45,33 @@ pub fn run_comms_selftest(
     let receiver_status = if mismatches.is_empty() { CheckStatus::Pass } else { CheckStatus::Fail };
     let calls = driver.provider_sdk_calls();
     let provider_status = if calls.is_zero() { CheckStatus::Pass } else { CheckStatus::Fail };
-    let run_id = driver.run_id().unwrap_or_else(next_run_id);
+    let contract_checks = run_contract_suite(workspace, team, &run_id);
+    let contract_status = if contract_checks.iter().all(|check| check.status == CheckStatus::Pass) {
+        CheckStatus::Pass
+    } else {
+        CheckStatus::Fail
+    };
     let receiver_binding = SelftestCheck {
         status: receiver_status,
         verifies: CheckKind::ReceiverBinding,
-        evidence: CheckEvidence::Binding { mismatches },
+        evidence: CheckEvidence::Binding { mismatches, details: binding },
     };
     let contract_suite = SelftestCheck {
-        status: CheckStatus::Deferred,
+        status: contract_status,
         verifies: CheckKind::ContractSuite,
-        evidence: CheckEvidence::Deferred { reason: "contract_suite_not_shipped".to_string() },
+        evidence: CheckEvidence::ContractSuite { checks: contract_checks },
     };
     let provider_sdk_calls = SelftestCheck {
         status: provider_status,
         verifies: CheckKind::NoProviderSdkCalls,
         evidence: CheckEvidence::ProviderSdkCalls(calls),
     };
+    let ok = receiver_binding.status == CheckStatus::Pass
+        && contract_suite.status == CheckStatus::Pass
+        && provider_sdk_calls.status == CheckStatus::Pass;
     Ok(SelftestReport {
-        ok: receiver_binding.status == CheckStatus::Pass && provider_sdk_calls.status == CheckStatus::Pass,
-        status: if receiver_binding.status == CheckStatus::Pass && provider_sdk_calls.status == CheckStatus::Pass {
-            CheckStatus::Pass
-        } else {
-            CheckStatus::Fail
-        },
+        ok,
+        status: if ok { CheckStatus::Pass } else { CheckStatus::Fail },
         run_id,
         scope: "binding_consistency".to_string(),
         boundary: "messaging".to_string(),
@@ -75,6 +81,187 @@ pub fn run_comms_selftest(
     })
 }
 
+fn run_contract_suite(
+    workspace: &Path,
+    team: Option<&TeamKey>,
+    run_id: &str,
+) -> Vec<ContractSuiteCheck> {
+    let scratch = std::env::temp_dir().join(format!(
+        "ta-comms-contract-{run_id}-{}",
+        std::process::id()
+    ));
+    let _ = std::fs::remove_dir_all(&scratch);
+    let mut checks = Vec::new();
+    let mut scratch_store = match MessageStore::open(&scratch) {
+        Ok(store) => {
+            checks.push(contract_check("message_store_schema", CheckStatus::Pass, None));
+            Some(store)
+        }
+        Err(error) => {
+            checks.push(contract_check(
+                "message_store_schema",
+                CheckStatus::Fail,
+                Some(error.to_string()),
+            ));
+            None
+        }
+    };
+
+    match scratch_store.as_ref().and_then(|store| {
+        store
+            .create_message(
+                None,
+                "doctor",
+                "worker",
+                "comms contract probe",
+                None,
+                false,
+                Some("contract-team"),
+            )
+            .ok()
+    }) {
+        Some(message_id) if message_id.starts_with("msg_") && message_id.len() > 4 => {
+            let rendered = format!(
+                "Team Agent message from doctor:\n\ncomms contract probe\n\n[team-agent-token:{message_id}]"
+            );
+            let token = format!("[team-agent-token:{message_id}]");
+            checks.push(contract_check(
+                "message_token_shape",
+                if rendered.ends_with(&token) { CheckStatus::Pass } else { CheckStatus::Fail },
+                (!rendered.ends_with(&token)).then(|| "rendered token suffix missing".to_string()),
+            ));
+        }
+        Some(_) => checks.push(contract_check(
+            "message_token_shape",
+            CheckStatus::Fail,
+            Some("message id did not use msg_ prefix".to_string()),
+        )),
+        None => checks.push(contract_check(
+            "message_token_shape",
+            CheckStatus::Fail,
+            Some("could not create scratch message".to_string()),
+        )),
+    }
+
+    let result_id = format!("res-comms-{run_id}");
+    let result_content = super::watchers::format_result_watcher_notification(&serde_json::json!({
+        "result_id": result_id,
+        "task_id": "comms-contract",
+        "agent_id": "doctor",
+        "status": "success",
+        "summary": "contract suite probe",
+    }));
+    let parsed_result_id = super::watchers::result_id_from_text(&result_content);
+    checks.push(contract_check(
+        "result_notification_render",
+        if parsed_result_id.as_deref() == Some(result_id.as_str()) {
+            CheckStatus::Pass
+        } else {
+            CheckStatus::Fail
+        },
+        (parsed_result_id.as_deref() != Some(result_id.as_str()))
+            .then(|| "result notification did not round-trip result_id".to_string()),
+    ));
+
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        team.map(TeamKey::as_str),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    );
+    match (scratch_store.take(), selected) {
+        (Some(store), Ok(selected)) => {
+            let owner_team = selected.team_key;
+            let mut state = selected.state;
+            if !state.is_object() {
+                state = serde_json::json!({});
+            }
+            if let Some(obj) = state.as_object_mut() {
+                obj.insert(
+                    "active_team_key".to_string(),
+                    serde_json::json!(owner_team.clone()),
+                );
+            }
+            let event_log = crate::event_log::EventLog::new(&scratch);
+            let outcome = super::leader_receiver::send_to_leader_receiver(
+                &scratch,
+                &state,
+                "leader",
+                "comms contract leader projection",
+                None,
+                "doctor",
+                false,
+                Some("comms-contract-result"),
+                &event_log,
+            );
+            match outcome {
+                Ok(outcome) => {
+                    let actual_owner = outcome
+                        .message_id
+                        .as_deref()
+                        .and_then(|message_id| message_owner_team(store.db_path(), message_id).ok().flatten());
+                    checks.push(contract_check(
+                        "leader_projection_owner_team",
+                        if actual_owner.as_deref() == Some(owner_team.as_str()) {
+                            CheckStatus::Pass
+                        } else {
+                            CheckStatus::Fail
+                        },
+                        (actual_owner.as_deref() != Some(owner_team.as_str())).then(|| {
+                            format!(
+                                "leader-bound message owner_team_id={:?}, expected={owner_team}",
+                                actual_owner
+                            )
+                        }),
+                    ));
+                }
+                Err(error) => checks.push(contract_check(
+                    "leader_projection_owner_team",
+                    CheckStatus::Fail,
+                    Some(error.to_string()),
+                )),
+            }
+        }
+        (_, Err(error)) => checks.push(contract_check(
+            "leader_projection_owner_team",
+            CheckStatus::Fail,
+            Some(error.to_string()),
+        )),
+        (None, _) => checks.push(contract_check(
+            "leader_projection_owner_team",
+            CheckStatus::Fail,
+            Some("message store schema unavailable".to_string()),
+        )),
+    }
+
+    let _ = std::fs::remove_dir_all(&scratch);
+    checks
+}
+
+fn contract_check(
+    name: &str,
+    status: CheckStatus,
+    reason: Option<String>,
+) -> ContractSuiteCheck {
+    ContractSuiteCheck {
+        name: name.to_string(),
+        status,
+        reason,
+    }
+}
+
+fn message_owner_team(
+    db_path: &Path,
+    message_id: &str,
+) -> Result<Option<String>, MessagingError> {
+    let conn = crate::db::schema::open_db(db_path)?;
+    let owner = conn.query_row(
+        "select owner_team_id from messages where message_id = ?1",
+        rusqlite::params![message_id],
+        |row| row.get::<_, Option<String>>(0),
+    )?;
+    Ok(owner)
+}
+
 /// `evaluate_idle_behavior` (`diagnose/comms.py:50`):idle 分类准确性评估。零 token,走 driver。
 pub fn evaluate_idle_behavior(
     workspace: &Path,

package/crates/team-agent/src/messaging/send.rs

@@ -138,9 +138,6 @@ pub fn send_message(
     };
     // send.py:259-261 — a non-leader target that is NOT a known team agent is refused
     // (target_not_in_team), NOT persisted. Membership = the runtime state's `agents` map.
-    if let Some(outcome) = send_owner_gate_refusal(workspace, &state, &opts.sender)? {
-        return Ok(outcome);
-    }
     let in_team = state
         .get("agents")
         .and_then(|a| a.as_object())
@@ -148,6 +145,19 @@ pub fn send_message(
     if !in_team {
         return Ok(refused_outcome(DeliveryRefusal::TargetNotInTeam));
     }
+    if let Some(outcome) = session_drift_refusal(
+        &state,
+        recipient,
+        "leader",
+        &opts.sender,
+        opts.task_id.as_ref(),
+        &event_log,
+    )? {
+        return Ok(outcome);
+    }
+    if let Some(outcome) = send_owner_gate_refusal(workspace, &state, &opts.sender)? {
+        return Ok(outcome);
+    }
     if opts.route_task_id {
         if let Some(task_id) = opts.task_id.as_ref() {
             if !task_exists(&state, task_id) {
@@ -367,6 +377,14 @@ fn owner_gate_hint_team_key(state: &serde_json::Value) -> String {
 }
 
 fn owner_pane_is_dead(state: &serde_json::Value) -> bool {
+    if state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get("status"))
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|status| status == "unbound")
+    {
+        return true;
+    }
     let Some(pane_id) = state
         .get("team_owner")
         .and_then(|owner| owner.get("pane_id"))
@@ -375,6 +393,9 @@ fn owner_pane_is_dead(state: &serde_json::Value) -> bool {
     else {
         return false;
     };
+    if pane_id == "__team_agent_unbound__" {
+        return true;
+    }
     if pane_id.contains("dead") {
         return true;
     }
@@ -519,12 +540,15 @@ fn fanout_send(
     channel_label: &str,
 ) -> Result<DeliveryOutcome, MessagingError> {
     let mut last_message_id: Option<String> = None;
+    let mut first_failure: Option<DeliveryOutcome> = None;
     let mut any_failure = false;
     let mut delivered_count = 0usize;
+    let mut attempted_count = 0usize;
     for recipient in recipients {
         if recipient.is_empty() || recipient == &opts.sender {
             continue;
         }
+        attempted_count = attempted_count.saturating_add(1);
         let outcome = if recipient == "leader" {
             send_to_leader_receiver(
                 workspace,
@@ -556,6 +580,14 @@ fn fanout_send(
             }
         } else {
             any_failure = true;
+            if first_failure.is_none() {
+                first_failure = Some(outcome);
+            }
+        }
+    }
+    if delivered_count == 0 && attempted_count == 1 {
+        if let Some(outcome) = first_failure {
+            return Ok(outcome);
         }
     }
     let status = if any_failure {

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -957,16 +957,31 @@ fn run_comms_selftest_nonzero_provider_sdk_fails_gate() {
 }
 
 #[test]
-fn run_comms_selftest_contract_suite_is_deferred() {
-    // diagnose/comms.py:132-139 — contract_suite is always deferred (test files
-    // not shipped) and counts as a pass for the overall gate.
+fn run_comms_selftest_contract_suite_is_executable_zero_token() {
     let ws = tmp_ws("selftestdefer");
     let driver = ZeroSdkDriver {
         run_id: Some("r3".to_string()),
         calls: ProviderSdkCalls::default(),
     };
     let report = run_comms_selftest(&ws, None, &driver).unwrap();
-    assert_eq!(report.contract_suite.status, CheckStatus::Deferred);
+    assert_eq!(report.contract_suite.status, CheckStatus::Pass);
+    match &report.contract_suite.evidence {
+        CheckEvidence::ContractSuite { checks } => {
+            assert!(
+                checks.iter().all(|check| check.status == CheckStatus::Pass),
+                "contract suite subchecks must all pass: {checks:?}"
+            );
+            let names: Vec<&str> = checks.iter().map(|check| check.name.as_str()).collect();
+            assert!(
+                names.contains(&"message_store_schema")
+                    && names.contains(&"message_token_shape")
+                    && names.contains(&"result_notification_render")
+                    && names.contains(&"leader_projection_owner_team"),
+                "contract suite must cover schema, token, result notification, and leader projection: {names:?}"
+            );
+        }
+        other => panic!("expected ContractSuite evidence, got {other:?}"),
+    }
 }
 
 // ════════════════════════════════════════════════════════════════════════

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

@@ -229,9 +229,17 @@ pub enum CheckEvidence {
     /// `no_provider_sdk_calls` 的机械证据 (§84):三 SDK 调用计数。
     ProviderSdkCalls(ProviderSdkCalls),
     /// binding 一致性比对结果 (mismatch 列表)。
-    Binding { mismatches: Vec<String> },
-    /// contract_suite deferred 占位。
-    Deferred { reason: String },
+    Binding { mismatches: Vec<String>, details: serde_json::Value },
+    /// executable zero-token comms contract suite evidence.
+    ContractSuite { checks: Vec<ContractSuiteCheck> },
+}
+
+/// One executable zero-token comms contract-suite subcheck.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ContractSuiteCheck {
+    pub name: String,
+    pub status: CheckStatus,
+    pub reason: Option<String>,
 }
 
 /// **机械门** (§84/MUST-NOT-13;`diagnose/comms.py:142`):selftest 路径 provider SDK 调用

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

@@ -0,0 +1,119 @@
+use std::cell::RefCell;
+use std::fs::OpenOptions;
+use std::io::{self, Read};
+use std::process::{Command, ExitStatus, Stdio};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+const DEFAULT_TIMEOUT: Duration = Duration::from_millis(900);
+
+thread_local! {
+    static PROBE_TIMEOUT: RefCell<Option<ProbeTimeout>> = const { RefCell::new(None) };
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct ProbeTimeout {
+    pub(crate) probe: &'static str,
+    pub(crate) pid: Option<u32>,
+    pub(crate) timeout_ms: u64,
+}
+
+#[derive(Debug)]
+pub(crate) struct BoundedCommandOutput {
+    pub(crate) status: ExitStatus,
+    pub(crate) stdout: Vec<u8>,
+}
+
+pub(crate) fn clear_probe_timeout() {
+    PROBE_TIMEOUT.with(|timeout| *timeout.borrow_mut() = None);
+}
+
+pub(crate) fn probe_timed_out() -> bool {
+    PROBE_TIMEOUT.with(|timeout| timeout.borrow().is_some())
+}
+
+pub(crate) fn probe_timeout() -> Option<ProbeTimeout> {
+    PROBE_TIMEOUT.with(|timeout| timeout.borrow().clone())
+}
+
+pub(crate) fn bounded_command_output_with_probe(
+    command: &mut Command,
+    probe: &'static str,
+    pid: Option<u32>,
+) -> io::Result<BoundedCommandOutput> {
+    bounded_command_output_with_timeout(command, DEFAULT_TIMEOUT, probe, pid)
+}
+
+fn bounded_command_output_with_timeout(
+    command: &mut Command,
+    timeout: Duration,
+    probe: &'static str,
+    pid: Option<u32>,
+) -> io::Result<BoundedCommandOutput> {
+    let stdout_path = temp_output_path("stdout");
+    let stdout_file = OpenOptions::new()
+        .create_new(true)
+        .read(true)
+        .write(true)
+        .open(&stdout_path)?;
+    let child = command
+        .stdout(Stdio::from(stdout_file.try_clone()?))
+        .stderr(Stdio::null())
+        .spawn()?;
+    wait_for_bounded_child(child, stdout_file, stdout_path, timeout, probe, pid)
+}
+
+fn wait_for_bounded_child(
+    mut child: std::process::Child,
+    stdout_file: std::fs::File,
+    stdout_path: std::path::PathBuf,
+    timeout: Duration,
+    probe: &'static str,
+    pid: Option<u32>,
+) -> io::Result<BoundedCommandOutput> {
+    let start = Instant::now();
+    loop {
+        if let Some(status) = child.try_wait()? {
+            drop(stdout_file);
+            let stdout = read_and_remove(&stdout_path);
+            return Ok(BoundedCommandOutput { status, stdout });
+        }
+        if start.elapsed() >= timeout {
+            PROBE_TIMEOUT.with(|current| {
+                let mut current = current.borrow_mut();
+                if current.is_none() {
+                    *current = Some(ProbeTimeout {
+                        probe,
+                        pid,
+                        timeout_ms: timeout.as_millis() as u64,
+                    });
+                }
+            });
+            let _ = child.kill();
+            let status = child.wait()?;
+            drop(stdout_file);
+            let stdout = read_and_remove(&stdout_path);
+            return Ok(BoundedCommandOutput { status, stdout });
+        }
+        std::thread::sleep(Duration::from_millis(10));
+    }
+}
+
+fn temp_output_path(kind: &str) -> std::path::PathBuf {
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_nanos())
+        .unwrap_or(0);
+    std::env::temp_dir().join(format!(
+        "team-agent-os-probe-{}-{nanos}.{kind}",
+        std::process::id()
+    ))
+}
+
+fn read_and_remove(path: &std::path::Path) -> Vec<u8> {
+    let mut stdout = Vec::new();
+    if let Ok(mut file) = std::fs::File::open(path) {
+        let _ = file.read_to_end(&mut stdout);
+    }
+    let _ = std::fs::remove_file(path);
+    stdout
+}

package/crates/team-agent/src/packaging/migrate.rs

@@ -13,8 +13,16 @@ pub fn doctor(opts: &DoctorOptions) -> Result<DoctorStatus, PackagingError> {
     if opts.fix && opts.gate.is_none() {
         return Err(PackagingError::InvalidOptions("--fix requires --gate".to_string()));
     }
-    if opts.fix && matches!(opts.gate, Some(DoctorGate::Orphans | DoctorGate::Comms)) {
-        return Ok(DoctorStatus::Ok);
+    let gate_blockers = crate::diagnose::doctor_gate_blockers(
+        &opts.workspace,
+        opts.gate,
+        opts.fix,
+        opts.confirm,
+    )?;
+    if !gate_blockers.is_empty() {
+        return Ok(DoctorStatus::HasBlockers {
+            blockers: gate_blockers,
+        });
     }
     let diagnosis = schema_diagnosis_workspace(&opts.workspace)?;
     if diagnosis.layout_diffs.is_empty() {

package/crates/team-agent/src/packaging/tests.rs

@@ -269,6 +269,29 @@ fn doctor_on_clean_workspace_no_drift_is_ok() {
     assert_eq!(status, DoctorStatus::Ok);
 }
 
+#[test]
+fn doctor_comms_gate_failure_maps_to_typed_blocker() {
+    let dir = std::env::temp_dir().join(format!("ta-doctor-comms-{}", std::process::id()));
+    let _ = std::fs::create_dir_all(&dir);
+    let mut opts = doctor_opts(&dir);
+    opts.gate = Some(DoctorGate::Comms);
+    let status = doctor(&opts).expect("comms gate should return typed blockers");
+    match status {
+        DoctorStatus::HasBlockers { blockers } => {
+            let blocker = blockers
+                .iter()
+                .find(|blocker| blocker.source == BlockerSource::CommsGate)
+                .expect("must surface CommsGate blocker");
+            assert!(
+                blocker.detail.contains("receiver_binding"),
+                "blocker detail must name failing check: {}",
+                blocker.detail
+            );
+        }
+        DoctorStatus::Ok => panic!("missing receiver binding must not report Ok"),
+    }
+}
+
 #[test]
 fn doctor_drifted_db_emits_schema_layout_drift_blocker() {
     // STRENGTHENED (gate w59ds828k): the ONLY drift assertion previously