@team-agent/installer 0.5.65 → 0.5.68

package/crates/team-agent/src/lifecycle/launch/agent_state.rs

@@ -1,3 +1,22 @@
+//! ---
+//! purpose: 单个席位在 runtime state 里的行的构造，含 MCP 配置落盘与审批策略投影
+//! contract:
+//!   provides:
+//!     - name: running_agent_state
+//!       what: 构造 running 席位的 state 行，同时写出该席位的 MCP 配置文件
+//!     - name: effective_approval_policy
+//!       what: 把 bypass 审批结论投影成 state 里的 JSON
+//!     - name: effective_approval_policy_from_agent
+//!       what: 由席位行自己的 dangerously_skip_permissions 算审批策略
+//!   depends:
+//!     - crate::provider
+//!     - crate::provider::bypass_flags
+//!     - crate::lifecycle::launch::mcp_config
+//! boundary:
+//!   - 只构造与落 MCP 配置，不 spawn 也不改窗口
+//!   - 审批结论只认席位自己的声明，不做全队继承
+//! maturity: wired
+//! ---
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -14,6 +33,15 @@ use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest}
 
 use super::*;
 
+/// ---
+/// purpose: 构造某席位 running 状态的 state 行
+/// params:
+///   spawn_cwd: 该席位进程的工作目录
+///   started_agent: 本次 spawn 结果，用于取布局窗口
+///   pane_id: 该席位的 pane，空串时不写入
+/// returns: 含状态、provider、模型、auth_mode、窗口、MCP 配置路径、spawn 时间与 pane 信息的行
+/// errors: 取 provider MCP 配置失败返回 Provider，写 MCP 配置文件失败返回 StatePersist
+/// ---
 pub(super) fn running_agent_state(
     agent: &Value,
     id: &str,
@@ -24,7 +52,6 @@ pub(super) fn running_agent_state(
     team_id: &str,
     pane_id: Option<&str>,
     pane_pid: Option<u32>,
-    safety: &DangerousApproval,
     started_agent: Option<&StartedAgent>,
     profile_dir: Option<&Path>,
 ) -> Result<serde_json::Value, LifecycleError> {
@@ -84,7 +111,16 @@ pub(super) fn running_agent_state(
         permissions_json(agent, id, provider)
             .map_err(|e| LifecycleError::Compile(e.to_string()))?,
     );
-    persist_effective_approval_policy(&mut state, safety);
+    // 0.5.66 bypass 单源:policy 从 agent 字段派生,不再用全队 `DangerousApproval`。
+    persist_effective_approval_policy_from_yaml_agent(&mut state, agent, provider);
+    // 0.5.66 bypass 单源 §2.6:fresh spawn 记录运行面 bypass 值(供 restart drift 挡板)。
+    state.insert(
+        "as_launched_dangerously_skip_permissions".to_string(),
+        serde_json::json!(matches!(
+            agent.get("dangerously_skip_permissions"),
+            Some(Value::Bool(true))
+        )),
+    );
     state.insert("session_id".to_string(), serde_json::Value::Null);
     state.insert("rollout_path".to_string(), serde_json::Value::Null);
     state.insert("captured_at".to_string(), serde_json::Value::Null);
@@ -133,6 +169,10 @@ pub(super) fn running_agent_state(
     Ok(serde_json::Value::Object(state))
 }
 
+/// ---
+/// purpose: 把 bypass 审批结论投影成落盘用的 JSON
+/// returns: 含 enabled、来源、是否继承与显式确认位；来源为 runtime_config 且启用时视为已显式确认
+/// ---
 pub(crate) fn effective_approval_policy(safety: &DangerousApproval) -> serde_json::Value {
     serde_json::json!({
         "enabled": safety.enabled,
@@ -145,6 +185,11 @@ pub(crate) fn effective_approval_policy(safety: &DangerousApproval) -> serde_jso
     })
 }
 
+/// ---
+/// purpose: 把审批策略写进席位 state 行
+/// params:
+///   agent_state: 就地写入 effective_approval_policy 字段
+/// ---
 pub(crate) fn persist_effective_approval_policy(
     agent_state: &mut serde_json::Map<String, serde_json::Value>,
     safety: &DangerousApproval,
@@ -155,6 +200,10 @@ pub(crate) fn persist_effective_approval_policy(
     );
 }
 
+/// ---
+/// purpose: 给出审批来源的稳定 wire 字符串
+/// returns: runtime_config、leader_process 或 disabled
+/// ---
 pub(super) fn dangerous_approval_source_str(source: DangerousApprovalSource) -> &'static str {
     match source {
         DangerousApprovalSource::RuntimeConfig => "runtime_config",
@@ -162,3 +211,148 @@ pub(super) fn dangerous_approval_source_str(source: DangerousApprovalSource) ->
         DangerousApprovalSource::Disabled => "disabled",
     }
 }
+
+/// ---
+/// purpose: 由 JSON 席位行自己的 bypass 声明算出审批策略
+/// returns: 未声明时全为关闭；声明为真时记 runtime_config 来源并带该 provider 的 bypass argv
+/// contract_id: lifecycle.agent_state.approval_policy_from_agent
+/// ---
+/// 0.5.66 bypass 单源:从 agent 行 + provider 构造 approval policy JSON
+/// (restart/fork/add 落盘用;取代全队 `DangerousApproval` 派生)。
+pub(crate) fn effective_approval_policy_from_agent(
+    agent: &serde_json::Value,
+    provider: Provider,
+) -> serde_json::Value {
+    let enabled = agent
+        .get("dangerously_skip_permissions")
+        .and_then(serde_json::Value::as_bool)
+        .unwrap_or(false);
+    if !enabled {
+        return serde_json::json!({
+            "enabled": false,
+            "source": "disabled",
+            "inherited": false,
+            "explicit_yes_confirmed": false,
+            "provider": null,
+            "flag": null,
+            "worker_capability_above_leader": false,
+        });
+    }
+    let flag = crate::provider::bypass_flags::provider_bypass_flag(provider);
+    serde_json::json!({
+        "enabled": true,
+        "source": "runtime_config",
+        "inherited": false,
+        "explicit_yes_confirmed": true,
+        "provider": provider_wire_str(provider),
+        "flag": flag,
+        "worker_capability_above_leader": false,
+    })
+}
+
+fn provider_wire_str(provider: Provider) -> &'static str {
+    match provider {
+        Provider::Claude => "claude",
+        Provider::ClaudeCode => "claude_code",
+        Provider::Codex => "codex",
+        Provider::Copilot => "copilot",
+        Provider::GeminiCli => "gemini_cli",
+        Provider::Grok => "grok",
+        Provider::CursorAgent => "cursor_agent",
+        Provider::Fake => "fake",
+    }
+}
+
+/// ---
+/// purpose: 由席位行自身算出审批策略并写回同一行
+/// params:
+///   agent_state: 既是来源也是写入目标
+/// ---
+/// 0.5.66 bypass 单源:从 agent 行(state Map)+ provider 落盘 approval policy。
+/// 目标与来源是同一 agent 行。
+pub(crate) fn persist_effective_approval_policy_from_agent(
+    agent_state: &mut serde_json::Map<String, serde_json::Value>,
+    provider: Provider,
+) {
+    let agent = serde_json::Value::Object(agent_state.clone());
+    agent_state.insert(
+        "effective_approval_policy".to_string(),
+        effective_approval_policy_from_agent(&agent, provider),
+    );
+}
+
+/// ---
+/// purpose: 由 YAML spec 里的 agent 声明算出审批策略并写进 state 行
+/// params:
+///   agent: YAML 侧的 agent 节点，提供 bypass 声明
+///   agent_state: 写入目标
+/// ---
+/// 0.5.66 bypass 单源:yaml spec agent 版(launch/state_projection 用)。
+pub(crate) fn persist_effective_approval_policy_from_yaml_agent(
+    agent_state: &mut serde_json::Map<String, serde_json::Value>,
+    agent: &Value,
+    provider: Provider,
+) {
+    let enabled = matches!(agent.get("dangerously_skip_permissions"), Some(Value::Bool(true)));
+    let policy = if !enabled {
+        serde_json::json!({
+            "enabled": false,
+            "source": "disabled",
+            "inherited": false,
+            "explicit_yes_confirmed": false,
+            "provider": null,
+            "flag": null,
+            "worker_capability_above_leader": false,
+        })
+    } else {
+        let flag = crate::provider::bypass_flags::provider_bypass_flag(provider);
+        serde_json::json!({
+            "enabled": true,
+            "source": "runtime_config",
+            "inherited": false,
+            "explicit_yes_confirmed": true,
+            "provider": provider_wire_str(provider),
+            "flag": flag,
+            "worker_capability_above_leader": false,
+        })
+    };
+    agent_state.insert("effective_approval_policy".to_string(), policy);
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+    use super::*;
+
+    fn yaml_agent(bypass: bool) -> Value {
+        crate::model::yaml::loads(&format!(
+            "id: a\nrole: r\nprovider: codex\ndangerously_skip_permissions: {bypass}\n"
+        ))
+        .unwrap()
+    }
+
+    // 0.5.66 bypass 单源 §4.1:true 角色 → policy 落盘为 enabled=true / runtime_config,
+    // 且 running_agent_state 记录 as_launched_dangerously_skip_permissions=true(审计留痕前提)。
+    #[test]
+    fn test_audit_log_written_on_true_spawn() {
+        let mut state = serde_json::Map::new();
+        persist_effective_approval_policy_from_yaml_agent(&mut state, &yaml_agent(true), Provider::Codex);
+        let policy = state.get("effective_approval_policy").unwrap();
+        assert_eq!(policy["enabled"], serde_json::json!(true));
+        assert_eq!(policy["source"], serde_json::json!("runtime_config"));
+        assert_eq!(
+            policy["flag"],
+            serde_json::json!("--dangerously-bypass-approvals-and-sandbox")
+        );
+        // 运行面记录(as-launched)供 restart drift 挡板。
+        let mut run_state = serde_json::Map::new();
+        run_state.insert(
+            "as_launched_dangerously_skip_permissions".to_string(),
+            serde_json::json!(matches!(
+                yaml_agent(true).get("dangerously_skip_permissions"),
+                Some(Value::Bool(true))
+            )),
+        );
+        assert_eq!(run_state["as_launched_dangerously_skip_permissions"], serde_json::json!(true));
+    }
+}

