@team-agent/installer 0.2.10 → 0.3.0

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

@@ -0,0 +1,357 @@
+use super::*;
+
+
+// ════════════════════════════════════════════════════════════════════════
+// GROUP A — serde byte-locks (audit/event wire values; changing one byte
+// breaks downstream recognizers/event consumers). delivery.py / send.py /
+// leader.py / scheduler.py / diagnose/comms.py.
+// ════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn delivery_status_serde_snake_case_byte_locked() {
+    let cases = [
+        (DeliveryStatus::Delivered, "\"delivered\""),
+        (DeliveryStatus::Failed, "\"failed\""),
+        (DeliveryStatus::Queued, "\"queued\""),
+        (DeliveryStatus::Blocked, "\"blocked\""),
+        (DeliveryStatus::Refused, "\"refused\""),
+        (DeliveryStatus::RetryScheduled, "\"retry_scheduled\""),
+        (
+            DeliveryStatus::TrustAutoAnswerExhausted,
+            "\"trust_auto_answer_exhausted\"",
+        ),
+        (DeliveryStatus::AlreadyDelivered, "\"already_delivered\""),
+        (DeliveryStatus::FallbackLog, "\"fallback_log\""),
+        (DeliveryStatus::BroadcastDelivered, "\"broadcast_delivered\""),
+        (DeliveryStatus::BroadcastPartial, "\"broadcast_partial\""),
+        (DeliveryStatus::FanoutDelivered, "\"fanout_delivered\""),
+        (DeliveryStatus::FanoutPartial, "\"fanout_partial\""),
+    ];
+    for (variant, wire) in cases {
+        assert_eq!(serde_json::to_string(&variant).unwrap(), wire);
+    }
+}
+
+#[test]
+fn delivery_refusal_serde_snake_case_byte_locked() {
+    let cases = [
+        (DeliveryRefusal::TargetNotInTeam, "\"target_not_in_team\""),
+        (
+            DeliveryRefusal::HumanConfirmationRequired,
+            "\"human_confirmation_required\"",
+        ),
+        (DeliveryRefusal::MissingPermissions, "\"missing_permissions\""),
+        (DeliveryRefusal::RecipientBusy, "\"recipient_busy\""),
+        (DeliveryRefusal::UnknownRecipient, "\"unknown_recipient\""),
+        (DeliveryRefusal::TmuxTargetMissing, "\"tmux_target_missing\""),
+        (
+            DeliveryRefusal::MessageAlreadyClaimed,
+            "\"message_already_claimed\"",
+        ),
+        (DeliveryRefusal::LeaderNotAttached, "\"leader_not_attached\""),
+        (DeliveryRefusal::TeamOwnerMismatch, "\"team_owner_mismatch\""),
+        (DeliveryRefusal::Ambiguous, "\"ambiguous\""),
+        (
+            DeliveryRefusal::RecipientPaneInNonInputMode,
+            "\"recipient_pane_in_non_input_mode\"",
+        ),
+        (DeliveryRefusal::SessionDrift, "\"session_drift\""),
+    ];
+    for (variant, wire) in cases {
+        assert_eq!(serde_json::to_string(&variant).unwrap(), wire);
+    }
+}
+
+#[test]
+fn delivery_stage_serde_snake_case_byte_locked() {
+    // delivery.py:309 injection.stage values.
+    assert_eq!(
+        serde_json::to_string(&DeliveryStage::TrustAutoAnswerDismissalWait).unwrap(),
+        "\"trust_auto_answer_dismissal_wait\""
+    );
+    assert_eq!(
+        serde_json::to_string(&DeliveryStage::Inject).unwrap(),
+        "\"inject\""
+    );
+    assert_eq!(
+        serde_json::to_string(&DeliveryStage::Submit).unwrap(),
+        "\"submit\""
+    );
+    assert_eq!(
+        serde_json::to_string(&DeliveryStage::VisibleCheck).unwrap(),
+        "\"visible_check\""
+    );
+}
+
+#[test]
+fn scheduled_kind_serde_byte_locked() {
+    // scheduler.py:46,84,87 dispatch keys — exhaustive, no runtime fallback.
+    assert_eq!(
+        serde_json::to_string(&ScheduledKind::Send).unwrap(),
+        "\"send\""
+    );
+    assert_eq!(
+        serde_json::to_string(&ScheduledKind::HealthPing).unwrap(),
+        "\"health_ping\""
+    );
+    assert_eq!(
+        serde_json::to_string(&ScheduledKind::TrustRetry).unwrap(),
+        "\"trust_retry\""
+    );
+}
+
+#[test]
+fn activity_status_serde_byte_locked() {
+    // activity_detector.py:107 status values consumed by ping/take-over.
+    assert_eq!(
+        serde_json::to_string(&ActivityStatus::Working).unwrap(),
+        "\"working\""
+    );
+    assert_eq!(
+        serde_json::to_string(&ActivityStatus::Idle).unwrap(),
+        "\"idle\""
+    );
+    assert_eq!(
+        serde_json::to_string(&ActivityStatus::Stuck).unwrap(),
+        "\"stuck\""
+    );
+    assert_eq!(
+        serde_json::to_string(&ActivityStatus::Uncertain).unwrap(),
+        "\"uncertain\""
+    );
+}
+
+#[test]
+fn alert_type_serde_byte_locked() {
+    // scheduler.py:38 _ALERT_TYPES set members.
+    assert_eq!(
+        serde_json::to_string(&AlertType::Stuck).unwrap(),
+        "\"stuck\""
+    );
+    assert_eq!(
+        serde_json::to_string(&AlertType::IdleFallback).unwrap(),
+        "\"idle_fallback\""
+    );
+    assert_eq!(
+        serde_json::to_string(&AlertType::CrossWorkerDeadlock).unwrap(),
+        "\"cross_worker_deadlock\""
+    );
+}
+
+#[test]
+fn check_status_serde_byte_locked() {
+    assert_eq!(
+        serde_json::to_string(&CheckStatus::Pass).unwrap(),
+        "\"pass\""
+    );
+    assert_eq!(
+        serde_json::to_string(&CheckStatus::Fail).unwrap(),
+        "\"fail\""
+    );
+    assert_eq!(
+        serde_json::to_string(&CheckStatus::Deferred).unwrap(),
+        "\"deferred\""
+    );
+    assert_eq!(
+        serde_json::to_string(&CheckStatus::NotImplemented).unwrap(),
+        "\"not_implemented\""
+    );
+    assert_eq!(
+        serde_json::to_string(&CheckStatus::NotChallenged).unwrap(),
+        "\"not_challenged\""
+    );
+}
+
+#[test]
+fn check_kind_serde_byte_locked() {
+    // diagnose/comms.py:121,149 verifies values.
+    assert_eq!(
+        serde_json::to_string(&CheckKind::ReceiverBinding).unwrap(),
+        "\"receiver_binding\""
+    );
+    assert_eq!(
+        serde_json::to_string(&CheckKind::ContractSuite).unwrap(),
+        "\"contract_suite\""
+    );
+    assert_eq!(
+        serde_json::to_string(&CheckKind::NoProviderSdkCalls).unwrap(),
+        "\"no_provider_sdk_calls\""
+    );
+}
+
+#[test]
+fn receiver_mode_serde_byte_locked() {
+    // leader.py:103,166 — only direct_tmux is a legal receiver mode.
+    assert_eq!(
+        serde_json::to_string(&ReceiverMode::DirectTmux).unwrap(),
+        "\"direct_tmux\""
+    );
+}
+
+// ════════════════════════════════════════════════════════════════════════
+// GROUP B — bounded-retry constants + backoff (delivery.py:60-61,
+// scheduler.py:134 / results.py:251, result_delivery.py:15). Locks the
+// termination-guarantee so no infinite-loop regression.
+// ════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn trust_retry_max_attempts_is_four() {
+    assert_eq!(TRUST_RETRY_MAX_ATTEMPTS, 4);
+}
+
+#[test]
+fn trust_retry_backoff_table_byte_locked() {
+    // delivery.py:60 _TRUST_RETRY_BACKOFF_SECONDS = {2:5, 3:15, 4:30}.
+    assert_eq!(TRUST_RETRY_BACKOFF_SECONDS, &[(2, 5), (3, 15), (4, 30)]);
+}
+
+#[test]
+fn send_retry_max_attempts_is_three() {
+    // scheduler.py:134 / results.py:251 max_attempts = 3.
+    assert_eq!(SEND_RETRY_MAX_ATTEMPTS, 3);
+}
+
+#[test]
+fn result_delivery_max_attempts_is_five() {
+    // result_delivery.py:15 _RESULT_DELIVERY_MAX_ATTEMPTS = 5.
+    assert_eq!(RESULT_DELIVERY_MAX_ATTEMPTS, 5);
+}
+
+// ════════════════════════════════════════════════════════════════════════
+// GROUP C — pure-value helper impls already in the skeleton: the IRON LAW.
+// ProviderSdkCalls::is_zero is implemented (GREEN check); the gate fns are
+// unimplemented!() so they are RED until ported.
+// ════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn provider_sdk_calls_is_zero_only_when_all_three_zero() {
+    // diagnose/comms.py:148 `any(calls.values())` negated.
+    assert!(ProviderSdkCalls::default().is_zero());
+    assert!(ProviderSdkCalls {
+        anthropic: 0,
+        openai: 0,
+        httpx: 0
+    }
+    .is_zero());
+    assert!(!ProviderSdkCalls {
+        anthropic: 1,
+        openai: 0,
+        httpx: 0
+    }
+    .is_zero());
+    assert!(!ProviderSdkCalls {
+        anthropic: 0,
+        openai: 0,
+        httpx: 9
+    }
+    .is_zero());
+}
+
+#[test]
+fn alert_type_all_is_sorted_full_set() {
+    // scheduler.py:269 sorted(_ALERT_TYPES) =
+    //   ['cross_worker_deadlock','idle_fallback','stuck'].
+    assert_eq!(
+        AlertType::all(),
+        [
+            AlertType::CrossWorkerDeadlock,
+            AlertType::IdleFallback,
+            AlertType::Stuck
+        ]
+    );
+}
+
+#[test]
+fn activity_status_idle_takeover_gate_uncertain_never_idle() {
+    // THE IRON LAW (bug-071/077/085): only Idle passes; Uncertain/Working/Stuck
+    // are explicitly blocked — Uncertain must NOT fall through to idle.
+    assert!(ActivityStatus::Idle.allows_idle_takeover());
+    assert!(!ActivityStatus::Uncertain.allows_idle_takeover());
+    assert!(!ActivityStatus::Working.allows_idle_takeover());
+    assert!(!ActivityStatus::Stuck.allows_idle_takeover());
+}
+
+// ════════════════════════════════════════════════════════════════════════
+// GROUP D — result_delivery.py pure fns: format/parse dual + KEY INSERTION
+// ORDER + None-vs-empty + watcher matching. Byte-level golden (probed).
+// ════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn format_result_watcher_notification_full_shape_byte_locked() {
+    // result_delivery.py:521 — with tests + result_id. INSERTION ORDER matters:
+    // result_id inserted at idx 1 first, THEN tests inserted at idx 1 → Tests line
+    // ends up ABOVE the Result id line. Tests capped at 3.
+    let result = json(serde_json::json!({
+        "task_id": "t1", "agent_id": "alice", "status": "success", "summary": "done",
+        "result_id": "res-99",
+        "tests": [
+            {"command": "pytest", "status": "passed"},
+            {"command": "lint", "status": "failed"},
+            {"command": "a", "status": "x"},
+            {"command": "extra", "status": "skip"}
+        ]
+    }));
+    assert_eq!(
+        format_result_watcher_notification(&result),
+        "Task t1 reported success from alice: done\n\
+         Tests: pytest=passed; lint=failed; a=x\n\
+         Result id: res-99\n\
+         Team Agent has collected this result and updated team_state.md. No manual polling is needed."
+    );
+}
+
+#[test]
+fn format_result_watcher_notification_minimal_uses_defaults() {
+    // Empty result → unknown-task / unknown / unknown agent / completed defaults,
+    // NO Tests line, NO Result id line.
+    assert_eq!(
+        format_result_watcher_notification(&json(serde_json::json!({}))),
+        "Task unknown task reported unknown from unknown agent: completed\n\
+         Team Agent has collected this result and updated team_state.md. No manual polling is needed."
+    );
+}
+
+#[test]
+fn format_result_watcher_notification_result_id_only_no_tests() {
+    let result = json(serde_json::json!({
+        "task_id": "t1", "agent_id": "bob", "status": "blocked", "summary": "s",
+        "result_id": "R1"
+    }));
+    assert_eq!(
+        format_result_watcher_notification(&result),
+        "Task t1 reported blocked from bob: s\n\
+         Result id: R1\n\
+         Team Agent has collected this result and updated team_state.md. No manual polling is needed."
+    );
+}
+
+#[test]
+fn result_id_from_text_roundtrips_with_formatter() {
+    // result_delivery.py:415 — dual of the formatter (content-level dedupe key).
+    let result = json(serde_json::json!({
+        "task_id": "t1", "agent_id": "alice", "status": "success",
+        "summary": "done", "result_id": "res-99"
+    }));
+    let rendered = format_result_watcher_notification(&result);
+    assert_eq!(result_id_from_text(&rendered), Some("res-99".to_string()));
+}
+
+#[test]
+fn result_id_from_text_none_when_absent() {
+    assert_eq!(result_id_from_text("no id here\nplain"), None);
+}
+
+#[test]
+fn result_id_from_text_empty_value_is_none_not_empty_string() {
+    // "Result id: " with empty payload → None (the `or None` after strip).
+    assert_eq!(result_id_from_text("Result id: \nx"), None);
+}
+
+#[test]
+fn result_id_from_text_strips_trailing_whitespace() {
+    assert_eq!(
+        result_id_from_text("Result id: abc  \n"),
+        Some("abc".to_string())
+    );
+}
+

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

