@team-agent/installer 0.5.110 → 0.5.112

package/crates/team-agent/src/cli/tests/verb_validate.rs

@@ -1,195 +0,0 @@
-use super::*;
-
-const VALIDATE_SPEC_TEMPLATE: &str = r#"version: 1
-team:
-  name: "fake-e2e"
-  mode: "supervisor_worker"
-  objective: "Exercise validate."
-  workspace: "__WS__"
-leader:
-  id: "leader"
-  role: "leader"
-  provider: "fake"
-  model: null
-  tools:
-    - "fs_read"
-    - "fs_list"
-    - "mcp_team"
-  context_policy:
-    keep_user_thread: true
-    receive_worker_outputs: "structured_only"
-    max_worker_result_tokens: 2000
-agents:
-  - id: "fake_impl"
-    role: "implementation_engineer"
-    provider: "fake"
-    model: null
-    working_directory: "__WS__"
-    system_prompt:
-      inline: "Handle fake implementation tasks."
-      file: null
-    tools:
-      - "fs_read"
-      - "fs_write"
-      - "fs_list"
-      - "execute_bash"
-      - "git_diff"
-      - "mcp_team"
-      - "provider_builtin"
-    dangerously_skip_permissions: false
-    preferred_for:
-      - "implementation"
-    avoid_for: []
-    output_contract:
-      format: "result_envelope_v1"
-      required_fields:
-        - "task_id"
-        - "status"
-        - "summary"
-        - "artifacts"
-routing:
-  default_assignee: "leader"
-  rules:
-    - id: "implementation-to-fake"
-      match:
-        type:
-          - "implementation"
-      assign_to: "fake_impl"
-      priority: 10
-communication:
-  protocol: "mcp_inbox"
-  topology: "leader_centered"
-  worker_to_worker: true
-  ack_timeout_sec: 2
-  result_format: "result_envelope_v1"
-  message_store:
-    sqlite: ".team/runtime/team.db"
-    mirror_files: ".team/messages"
-runtime:
-  backend: "tmux"
-  session_name: "team-agent-fake-e2e"
-  auto_launch: true
-  require_user_approval_before_launch: false
-  max_active_agents: 1
-  startup_order:
-    - "fake_impl"
-context:
-  state_file: "team_state.md"
-  artifact_dir: ".team/artifacts"
-  log_dir: ".team/logs"
-  summarization:
-    worker_full_logs: "retain_outside_leader_context"
-    state_update: "after_each_result"
-tasks:
-  - id: "task_impl"
-    title: "Fake implementation"
-    type: "implementation"
-    assignee: null
-    deps: []
-    acceptance:
-      - "fake result collected"
-    status: "pending"
-"#;
-
-fn write_validate_spec(
-    ws: &std::path::Path,
-    file_name: &str,
-    provider: &str,
-) -> std::path::PathBuf {
-    let spec = VALIDATE_SPEC_TEMPLATE
-        .replace("__WS__", &ws.to_string_lossy())
-        .replacen(
-            "provider: \"fake\"",
-            &format!("provider: \"{provider}\""),
-            1,
-        );
-    let path = ws.join(file_name);
-    std::fs::write(&path, spec).unwrap();
-    path
-}
-
-// Golden source:
-// - cli/parser.py:120-123 registers `validate [spec=team.spec.yaml] --json`.
-// - cli/commands.py:38-39 delegates to `runtime.validate_file(Path(args.spec).resolve())`.
-// - launch/bootstrap.py:30-43: file specs return `{ok: True, workspace: str(workspace), team: name}`.
-// - cli/helpers.py:12-16 JSON emits `json.dumps(..., indent=2, ensure_ascii=False, sort_keys=True)`.
-//
-// Golden probe:
-//   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src python3 /tmp/probe_validate_cli.py
-//   valid file --json rc=0 stdout:
-//   {
-//     "ok": true,
-//     "team": "fake-e2e",
-//     "workspace": "<ws>"
-//   }
-#[test]
-fn validate_valid_spec_file_json_byte_shape() {
-    let ws = tmp_workspace();
-    let spec_path = write_validate_spec(&ws, "team.spec.yaml", "fake");
-
-    let result = cmd_validate(&ValidateArgs {
-        spec: spec_path.clone(),
-        json: true,
-    })
-    .expect("valid spec must return an ok CmdResult");
-
-    assert_eq!(result.exit, ExitCode::Ok);
-    assert_eq!(
-        emit(&result.output, true).unwrap(),
-        format!(
-            "{{\n  \"ok\": true,\n  \"team\": \"fake-e2e\",\n  \"workspace\": \"{}\"\n}}",
-            ws.to_string_lossy()
-        ),
-        "validate --json must match Python sort_keys+indent bytes for a valid file spec",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// Golden source:
-// - spec.py:85-91 accumulates validation messages and raises
-//   `team.spec.yaml validation failed:\n- ...`.
-// - spec.py semantic provider check emits `/leader/provider: unknown provider 'bogus'`.
-// - cli/helpers.py:137-155 error payload insertion order is `ok,error,action,log`.
-// - cli/helpers.py:128-131 prints compact JSON, not pretty/sorted JSON, for `--json` errors.
-#[test]
-fn validate_invalid_spec_json_error_envelope_byte_shape() {
-    let ws = tmp_workspace();
-    let spec_path = write_validate_spec(&ws, "bad.spec.yaml", "bogus");
-
-    let err = cmd_validate(&ValidateArgs {
-        spec: spec_path,
-        json: true,
-    })
-    .expect_err("invalid spec must surface a CLI/runtime validation error");
-
-    assert_eq!(
-        err.to_string(),
-        "team.spec.yaml validation failed:\n- /leader/provider: unknown provider 'bogus'",
-    );
-    let payload = err.to_payload(&ws.join(".team/logs/cli-error-123.log"), "validate");
-    assert_eq!(
-        serde_json::to_string(&payload).unwrap(),
-        format!(
-            "{{\"ok\":false,\"error\":\"team.spec.yaml validation failed:\\n- /leader/provider: unknown provider 'bogus'\",\"action\":\"run `team-agent doctor` or inspect the log path shown here\",\"log\":\"{}\"}}",
-            ws.join(".team/logs/cli-error-123.log").to_string_lossy()
-        ),
-        "validate --json errors must match Python compact error envelope key order and text",
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// Golden source:
-// - cli/parser.py:120-123 default spec argument is `team.spec.yaml`.
-// Current Rust dispatch has no `validate` arm; this must be RED until the porter routes it.
-#[test]
-fn dispatch_routes_validate_default_spec() {
-    let ws = tmp_workspace();
-    let _spec_path = write_validate_spec(&ws, "team.spec.yaml", "fake");
-    let code = run(&["validate".to_string(), "--json".to_string()], &ws);
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "`validate --json` must route and exit 0 for default team.spec.yaml"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}

package/crates/team-agent/src/coordinator/tests/watch.rs

@@ -1,223 +0,0 @@
-use super::*;
-
-// ═════════════════════════════════════════════════════════════════════════
-// GROUP G — watch render_event_line (watch.py:46) — golden text — RED
-//   exact strings captured via PYTHONPATH probe against v0.2.11.
-// ═════════════════════════════════════════════════════════════════════════
-
-#[test]
-fn render_result_received_collapses_whitespace_and_defaults() {
-    // watch.py:48-49 + _result_line — "result_received: <agent|-> -> <clean summary>".
-    let e = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": "did   the\nthing"});
-    assert_eq!(
-        render_event_line(&e),
-        Some("result_received: w1 -> did the thing".to_string())
-    );
-    // missing agent + summary → both '-'.
-    let bare = serde_json::json!({"event": "result_received"});
-    assert_eq!(
-        render_event_line(&bare),
-        Some("result_received: - -> -".to_string())
-    );
-}
-
-#[test]
-fn render_injected_and_submitted_share_prefix_and_truncate_message_id() {
-    // watch.py:50-51 — both render as "leader_receiver.injected"; message_id truncated to 12.
-    let inj = serde_json::json!({"event": "leader_receiver.injected", "message_id": "abcdef0123456789", "recipient": "w2"});
-    assert_eq!(
-        render_event_line(&inj),
-        Some("leader_receiver.injected: abcdef012345 -> w2".to_string())
-    );
-    // submitted uses same label, msg_id fallback, `to` recipient fallback.
-    let sub = serde_json::json!({"event": "leader_receiver.submitted", "msg_id": "xy", "to": "w3"});
-    assert_eq!(
-        render_event_line(&sub),
-        Some("leader_receiver.injected: xy -> w3".to_string())
-    );
-}
-
-#[test]
-fn render_send_failed_uses_reason_then_error_fallback() {
-    // watch.py:52-53 — reason || error || '-', recipient || to || target || '-', whitespace-cleaned.
-    let with_reason =
-        serde_json::json!({"event": "send.failed", "recipient": "w4", "reason": "  pane   gone  "});
-    assert_eq!(
-        render_event_line(&with_reason),
-        Some("send.failed: w4 reason=pane gone".to_string())
-    );
-    let with_error = serde_json::json!({"event": "send.failed", "target": "w5", "error": "boom"});
-    assert_eq!(
-        render_event_line(&with_error),
-        Some("send.failed: w5 reason=boom".to_string())
-    );
-}
-
-#[test]
-fn render_rebind_required_uses_pane_and_reason_fallbacks() {
-    // watch.py:54-57 — old_pane_id || pane_id || target || '-'; reason || rediscovery_status || '-'.
-    let e = serde_json::json!({"event": "leader_receiver.rebind_required", "old_pane_id": "%9", "reason": "lost"});
-    assert_eq!(
-        render_event_line(&e),
-        Some("leader_receiver.rebind_required: pane=%9 reason=lost".to_string())
-    );
-    let no_reason =
-        serde_json::json!({"event": "leader_receiver.rebind_required", "pane_id": "%7"});
-    assert_eq!(
-        render_event_line(&no_reason),
-        Some("leader_receiver.rebind_required: pane=%7 reason=-".to_string())
-    );
-}
-
-#[test]
-fn render_api_error_defaults_unknown_class_and_dash() {
-    // watch.py:58-62 — error_class || "Unknown"; provider || '-'; snippet || '-' cleaned.
-    let error_class = ["Over", "loaded"].concat();
-    let code = (500 + 29).to_string();
-    let e = serde_json::json!({"event": "leader.api_error", "error_class": error_class, "provider": "claude_code", "matched_pattern_snippet": format!("{code}  too  many")});
-    assert_eq!(
-        render_event_line(&e),
-        Some(format!(
-            "leader.api_error: {} provider=claude_code snippet={} too many",
-            ["Over", "loaded"].concat(),
-            code
-        ))
-    );
-    let bare = serde_json::json!({"event": "leader.api_error"});
-    assert_eq!(
-        render_event_line(&bare),
-        Some("leader.api_error: Unknown provider=- snippet=-".to_string())
-    );
-}
-
-#[test]
-fn render_non_renderable_events_return_none() {
-    // watch.py:63 — coordinator.* / unknown events → None.
-    assert_eq!(
-        render_event_line(&serde_json::json!({"event": "coordinator.boot"})),
-        None
-    );
-    assert_eq!(
-        render_event_line(&serde_json::json!({"event": "unknown.thing"})),
-        None
-    );
-}
-
-// ═════════════════════════════════════════════════════════════════════════
-// GROUP H — WatchCursor rotation invariants (watch.py:66-97) — RED via collect_watch_lines
-// ═════════════════════════════════════════════════════════════════════════
-
-#[test]
-fn watch_cursor_default_is_uninitialized() {
-    let c = WatchCursor::default();
-    assert_eq!(c.event_offset, 0);
-    assert!(!c.initialized);
-    assert!(c.archive_signature.is_none());
-    assert!(c.seen_result_ids.is_empty());
-}
-
-/// seed a workspace with an `events.jsonl` (+ optional archived `events.jsonl.1`).
-/// Returns the resolved `WorkspacePath`. The events file holds one renderable
-/// `result_received` line so `collect_watch_lines` has observable non-marker output.
-fn seed_watch_workspace(event_summary: &str, archive_bytes: Option<&[u8]>) -> WorkspacePath {
-    let dir = std::env::temp_dir().join(format!(
-        "team-agent-watch-rotate-{}-{}",
-        std::process::id(),
-        std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos()
-    ));
-    let logs = crate::model::paths::logs_dir(&dir);
-    std::fs::create_dir_all(&logs).unwrap();
-    let line =
-        serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": event_summary});
-    std::fs::write(
-        logs.join("events.jsonl"),
-        format!("{}\n", serde_json::to_string(&line).unwrap()),
-    )
-    .unwrap();
-    if let Some(bytes) = archive_bytes {
-        std::fs::write(logs.join("events.jsonl.1"), bytes).unwrap();
-    }
-    // MessageStore::open creates the schema so collect_watch_lines' result tail works.
-    let _ = MessageStore::open(&dir).unwrap();
-    WorkspacePath::new(dir)
-}
-
-#[test]
-fn watch_rotation_emits_marker_once_resets_offset_and_does_not_replay() {
-    // watch/__init__.py:66-97 — archive_signature change OR offset>size => ROTATION_MARKER
-    // (once), event_offset reset to 0, archived segment NOT replayed (only the current
-    // events.jsonl is read from the new offset forward). The doc-comment invariant
-    // (coordinator.rs lines 42-43 / 532-533) is now ASSERTED, not commented.
-    let ws = seed_watch_workspace("first segment", None);
-    let store = MessageStore::open(ws.as_path()).unwrap();
-    let mut cursor = WatchCursor::default();
-
-    // First call: initializes the cursor (no marker even though no archive yet),
-    // renders the seeded result line, advances offset past EOF.
-    let first = collect_watch_lines(&ws, &mut cursor, &store, None).unwrap();
-    assert!(cursor.initialized, "first call initializes the cursor");
-    assert!(
-        !first.iter().any(|l| l == ROTATION_MARKER),
-        "no rotation marker on first/initializing call"
-    );
-    assert!(
-        first.iter().any(|l| l.contains("first segment")),
-        "first segment line is rendered exactly once"
-    );
-    let offset_after_first = cursor.event_offset;
-    assert!(
-        offset_after_first > 0,
-        "offset advanced past the consumed segment"
-    );
-
-    // Simulate rotation: an archive segment now appears (archive_signature changes from
-    // None -> Some), and the live events.jsonl is replaced with a fresh, SHORTER file
-    // whose new content must NOT include the archived "first segment".
-    let logs = crate::model::paths::logs_dir(ws.as_path());
-    std::fs::write(
-        logs.join("events.jsonl.1"),
-        b"archived old bytes that must never replay\n",
-    )
-    .unwrap();
-    let fresh = serde_json::json!({"event": "result_received", "agent_id": "w1", "summary": "post rotation"});
-    std::fs::write(
-        logs.join("events.jsonl"),
-        format!("{}\n", serde_json::to_string(&fresh).unwrap()),
-    )
-    .unwrap();
-
-    let second = collect_watch_lines(&ws, &mut cursor, &store, None).unwrap();
-    let marker_count = second.iter().filter(|l| **l == ROTATION_MARKER).count();
-    assert_eq!(
-        marker_count, 1,
-        "ROTATION_MARKER emitted exactly once on rotation"
-    );
-    assert!(
-        !second.iter().any(|l| l.contains("first segment")),
-        "archived segment is NOT replayed"
-    );
-    assert!(
-        !second
-            .iter()
-            .any(|l| l.contains("old bytes that must never replay")),
-        "archive file contents are NEVER read/replayed"
-    );
-    assert!(
-        second.iter().any(|l| l.contains("post rotation")),
-        "post-rotation live segment IS rendered (read from reset offset forward)"
-    );
-    // offset was reset to 0 by the rotation branch, then re-advanced over the fresh
-    // (shorter) file — so it must be < the pre-rotation offset, proving the reset.
-    assert!(
-        cursor.event_offset <= offset_after_first,
-        "event_offset reset on rotation (re-advanced over the shorter fresh file)"
-    );
-    assert_eq!(
-        cursor.archive_signature.map(|(sz, _)| sz),
-        Some(b"archived old bytes that must never replay\n".len() as u64),
-        "archive_signature updated to the new archived segment's (size, mtime_ns)"
-    );
-}

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

@@ -1,34 +0,0 @@
-//!
-//! peer messaging compatibility helpers.
-
-use std::path::Path;
-
-use crate::event_log::EventLog;
-use crate::message_store::MessageStore;
-
-use super::MessagingError;
-
-///
-/// `leader.py:allow_peer_talk`: persist a bidirectional peer allowlist entry.
-pub fn allow_peer_talk(
-    workspace: &Path,
-    a: &str,
-    b: &str,
-) -> Result<serde_json::Value, MessagingError> {
-    let store = MessageStore::open(workspace)?;
-    store.allow_peer(a, b)?;
-    EventLog::new(workspace).write(
-        "communication.peer_allowed",
-        serde_json::json!({
-            "a": a,
-            "b": b,
-        }),
-    )?;
-    Ok(serde_json::json!({
-        "ok": true,
-        "a": a,
-        "b": b,
-        "status": "compat_noop",
-        "reason": "team_scoped_peer_messages_enabled",
-    }))
-}