package/crates/team-agent/src/lifecycle/launch/clone_agent.rs

@@ -1,3 +1,14 @@
+//! ---
+//! purpose: 零上下文重读角色文件再起一席，不继承源会话
+//! contract:
+//!   provides:
+//!     - name: clone_agent
+//!       what: 用源席最新角色文件 add-agent，保留源工具集
+//! boundary:
+//!   - 不走 fork 的窗口内命令
+//!   - 不把 clone 与 fork 合成一条路径
+//! maturity: wired
+//! ---
 use crate::lifecycle::*;
 use crate::model::ids::AgentId;
 use crate::provider::SessionId;
@@ -5,6 +16,15 @@ use std::path::Path;
 
 use super::*;
 
+/// ---
+/// purpose: 以源席最新角色文件另起一席，不继承源会话
+/// params:
+///   source_agent_id: 源席位，只借它的角色文件与工具集
+///   as_agent_id: 新席位名
+///   label: 新席位的角色标签
+/// returns: clone 报告
+/// errors: 选不到 team 返回 TeamSelect，源席不存在返回 RequirementUnmet，角色物化与加席错误透传
+/// ---
 pub fn clone_agent(
     workspace: &Path,
     source_agent_id: &AgentId,
@@ -40,16 +60,10 @@ pub fn clone_agent(
         as_agent_id,
         label,
     )?;
-    let spec_path = selected
-        .spec_path
-        .as_ref()
-        .ok_or_else(|| LifecycleError::TeamSelect("active team spec not found".to_string()))?;
-    let spec = crate::model::yaml::loads(
-        &std::fs::read_to_string(spec_path)
-            .map_err(|error| LifecycleError::Compile(error.to_string()))?,
-    )
-    .map_err(|error| LifecycleError::Compile(error.to_string()))?;
-    clamp_materialized_role_to_leader(materialized.path(), &spec)?;
+    // The materialized role carries the source role's DECLARED tools verbatim —
+    // a clone must preserve the source seat's full tools set (add-agent does
+    // the same; no leader-ceiling clamp). See role_source.rs for the removed
+    // clamp_materialized_role_to_leader.
     let added = add_agent(
         &selected.run_workspace,
         as_agent_id,
@@ -63,6 +77,15 @@ pub fn clone_agent(
         as_agent_id,
         source_session_id.as_ref(),
     );
+    if let Some((session_id, backing_path)) = verified.as_ref() {
+        persist_clone_session(
+            &selected.run_workspace,
+            selected.team_key.as_str(),
+            as_agent_id,
+            session_id,
+            backing_path,
+        )?;
+    }
     let (session_id, backing_path, backing_state) = match verified {
         Some((session_id, backing_path)) => (
             Some(session_id),
@@ -94,13 +117,80 @@ fn read_agent_session(
         .and_then(|agents| agents.get(agent_id.as_str()))?;
     let session = agent
         .get("session_id")
+        .or_else(|| agent.get("_pending_session_id"))
         .and_then(serde_json::Value::as_str)
         .filter(|value| !value.is_empty())?;
     let backing = agent
         .get("rollout_path")
         .and_then(serde_json::Value::as_str)
         .filter(|value| !value.is_empty())
-        .map(std::path::PathBuf::from)?;
+        .map(std::path::PathBuf::from)
+        .or_else(|| find_claude_backing(agent, session))?;
     let distinct = source_session_id.is_none_or(|source| source.as_str() != session);
     (distinct && backing.is_file()).then(|| (SessionId::new(session), backing))
 }
+
+fn find_claude_backing(agent: &serde_json::Value, session: &str) -> Option<std::path::PathBuf> {
+    let root = agent
+        .get("claude_projects_root")
+        .and_then(serde_json::Value::as_str)
+        .map(std::path::PathBuf::from)
+        .or_else(|| {
+            std::env::var_os("HOME")
+                .map(|home| std::path::PathBuf::from(home).join(".claude/projects"))
+        })?;
+    let target = format!("{session}.jsonl");
+    let mut pending = vec![root];
+    while let Some(dir) = pending.pop() {
+        let entries = std::fs::read_dir(&dir).ok()?;
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                pending.push(path);
+            } else if path.file_name().and_then(|name| name.to_str()) == Some(target.as_str()) {
+                return Some(path);
+            }
+        }
+    }
+    None
+}
+
+fn persist_clone_session(
+    workspace: &Path,
+    team_key: &str,
+    agent_id: &AgentId,
+    session_id: &SessionId,
+    backing_path: &Path,
+) -> Result<(), LifecycleError> {
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace,
+        operation: "clone-session-bind",
+        team: Some(team_key),
+        agent_id: Some(agent_id),
+    })?;
+    let mut state = crate::state::projection::select_runtime_state(workspace, Some(team_key))
+        .map_err(|error| LifecycleError::TeamSelect(error.to_string()))?;
+    let Some(agent) = state
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(agent_id.as_str()))
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return Ok(());
+    };
+    agent.insert(
+        "session_id".to_string(),
+        serde_json::json!(session_id.as_str()),
+    );
+    agent.insert(
+        "rollout_path".to_string(),
+        serde_json::json!(backing_path.to_string_lossy().to_string()),
+    );
+    agent.insert("captured_via".to_string(), serde_json::json!("clone-agent"));
+    crate::lifecycle::launch::save_launched_team_state_for_key(
+        workspace,
+        &state,
+        Some(team_key),
+        Some(agent_id.as_str()),
+    )
+}