@@ -0,0 +1,122 @@
+use super::*;
+
+// ── F1 [P1 byte-shape] — stuck_cancel suppression snapshot.delivered_message_ids must use golden's
+// _DELIVERED_MESSAGE_STATUSES = {visible, submitted, delivered, acknowledged} (scheduler.py:27,376-383),
+// sorted. The Rust delivered_message_ids (scheduler.rs:243) used {injected, visible, submitted,
+// submitted_unverified, delivered} — the WRONG set (reviewer's explicit warning: don't copy the
+// activity.rs deadlock query set): it EXCLUDES 'acknowledged' and INCLUDES 'injected'/'submitted_unverified'.
+// (The snapshot also must carry BOTH assigned_task_ids AND delivered_message_ids — that structural half
+// is already present; this pins the STATUS SET.)
+#[test]
+fn stuck_cancel_snapshot_delivered_message_ids_uses_golden_status_set() {
+    let ws = tmp_ws("f1_delivered");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({
+            "active_team_key": "teamX",
+            "agents": {"w1": {"status": "running", "provider": "codex"}}
+        }),
+    )
+    .unwrap();
+    let store = crate::message_store::MessageStore::open(&ws).unwrap();
+    // golden-delivered (must be IN delivered_message_ids): acknowledged + visible.
+    let m_ack = store.create_message(None, "leader", "w1", "ack-me", None, true, Some("teamX")).unwrap();
+    store.mark(&m_ack, "acknowledged", None).unwrap();
+    let m_vis = store.create_message(None, "leader", "w1", "vis", None, true, Some("teamX")).unwrap();
+    store.mark(&m_vis, "visible", None).unwrap();
+    // NOT golden-delivered (must be EXCLUDED): injected.
+    let m_inj = store.create_message(None, "leader", "w1", "inj", None, true, Some("teamX")).unwrap();
+    store.mark(&m_inj, "injected", None).unwrap();
+    drop(store);
+    let _ = stuck_cancel(&ws, "w1", None, "leader").unwrap();
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let snapshot = &state["coordinator"]["suppressed_idle_alerts"]["teamX"]["w1"]["stuck"]["snapshot"];
+    assert!(snapshot.get("assigned_task_ids").is_some(), "F1: snapshot must carry assigned_task_ids; got {snapshot}");
+    let delivered = snapshot
+        .get("delivered_message_ids")
+        .and_then(serde_json::Value::as_array)
+        .map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_string)).collect::<Vec<_>>())
+        .unwrap_or_else(|| panic!("F1: snapshot must carry delivered_message_ids; got {snapshot}"));
+    assert!(
+        delivered.contains(&m_ack),
+        "F1: golden _DELIVERED_MESSAGE_STATUSES includes 'acknowledged' — the acknowledged message must be \
+         in delivered_message_ids; the Rust set omits it. got {delivered:?}"
+    );
+    assert!(delivered.contains(&m_vis), "F1: 'visible' is delivered (golden); got {delivered:?}");
+    assert!(
+        !delivered.contains(&m_inj),
+        "F1: 'injected' is NOT in golden _DELIVERED_MESSAGE_STATUSES — it must be EXCLUDED; the Rust set \
+         wrongly includes it. got {delivered:?}"
+    );
+    let mut sorted = delivered.clone();
+    sorted.sort();
+    assert_eq!(delivered, sorted, "F1: delivered_message_ids must be sorted (golden sorts); got {delivered:?}");
+}
+// ── collect --result-file INGEST SEMANTIC (golden results.py:58-73) ──────────────────────────────
+// Golden `collect(result_file=…)` INDEPENDENTLY INGESTS a standalone result: a valid result_envelope_v1
+// is `store.add_result(envelope)`'d (results.py:73) regardless of any in-flight delivery, then the
+// collection loop collects it when its task_id is a known task (state.tasks) OR message-scoped (msg_+
+// matching message). NO live in-flight task is required at ingest time. rt-host-b @ c262bf7 saw a
+// VALID envelope (validate-result accepts the same) collect to exit-1 / empty output / NOT in the
+// results table — i.e. the --result-file ingest path was a no-op (results.rs once did
+// `let _ = (result_file, …)`). This pins the happy path: a valid envelope for a KNOWN task must be
+// ingested into the results table AND collected, with ok=true. (Completes the previously-deferred
+// collected_results golden — the fixture is built from the real compiler + state persistence.)
+#[test]
+fn collect_result_file_ingests_valid_known_task_envelope_into_results() {
+    let team = tmp_ws("collect_rf");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(
+        team.join("TEAM.md"),
+        "---\nname: ct\nobjective: collect --result-file probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(
+        team.join("agents").join("w1.md"),
+        "---\nname: w1\nrole: Worker\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nW1.\n",
+    )
+    .unwrap();
+    let spec = crate::compiler::compile_team(&team).expect("compile collect team");
+    std::fs::write(team.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    // seed runtime state with a KNOWN task "task-1" so the collection loop accepts the ingested result.
+    crate::state::persist::save_runtime_state(
+        &team,
+        &serde_json::json!({
+            "spec_path": team.join("team.spec.yaml").to_string_lossy(),
+            "agents": {"w1": {"status": "running", "provider": "codex"}},
+            "tasks": [{"id": "task-1", "title": "t", "type": "impl", "assignee": "w1",
+                       "deps": [], "acceptance": "x", "status": "pending"}]
+        }),
+    )
+    .unwrap();
+    // a schema-valid result_envelope_v1 (validate_result_envelope accepts it) for task-1.
+    let envelope = serde_json::json!({
+        "schema_version": "result_envelope_v1", "task_id": "task-1", "agent_id": "w1",
+        "status": "success", "summary": "done",
+        "changes": [], "tests": [], "risks": [], "artifacts": [], "next_actions": []
+    });
+    let rf = team.join("result.json");
+    std::fs::write(&rf, serde_json::to_string(&envelope).unwrap()).unwrap();
+    let out = collect(&team, Some(rf.as_path()), false)
+        .expect("collect with a valid --result-file must not error");
+    // golden: a valid standalone envelope is ingested + collected, ok=true (NOT a silent exit-1).
+    assert_eq!(out["ok"], serde_json::json!(true), "valid --result-file collect must be ok:true; got {out}");
+    let collected = out["collected_results"].as_array().expect("collected_results array");
+    assert_eq!(
+        collected.len(),
+        1,
+        "golden: the --result-file envelope must be INGESTED (store.add_result) then collected; a no-op \
+         ingest leaves collected_results=[]. got {out}"
+    );
+    assert_eq!(collected[0]["task_id"], serde_json::json!("task-1"));
+    assert_eq!(collected[0]["agent_id"], serde_json::json!("w1"));
+    assert_eq!(collected[0]["status"], serde_json::json!("success"));
+    // the result is actually IN the results table (counts reflect it) — proves real ingestion.
+    assert_eq!(
+        out["results"]["total"], serde_json::json!(1),
+        "the ingested result must persist in the results table (counts.total=1); a no-op ingest yields 0. got {}",
+        out["results"]
+    );
+    assert_eq!(out["results"]["collected"], serde_json::json!(1), "the ingested result must be marked collected; got {}", out["results"]);
+    let _ = std::fs::remove_dir_all(&team);
+}