@team-agent/installer 0.2.10 → 0.3.0

package/crates/team-agent-core/src/lib.rs

@@ -1,332 +0,0 @@
-use std::process::Command;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Target {
-    pub pane_id: String,
-    pub session_name: String,
-    pub window_index: String,
-    pub window_name: String,
-    pub pane_index: String,
-    pub pane_tty: String,
-    pub pane_current_command: String,
-    pub pane_active: bool,
-}
-
-impl Target {
-    pub fn fingerprint(&self) -> String {
-        format!(
-            "{}|{}|{}|{}",
-            self.session_name, self.window_index, self.pane_index, self.pane_tty
-        )
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum TargetResolution {
-    Resolved(Target),
-    Ambiguous(Vec<Target>),
-    Missing,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DeliveryStatus {
-    Accepted,
-    TargetResolved,
-    Injected,
-    Visible,
-    Failed,
-    Ambiguous,
-}
-
-impl DeliveryStatus {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            DeliveryStatus::Accepted => "accepted",
-            DeliveryStatus::TargetResolved => "target_resolved",
-            DeliveryStatus::Injected => "injected",
-            DeliveryStatus::Visible => "visible",
-            DeliveryStatus::Failed => "failed",
-            DeliveryStatus::Ambiguous => "ambiguous",
-        }
-    }
-
-    pub fn can_transition_to(&self, next: &DeliveryStatus) -> bool {
-        matches!(
-            (self, next),
-            (DeliveryStatus::Accepted, DeliveryStatus::TargetResolved)
-                | (DeliveryStatus::Accepted, DeliveryStatus::Failed)
-                | (DeliveryStatus::Accepted, DeliveryStatus::Ambiguous)
-                | (DeliveryStatus::TargetResolved, DeliveryStatus::Injected)
-                | (DeliveryStatus::TargetResolved, DeliveryStatus::Failed)
-                | (DeliveryStatus::TargetResolved, DeliveryStatus::Ambiguous)
-                | (DeliveryStatus::Injected, DeliveryStatus::Visible)
-                | (DeliveryStatus::Injected, DeliveryStatus::Failed)
-                | (DeliveryStatus::Visible, DeliveryStatus::Failed)
-        )
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DeliveryError {
-    pub code: String,
-    pub message: String,
-}
-
-pub fn list_tmux_targets() -> Result<Vec<Target>, String> {
-    let format = "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}";
-    let output = Command::new("tmux")
-        .args(["list-panes", "-a", "-F", format])
-        .output()
-        .map_err(|err| format!("tmux list-panes failed: {err}"))?;
-    if !output.status.success() {
-        return Err(String::from_utf8_lossy(&output.stderr).trim().to_string());
-    }
-    Ok(String::from_utf8_lossy(&output.stdout)
-        .lines()
-        .filter_map(parse_target_line)
-        .collect())
-}
-
-pub fn parse_target_line(line: &str) -> Option<Target> {
-    let parts: Vec<&str> = line.split('\t').collect();
-    if parts.len() != 8 {
-        return None;
-    }
-    Some(Target {
-        pane_id: parts[0].to_string(),
-        session_name: parts[1].to_string(),
-        window_index: parts[2].to_string(),
-        window_name: parts[3].to_string(),
-        pane_index: parts[4].to_string(),
-        pane_tty: parts[5].to_string(),
-        pane_current_command: parts[6].to_string(),
-        pane_active: parts[7] == "1",
-    })
-}
-
-pub fn resolve_target(candidates: Vec<Target>, expected_fingerprint: Option<&str>) -> TargetResolution {
-    if let Some(fingerprint) = expected_fingerprint {
-        let matched: Vec<Target> = candidates
-            .iter()
-            .cloned()
-            .filter(|target| target.fingerprint() == fingerprint)
-            .collect();
-        if matched.len() == 1 {
-            return TargetResolution::Resolved(matched[0].clone());
-        }
-        if matched.len() > 1 {
-            return TargetResolution::Ambiguous(matched);
-        }
-    }
-    let usable: Vec<Target> = candidates
-        .into_iter()
-        .filter(|target| {
-            let cmd = target
-                .pane_current_command
-                .rsplit('/')
-                .next()
-                .unwrap_or(&target.pane_current_command);
-            matches!(cmd, "codex" | "node" | "nodejs")
-        })
-        .collect();
-    match usable.len() {
-        0 => TargetResolution::Missing,
-        1 => TargetResolution::Resolved(usable[0].clone()),
-        _ => TargetResolution::Ambiguous(usable),
-    }
-}
-
-pub fn render_message(sender: &str, task_id: Option<&str>, content: &str, token: &str) -> String {
-    let mut header = format!("Team Agent message from {}", sender);
-    if let Some(task) = task_id {
-        if !task.is_empty() {
-            header.push_str(" for ");
-            header.push_str(task);
-        }
-    }
-    format!("{header}:\n\n{content}\n\n[team-agent-token:{token}]")
-}
-
-pub fn redact_secrets(input: &str) -> String {
-    let mut out = Vec::new();
-    for raw in input.split_whitespace() {
-        let lower = raw.to_ascii_lowercase();
-        let redacted = lower.contains("api_key")
-            || lower.contains("apikey")
-            || lower.contains("token=")
-            || lower.contains("secret")
-            || lower == "bearer"
-            || raw.starts_with("sk-")
-            || looks_base64_secret(raw);
-        out.push(if redacted { "[REDACTED]" } else { raw });
-    }
-    out.join(" ")
-}
-
-pub fn looks_base64_secret(value: &str) -> bool {
-    value.len() >= 32
-        && value
-            .chars()
-            .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '+' | '/' | '=' | '_' | '-'))
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Profile {
-    pub provider: String,
-    pub model: String,
-    pub auth_mode: String,
-    pub profile: String,
-    pub credential_ref: Option<String>,
-}
-
-pub fn validate_profile(profile: &Profile) -> Result<(), Vec<String>> {
-    let mut errors = Vec::new();
-    if !matches!(
-        profile.auth_mode.as_str(),
-        "subscription" | "official_api" | "compatible_api"
-    ) {
-        errors.push("auth_mode must be subscription, official_api, or compatible_api".to_string());
-    }
-    if profile.provider.is_empty() {
-        errors.push("provider must not be empty".to_string());
-    }
-    if profile.model.is_empty() {
-        errors.push("model must not be empty".to_string());
-    }
-    if profile.profile.is_empty() {
-        errors.push("profile must not be empty".to_string());
-    }
-    for value in [
-        &profile.provider,
-        &profile.model,
-        &profile.auth_mode,
-        &profile.profile,
-    ] {
-        if contains_inline_secret(value) {
-            errors.push("profile metadata contains a probable inline secret".to_string());
-            break;
-        }
-    }
-    if errors.is_empty() {
-        Ok(())
-    } else {
-        Err(errors)
-    }
-}
-
-pub fn contains_inline_secret(value: &str) -> bool {
-    contains_secret_assignment(value)
-        || contains_bearer_secret(value)
-        || value
-            .split_whitespace()
-            .any(|chunk| chunk.starts_with("sk-") || looks_base64_secret(chunk))
-        || value.starts_with("sk-")
-        || looks_base64_secret(value)
-}
-
-fn contains_secret_assignment(value: &str) -> bool {
-    for line in value.lines() {
-        for separator in ['=', ':'] {
-            let Some((key, raw)) = line.split_once(separator) else {
-                continue;
-            };
-            let normalized: String = key
-                .to_ascii_lowercase()
-                .chars()
-                .filter(|ch| ch.is_ascii_alphanumeric())
-                .collect();
-            if !matches!(
-                normalized.as_str(),
-                "apikey" | "token" | "secret" | "password" | "credential"
-            ) {
-                continue;
-            }
-            let candidate = raw.trim().trim_matches(|ch| ch == '"' || ch == '\'');
-            if candidate.starts_with("sk-") || candidate.len() >= 8 || looks_base64_secret(candidate) {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-fn contains_bearer_secret(value: &str) -> bool {
-    let mut previous_was_bearer = false;
-    for chunk in value.split_whitespace() {
-        if previous_was_bearer && chunk.len() >= 16 && chunk.chars().all(|ch| {
-            ch.is_ascii_alphanumeric() || matches!(ch, '.' | '_' | '~' | '+' | '/' | '=' | '-')
-        }) {
-            return true;
-        }
-        previous_was_bearer = chunk.eq_ignore_ascii_case("bearer");
-    }
-    false
-}
-
-pub fn json_escape(input: &str) -> String {
-    let mut out = String::new();
-    for ch in input.chars() {
-        match ch {
-            '"' => out.push_str("\\\""),
-            '\\' => out.push_str("\\\\"),
-            '\n' => out.push_str("\\n"),
-            '\r' => out.push_str("\\r"),
-            '\t' => out.push_str("\\t"),
-            ch if ch.is_control() => out.push_str(&format!("\\u{:04x}", ch as u32)),
-            ch => out.push(ch),
-        }
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_target_and_fingerprint() {
-        let target = parse_target_line("%1\ts\t2\tw\t0\t/dev/ttys001\tnode\t1").unwrap();
-        assert_eq!(target.pane_id, "%1");
-        assert_eq!(target.fingerprint(), "s|2|0|/dev/ttys001");
-    }
-
-    #[test]
-    fn delivery_state_transitions_are_explicit() {
-        assert!(DeliveryStatus::Accepted.can_transition_to(&DeliveryStatus::TargetResolved));
-        assert!(DeliveryStatus::TargetResolved.can_transition_to(&DeliveryStatus::Injected));
-        assert!(DeliveryStatus::Injected.can_transition_to(&DeliveryStatus::Visible));
-        assert!(!DeliveryStatus::Accepted.can_transition_to(&DeliveryStatus::Visible));
-    }
-
-    #[test]
-    fn renders_human_readable_message() {
-        let rendered = render_message("worker", Some("task_a"), "done", "msg_1");
-        assert!(rendered.contains("Team Agent message from worker for task_a:"));
-        assert!(rendered.contains("[team-agent-token:msg_1]"));
-    }
-
-    #[test]
-    fn redacts_common_secret_shapes() {
-        let redacted = redact_secrets("Authorization Bearer sk-test abcdefghijklmnopqrstuvwxyz123456");
-        assert!(redacted.contains("[REDACTED]"));
-        assert!(!redacted.contains("sk-test"));
-    }
-
-    #[test]
-    fn inline_secret_scan_allows_ordinary_token_prose() {
-        assert!(!contains_inline_secret("Use the visible token in logs for delivery evidence."));
-        assert!(contains_inline_secret("API_KEY=sk-inline-secret"));
-    }
-
-    #[test]
-    fn profile_rejects_inline_secret() {
-        let profile = Profile {
-            provider: "codex".to_string(),
-            model: "gpt-5.5".to_string(),
-            auth_mode: "subscription".to_string(),
-            profile: "sk-inline-secret".to_string(),
-            credential_ref: None,
-        };
-        assert!(validate_profile(&profile).is_err());
-    }
-}

package/crates/team-agent-core/src/main.rs

@@ -1,152 +0,0 @@
-use std::env;
-use std::io::{self, Read};
-
-use team_agent_core::{
-    contains_inline_secret, json_escape, list_tmux_targets, redact_secrets, render_message,
-    validate_profile, Profile,
-};
-
-fn main() {
-    let args: Vec<String> = env::args().collect();
-    let command = args.get(1).map(String::as_str).unwrap_or("");
-    let result = match command {
-        "list-targets" => list_targets(),
-        "render-message" => render_message_cmd(),
-        "redact" => redact_cmd(),
-        "validate-profile" => validate_profile_cmd(),
-        _ => Err(format!(
-            "unknown command {command:?}; expected list-targets, render-message, redact, validate-profile"
-        )),
-    };
-    match result {
-        Ok(json) => println!("{json}"),
-        Err(error) => {
-            println!(
-                "{{\"ok\":false,\"error\":\"{}\"}}",
-                json_escape(error.trim())
-            );
-            std::process::exit(1);
-        }
-    }
-}
-
-fn read_stdin() -> Result<String, String> {
-    let mut input = String::new();
-    io::stdin()
-        .read_to_string(&mut input)
-        .map_err(|err| format!("stdin read failed: {err}"))?;
-    Ok(input)
-}
-
-fn list_targets() -> Result<String, String> {
-    let targets = list_tmux_targets()?;
-    let mut items = Vec::new();
-    for target in targets {
-        items.push(format!(
-            "{{\"pane_id\":\"{}\",\"session_name\":\"{}\",\"window_index\":\"{}\",\"window_name\":\"{}\",\"pane_index\":\"{}\",\"pane_tty\":\"{}\",\"pane_current_command\":\"{}\",\"pane_active\":{},\"fingerprint\":\"{}\"}}",
-            json_escape(&target.pane_id),
-            json_escape(&target.session_name),
-            json_escape(&target.window_index),
-            json_escape(&target.window_name),
-            json_escape(&target.pane_index),
-            json_escape(&target.pane_tty),
-            json_escape(&target.pane_current_command),
-            target.pane_active,
-            json_escape(&target.fingerprint())
-        ));
-    }
-    Ok(format!("{{\"ok\":true,\"targets\":[{}]}}", items.join(",")))
-}
-
-fn render_message_cmd() -> Result<String, String> {
-    let input = read_stdin()?;
-    let sender = extract_string(&input, "from")
-        .or_else(|| extract_string(&input, "sender"))
-        .unwrap_or_else(|| "unknown".to_string());
-    let task_id = extract_string(&input, "task_id");
-    let content = extract_string(&input, "content").unwrap_or_default();
-    let token = extract_string(&input, "message_id").unwrap_or_else(|| "missing".to_string());
-    let rendered = render_message(&sender, task_id.as_deref(), &content, &token);
-    Ok(format!(
-        "{{\"ok\":true,\"text\":\"{}\",\"token\":\"{}\"}}",
-        json_escape(&rendered),
-        json_escape(&token)
-    ))
-}
-
-fn redact_cmd() -> Result<String, String> {
-    let input = read_stdin()?;
-    let text = extract_string(&input, "text").unwrap_or(input);
-    Ok(format!(
-        "{{\"ok\":true,\"text\":\"{}\"}}",
-        json_escape(&redact_secrets(&text))
-    ))
-}
-
-fn validate_profile_cmd() -> Result<String, String> {
-    let input = read_stdin()?;
-    let profile = Profile {
-        provider: extract_string(&input, "provider").unwrap_or_default(),
-        model: extract_string(&input, "model").unwrap_or_default(),
-        auth_mode: extract_string(&input, "auth_mode").unwrap_or_default(),
-        profile: extract_string(&input, "profile").unwrap_or_default(),
-        credential_ref: extract_string(&input, "credential_ref"),
-    };
-    let mut errors = match validate_profile(&profile) {
-        Ok(()) => Vec::new(),
-        Err(errors) => errors,
-    };
-    if contains_inline_secret(&input) {
-        errors.push("input contains a probable inline secret".to_string());
-    }
-    if errors.is_empty() {
-        Ok("{\"ok\":true,\"errors\":[]}".to_string())
-    } else {
-        let encoded: Vec<String> = errors
-            .into_iter()
-            .map(|err| format!("\"{}\"", json_escape(&err)))
-            .collect();
-        Ok(format!("{{\"ok\":false,\"errors\":[{}]}}", encoded.join(",")))
-    }
-}
-
-fn extract_string(input: &str, key: &str) -> Option<String> {
-    let needle = format!("\"{key}\"");
-    let key_pos = input.find(&needle)?;
-    let rest = &input[key_pos + needle.len()..];
-    let colon = rest.find(':')?;
-    let value = rest[colon + 1..].trim_start();
-    if !value.starts_with('"') {
-        return None;
-    }
-    parse_json_string(value)
-}
-
-fn parse_json_string(input: &str) -> Option<String> {
-    let mut out = String::new();
-    let mut chars = input.chars();
-    if chars.next()? != '"' {
-        return None;
-    }
-    let mut escaped = false;
-    for ch in chars {
-        if escaped {
-            match ch {
-                '"' => out.push('"'),
-                '\\' => out.push('\\'),
-                'n' => out.push('\n'),
-                'r' => out.push('\r'),
-                't' => out.push('\t'),
-                other => out.push(other),
-            }
-            escaped = false;
-            continue;
-        }
-        match ch {
-            '\\' => escaped = true,
-            '"' => return Some(out),
-            other => out.push(other),
-        }
-    }
-    None
-}

package/pyproject.toml

@@ -1,18 +0,0 @@
-[project]
-name = "teamspec-agent-mode"
-version = "0.1.4"
-description = "Spec-first CLI-native team agent runtime for Claude Code, Codex CLI, and Gemini CLI workers."
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = []
-
-[project.optional-dependencies]
-test = []
-
-[project.scripts]
-team-agent = "team_agent.cli:main"
-team_orchestrator = "team_agent.mcp_server:main"
-team-agent-coordinator = "team_agent.coordinator:main"
-
-[tool.team-agent]
-run = "PYTHONPATH=src python3 -m team_agent"

package/scripts/install.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import glob
-import os
-import shutil
-import subprocess
-from pathlib import Path
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Install local team-agent wrapper commands")
-    parser.add_argument("--prefix", default=str(Path.home() / ".local"), help="Install prefix; bin/ is created under it")
-    parser.add_argument("--python", help="Python executable to embed in wrappers; defaults to TEAM_AGENT_PYTHON, python3, then python")
-    args = parser.parse_args()
-    repo = Path(__file__).resolve().parents[1]
-    python = _resolve_python(args.python)
-    bin_dir = Path(args.prefix) / "bin"
-    bin_dir.mkdir(parents=True, exist_ok=True)
-    _write_wrapper(bin_dir / "team-agent", repo, "team_agent", python)
-    _write_wrapper(bin_dir / "team_orchestrator", repo, "team_agent.mcp_server", python)
-    _write_wrapper(bin_dir / "team-agent-coordinator", repo, "team_agent.coordinator", python)
-    print(f"installed: {bin_dir / 'team-agent'}")
-    print(f"installed: {bin_dir / 'team_orchestrator'}")
-    print(f"installed: {bin_dir / 'team-agent-coordinator'}")
-    print(f"python: {python}")
-    print(f"ensure PATH contains: {bin_dir}")
-
-
-def _resolve_python(explicit: str | None) -> str:
-    candidates = _python_candidates(explicit)
-    for candidate in candidates:
-        if not candidate:
-            continue
-        resolved = shutil.which(candidate) if os.path.basename(candidate) == candidate else candidate
-        if not resolved:
-            continue
-        proc = subprocess.run(
-            [
-                resolved,
-                "-c",
-                "import sys; raise SystemExit(0 if sys.version_info >= (3, 10) else 1)",
-            ],
-            text=True,
-            capture_output=True,
-            check=False,
-        )
-        if proc.returncode == 0:
-            return resolved
-    raise SystemExit("No usable Python >= 3.10 found. Set TEAM_AGENT_PYTHON or pass --python.")
-
-
-def _python_candidates(explicit: str | None) -> list[str]:
-    candidates = [
-        explicit,
-        os.environ.get("TEAM_AGENT_PYTHON"),
-        "python3",
-        "python",
-        "/opt/homebrew/bin/python3",
-        "/usr/local/bin/python3",
-        "/usr/bin/python3",
-        "/opt/homebrew/opt/python@3/bin/python3",
-        "/usr/local/opt/python@3/bin/python3",
-    ]
-    candidates.extend(glob.glob("/opt/homebrew/opt/python@*/bin/python3*"))
-    candidates.extend(glob.glob("/usr/local/opt/python@*/bin/python3*"))
-    seen: set[str] = set()
-    result: list[str] = []
-    for item in candidates:
-        if not item or item in seen:
-            continue
-        seen.add(item)
-        result.append(item)
-    return result
-
-
-def _write_wrapper(path: Path, repo: Path, module: str, python: str) -> None:
-    path.write_text(
-        "#!/usr/bin/env sh\n"
-        f'PYTHON_BIN="${{TEAM_AGENT_PYTHON:-{python}}}"\n'
-        f'PYTHONPATH="{repo / "src"}" exec "$PYTHON_BIN" -m {module} "$@"\n',
-        encoding="utf-8",
-    )
-    path.chmod(path.stat().st_mode | 0o755)
-
-
-if __name__ == "__main__":
-    main()

package/scripts/run_regression_tests.py

@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-
-REGRESSION_TESTS = [
-    "tests.run_tests.RuntimeTests.test_send_default_timeout_reports_submitted_unverified",
-    "tests.run_tests.RuntimeTests.test_message_fragment_matching_ignores_generic_header",
-    "tests.run_tests.RuntimeTests.test_wait_for_message_ready_does_not_accept_old_header",
-    "tests.run_tests.RuntimeTests.test_wait_for_message_ready_accepts_only_new_pasted_prompt",
-    "tests.run_tests.RuntimeTests.test_worker_delivery_retries_paste_until_message_ready",
-    "tests.run_tests.RuntimeTests.test_worker_pasted_content_prompt_retries_enter_until_submitted",
-    "tests.run_tests.RuntimeTests.test_worker_pasted_content_prompt_reports_unverified_when_enter_does_not_submit",
-    "tests.run_tests.RuntimeTests.test_delivery_claim_prevents_duplicate_worker_injection",
-    "tests.run_tests.RuntimeTests.test_approvals_returns_structured_prompt_without_terminal_page",
-    "tests.run_tests.RuntimeTests.test_coordinator_auto_approves_internal_mcp_prompt_with_retry_verification",
-    "tests.run_tests.RuntimeTests.test_coordinator_auto_approves_claude_internal_mcp_prompt",
-    "tests.run_tests.RuntimeTests.test_stale_approval_prompt_in_scrollback_is_not_current_approval",
-    "tests.run_tests.RuntimeTests.test_ghostty_display_session_is_linked_and_window_selected",
-    "tests.run_tests.RuntimeTests.test_shutdown_closes_ghostty_display_session_before_base_session_without_pid",
-    "tests.run_tests.RuntimeTests.test_restart_resumes_known_sessions_and_fresh_spawns_missing_sessions",
-    "tests.run_tests.RuntimeTests.test_restart_first_resume_exit_fallback_recreates_session_and_opens_display",
-    "tests.run_tests.RuntimeTests.test_start_agent_repairs_missing_worker_window_without_restart",
-    "tests.run_tests.RuntimeTests.test_start_agent_falls_back_to_fresh_when_resume_window_exits",
-    "tests.run_tests.RuntimeTests.test_broadcast_sends_only_to_current_team_and_excludes_sender",
-    "tests.run_tests.RuntimeTests.test_status_and_collect_expose_uncollected_report_result",
-    "tests.run_tests.RuntimeTests.test_collect_accepts_message_scoped_report_result",
-    "tests.run_tests.RuntimeTests.test_report_result_queues_leader_notification_without_blocking_mcp",
-    "tests.run_tests.RuntimeTests.test_mcp_send_message_accepts_thin_args_and_returns_compact_result",
-    "tests.run_tests.RuntimeTests.test_mcp_send_message_accepts_broadcast_target",
-    "tests.run_tests.RuntimeTests.test_mcp_send_message_without_env_infers_worker_before_leader_send",
-    "tests.run_tests.RuntimeTests.test_mcp_report_result_without_env_infers_task_and_agent",
-    "tests.run_tests.RuntimeTests.test_mcp_report_result_normalizes_common_loose_shapes",
-    "tests.run_tests.RuntimeTests.test_compile_system_prompt_prepends_teammate_runtime_contract",
-    "tests.run_tests.RuntimeTests.test_codex_default_command_avoids_dangerous_bypass",
-    "tests.run_tests.RuntimeTests.test_launch_inherits_leader_dangerous_permissions_in_dry_run",
-    "tests.run_tests.RuntimeTests.test_launch_passes_inherited_dangerous_permissions_to_worker_runtime",
-    "tests.run_tests.RuntimeTests.test_restart_passes_inherited_dangerous_permissions_to_resume_and_fresh_workers",
-    "tests.run_tests.RuntimeTests.test_quick_start_refuses_to_overwrite_existing_context_without_fresh",
-    "tests.run_tests.RuntimeTests.test_quick_start_team_id_stores_loose_docs_outside_current",
-    "tests.run_tests.RuntimeTests.test_start_writes_compiled_spec_inside_selected_team_dir",
-    "tests.run_tests.RuntimeTests.test_preflight_uses_selected_team_profile_dir_not_current",
-    "tests.run_tests.RuntimeTests.test_restart_requires_team_selector_when_multiple_snapshots_exist",
-    "tests.run_tests.RuntimeTests.test_leader_start_plan_creates_tmux_session_outside_tmux_and_passes_args",
-    "tests.run_tests.RuntimeTests.test_leader_start_plan_inside_tmux_execs_provider_in_current_pane",
-    "tests.run_tests.RuntimeTests.test_launch_requires_current_tmux_leader_for_real_workers",
-    "tests.run_tests.RuntimeTests.test_resolve_leader_scans_workspace_when_tool_shell_has_wrong_tmux_client",
-    "tests.run_tests.RuntimeTests.test_resolve_leader_reports_ambiguous_workspace_panes",
-    "tests.run_tests.CliContractTests.test_leader_commands_pass_provider_flags_without_argparse_consuming_them",
-    "tests.run_tests.CliContractTests.test_npx_installer_installs_runtime_wrappers_and_skills",
-    "tests.run_tests.CliContractTests.test_skill_blackbox_lint",
-]
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Run the fixed Team Agent regression asset.")
-    parser.add_argument("--iterations", type=int, default=1, help="repeat the regression batch N times")
-    parser.add_argument("--list", action="store_true", help="print the selected unittest ids and exit")
-    args = parser.parse_args()
-    if args.iterations < 1:
-        parser.error("--iterations must be >= 1")
-    if args.list:
-        print("\n".join(REGRESSION_TESTS))
-        return 0
-
-    repo = Path(__file__).resolve().parents[1]
-    env = os.environ.copy()
-    env["PYTHONPATH"] = str(repo / "src") + os.pathsep + env.get("PYTHONPATH", "")
-    for index in range(1, args.iterations + 1):
-        print(f"[team-agent-regression] iteration {index}/{args.iterations}", flush=True)
-        proc = subprocess.run([sys.executable, "-m", "unittest", *REGRESSION_TESTS], cwd=repo, env=env, check=False)
-        if proc.returncode != 0:
-            return proc.returncode
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/team_agent/__init__.py

@@ -1,3 +0,0 @@
-"""TeamSpec Agent Mode runtime."""
-
-__version__ = "0.1.4"

package/src/team_agent/__main__.py

@@ -1,5 +0,0 @@
-from team_agent.cli import main
-
-
-if __name__ == "__main__":
-    main()