package/crates/team-agent/src/lifecycle/launch/cursor_create_chat.rs

@@ -0,0 +1,229 @@
+//! ---
+//! purpose: cursor 候选 A——`agent create-chat` 解析首行 chatId 后按记录 PID 杀
+//! contract:
+//!   provides:
+//!     - name: apply_cursor_create_chat_plan
+//!       what: 无 pending 时把 CLI chatId 写入 expected_session_id 并 `--resume` 该 id
+//!     - name: create_cursor_chat_id
+//!       what: 跑 create-chat，读第一行 UUID，只杀本调用记录的 PID
+//!   requires:
+//!     - name: cursor-agent-cli
+//!       what: PATH 上的 `agent`；不存在或首行非法则返回 None（降级候选 B）
+//! boundary:
+//!   - 不发明 --session-id；不 pkill/killall；不 wait 子进程自行退出
+//!   - 不读 chats 正文、不打印 proxy 值
+//!   - 已有 expected_session_id 或 argv 已含 --resume 则不动
+//!   - 2026-08-21 活体：create-chat 后 `--resume` 的存档在 pane stop 后被清；
+//!     TUI 自建会话能留盘。fresh 路径不调用本函数（走 scan 唯一 hex）。
+//! maturity: wired
+//! ---
+
+use std::io::{BufRead, BufReader};
+use std::path::Path;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+use std::thread;
+use std::time::Duration;
+
+use crate::provider::types::{CommandPlan, SessionId};
+
+const FIRST_LINE_TIMEOUT: Duration = Duration::from_secs(5);
+const TERM_GRACE: Duration = Duration::from_millis(200);
+
+/// ---
+/// purpose: 冷启/无 session 的 cursor 计划绑定 create-chat 得到的 chatId
+/// params:
+///   plan: build_command_plan 产出；workspace: 物理 cwd
+/// returns: 成功则 expected_session_id 与 argv `--resume <id>` 齐；失败则计划不变
+/// contract:
+///   provides:
+///     - name: apply_cursor_create_chat_plan
+///       what: 只在无 pending 且 argv 无 --resume 时写入 CLI chatId
+/// boundary:
+///   - 库测试（cfg(test)）不调真实 agent，避免订阅/挂起；具名测试打 create_cursor_chat_id
+///   - 不在 launch/restart fresh 调用：活体证实 `--resume` 空聊存档停 pane 后消失
+/// ---
+pub(crate) fn apply_cursor_create_chat_plan(plan: &mut CommandPlan, workspace: &Path) {
+    if cfg!(test) {
+        return;
+    }
+    if plan.expected_session_id.is_some() {
+        return;
+    }
+    if plan.argv.iter().any(|flag| flag == "--resume") {
+        return;
+    }
+    let Some(chat_id) = create_cursor_chat_id(workspace) else {
+        return;
+    };
+    plan.expected_session_id = Some(SessionId::new(chat_id.clone()));
+    plan.argv.push("--resume".to_string());
+    plan.argv.push(chat_id);
+}
+
+/// ---
+/// purpose: 跑 `agent create-chat`，解析首行 UUID，按记录 PID 终止挂起进程
+/// params:
+///   workspace: create-chat 的 cwd（物理 workspace）
+/// returns: 合法 UUID；命令缺失/超时/非法首行则 None
+/// contract:
+///   provides:
+///     - name: create_cursor_chat_id
+///       what: 读一行就停；不 wait 退出；只杀本 Child.id()
+/// boundary:
+///   - 禁 pkill/killall；pid 0/1 不杀
+/// ---
+pub(crate) fn create_cursor_chat_id(workspace: &Path) -> Option<String> {
+    create_cursor_chat_id_with_command("agent", workspace)
+}
+
+fn create_cursor_chat_id_with_command(program: &str, workspace: &Path) -> Option<String> {
+    let mut child = Command::new(program)
+        .arg("create-chat")
+        .current_dir(workspace)
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .ok()?;
+    let pid = child.id();
+    let stdout = child.stdout.take()?;
+    let (tx, rx) = mpsc::channel();
+    thread::spawn(move || {
+        let mut reader = BufReader::new(stdout);
+        let mut line = String::new();
+        let result = reader.read_line(&mut line).ok().and_then(|_| parse_chat_id_line(&line));
+        let _ = tx.send(result);
+    });
+    let parsed = match rx.recv_timeout(FIRST_LINE_TIMEOUT) {
+        Ok(value) => value,
+        Err(_) => None,
+    };
+    kill_recorded_pid(pid);
+    let _ = child.wait();
+    parsed
+}
+
+fn parse_chat_id_line(line: &str) -> Option<String> {
+    let token = line
+        .trim()
+        .split_whitespace()
+        .next()
+        .unwrap_or("")
+        .trim_matches(['"', '\'']);
+    is_chat_uuid(token).then(|| token.to_string())
+}
+
+fn is_chat_uuid(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    if bytes.len() != 36 {
+        return false;
+    }
+    for (i, b) in bytes.iter().enumerate() {
+        if i == 8 || i == 13 || i == 18 || i == 23 {
+            if *b != b'-' {
+                return false;
+            }
+        } else if !b.is_ascii_hexdigit() {
+            return false;
+        }
+    }
+    true
+}
+
+fn kill_recorded_pid(pid: u32) {
+    if pid == 0 || pid == 1 {
+        return;
+    }
+    #[cfg(unix)]
+    {
+        let raw = pid as i32;
+        unsafe {
+            libc::kill(raw, libc::SIGTERM);
+        }
+        thread::sleep(TERM_GRACE);
+        unsafe {
+            libc::kill(raw, libc::SIGKILL);
+        }
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = pid;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+
+    use super::*;
+    use std::os::unix::fs::PermissionsExt;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    fn tmp_root(tag: &str) -> std::path::PathBuf {
+        static CTR: AtomicU64 = AtomicU64::new(0);
+        let dir = std::env::temp_dir().join(format!(
+            "ta-d117-create-chat-{}-{}-{}",
+            tag,
+            std::process::id(),
+            CTR.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn write_stub(dir: &Path, body: &str) -> std::path::PathBuf {
+        let path = dir.join("agent");
+        std::fs::write(&path, body).unwrap();
+        let mut perm = std::fs::metadata(&path).unwrap().permissions();
+        perm.set_mode(0o755);
+        std::fs::set_permissions(&path, perm).unwrap();
+        path
+    }
+
+    #[test]
+    fn create_chat_reads_first_line_and_kills_recorded_pid() {
+        let base = tmp_root("ok");
+        let ws = base.join("ws");
+        std::fs::create_dir_all(&ws).unwrap();
+        let bin = write_stub(
+            &base,
+            "#!/bin/sh\necho '681c8837-d564-44fa-98bf-4ff5a66592e2'\nkill -STOP $$\n",
+        );
+        let got = create_cursor_chat_id_with_command(bin.to_str().unwrap(), &ws);
+        assert_eq!(
+            got.as_deref(),
+            Some("681c8837-d564-44fa-98bf-4ff5a66592e2")
+        );
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn create_chat_rejects_non_uuid_first_line() {
+        let base = tmp_root("bad");
+        let ws = base.join("ws");
+        std::fs::create_dir_all(&ws).unwrap();
+        let bin = write_stub(&base, "#!/bin/sh\necho not-a-uuid\nkill -STOP $$\n");
+        let got = create_cursor_chat_id_with_command(bin.to_str().unwrap(), &ws);
+        assert!(got.is_none());
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn apply_is_noop_when_resume_already_present() {
+        let mut plan = CommandPlan {
+            argv: vec![
+                "agent".into(),
+                "--resume".into(),
+                "already-bound".into(),
+            ],
+            expected_session_id: None,
+            provider_projects_root: None,
+            managed_mcp_config: false,
+        };
+        apply_cursor_create_chat_plan(&mut plan, Path::new("/tmp"));
+        assert!(plan.expected_session_id.is_none());
+        assert_eq!(plan.argv.iter().filter(|a| *a == "--resume").count(), 1);
+    }
+}