@team-agent/installer 0.3.7 → 0.3.8

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.7"
+version = "0.3.8"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -133,13 +133,33 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         }
         Ok(result)
     } else {
-        Ok(CmdResult::human(
-            value
-                .get("summary")
-                .and_then(Value::as_str)
-                .unwrap_or("quick-start complete"),
-        ))
+        // E13:happy 人类路径必须带 attach_commands(json 路径 cli/mod.rs:1775 已有)。
+        Ok(CmdResult::human(&quickstart_human(&value)))
+    }
+}
+
+/// E13:quick-start "team 起了" 人类输出 = summary + attach 块。所有成功出口共用(别每分支手拷)。
+/// attach_commands 缺/空 → 只 summary(向后兼容)。
+fn quickstart_human(value: &Value) -> String {
+    let summary = value
+        .get("summary")
+        .and_then(Value::as_str)
+        .unwrap_or("quick-start complete");
+    let attach: Vec<&str> = value
+        .get("attach_commands")
+        .and_then(Value::as_array)
+        .map(|items| items.iter().filter_map(Value::as_str).collect())
+        .unwrap_or_default();
+    if attach.is_empty() {
+        return summary.to_string();
+    }
+    let mut out = String::from(summary);
+    out.push_str("\n\nattach:");
+    for cmd in attach {
+        out.push_str("\n  ");
+        out.push_str(cmd);
     }
+    out
 }
 
 /// `cmd_compile`(`commands.py:42`)。
@@ -1522,9 +1542,34 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
 mod tests {
     #![allow(clippy::unwrap_used)]
 
-    use super::agent_pane_id;
+    use super::{agent_pane_id, quickstart_human};
     use serde_json::json;
 
+    // E13:happy 人类输出必须带 attach 块(此前 else 分支只打 summary 丢 attach_commands)。
+    #[test]
+    fn e13_quickstart_human_includes_attach_commands() {
+        let value = json!({
+            "summary": "team started",
+            "attach_commands": [
+                "tmux -S /tmp/ta-x attach -t team-y:w1",
+                "tmux -S /tmp/ta-x attach -t team-y:w2",
+            ],
+        });
+        let out = quickstart_human(&value);
+        assert!(out.contains("team started"), "must keep summary; got {out}");
+        assert!(out.contains("attach:"), "must render attach block; got {out}");
+        assert!(out.contains("team-y:w1") && out.contains("team-y:w2"), "must list each attach cmd; got {out}");
+    }
+
+    #[test]
+    fn e13_quickstart_human_summary_only_when_no_attach() {
+        let value = json!({"summary": "quick-start complete"});
+        assert_eq!(quickstart_human(&value), "quick-start complete");
+        // 空数组也只 summary。
+        let value2 = json!({"summary": "s", "attach_commands": []});
+        assert_eq!(quickstart_human(&value2), "s");
+    }
+
     #[test]
     fn agent_pane_id_resolves_session_window_even_with_recorded_pane_id() {
         let state = json!({

package/crates/team-agent/src/cli/emit.rs

@@ -108,6 +108,7 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "watch" => cmd_watch(&watch_args(args, cwd)).map(emit_result),
         "sessions" => cmd_sessions(&sessions_args(args, cwd)).map(emit_result),
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
+        "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
         "validate-result" if has_arg(args, "--result") => {
             eprintln!("team-agent: error: unrecognized arguments: --result");
@@ -160,6 +161,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "watch",
     "sessions",
     "validate",
+    "install-skill",
     "profile",
     "validate-result",
     "collect",
@@ -230,6 +232,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("watch") => "usage: team-agent watch [--workspace WORKSPACE] [--team TEAM]".to_string(),
         Some("sessions") => "usage: team-agent sessions [--workspace WORKSPACE] [--json]".to_string(),
         Some("validate") => "usage: team-agent validate [SPEC] [--json]".to_string(),
+        Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]".to_string(),
         Some("validate-result") => "usage: team-agent validate-result [ENVELOPE] [--file FILE|--result JSON] [--json]".to_string(),
         Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
@@ -298,6 +301,115 @@ fn emit_usage_error(message: &str) {
 }
 
 /// `cmd_validate` delegates to runtime validate_file.
+/// `install-skill` 参数(RED-1 根治:把 skill 安装单源收敛到二进制,install.mjs 调它)。
+struct InstallSkillArgs {
+    target: crate::packaging::SkillTarget,
+    dest: Option<PathBuf>,
+    dry_run: bool,
+    /// `--uninstall`:删 target 的 skill 目标目录(单源,走同一 SkillTarget 表),不需 --source。
+    uninstall: bool,
+    source: Option<PathBuf>,
+    json: bool,
+}
+
+fn install_skill_args(args: &[String]) -> Result<InstallSkillArgs, CliError> {
+    let parsed = parse_args(args);
+    // `--target` 复用 parse_args.targets(codex|claude|copilot|all,默认 all)。
+    let target = match parsed.targets.as_deref() {
+        None | Some("all") => crate::packaging::SkillTarget::All,
+        Some("codex") => crate::packaging::SkillTarget::Codex,
+        Some("claude") => crate::packaging::SkillTarget::Claude,
+        Some("copilot") => crate::packaging::SkillTarget::Copilot,
+        Some(other) => {
+            return Err(CliError::Usage(format!(
+                "invalid --target: {other} (choose from codex, claude, copilot, all)"
+            )))
+        }
+    };
+    let uninstall = args.iter().any(|a| a == "--uninstall");
+    // `--source <dir>` 安装时必需(npm 包的 skills/team-agent;运行期无 CARGO_MANIFEST_DIR);
+    // 卸载不需要。
+    let source = flag_value(args, "--source").map(PathBuf::from);
+    if !uninstall && source.is_none() {
+        return Err(CliError::Usage("missing --source <skill dir>".to_string()));
+    }
+    let dest = flag_value(args, "--dest").map(PathBuf::from);
+    let dry_run = args.iter().any(|a| a == "--dry-run");
+    Ok(InstallSkillArgs {
+        target,
+        dest,
+        dry_run,
+        uninstall,
+        source,
+        json: parsed.json,
+    })
+}
+
+/// 取 `--flag <value>` 的值(用于 install-skill 的 --source/--dest,parse_args 不覆盖的旗标)。
+fn flag_value(args: &[String], flag: &str) -> Option<String> {
+    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).cloned())
+}
+
+/// `team-agent install-skill`(RED-1 单源):repo `skills/team-agent` → `~/.codex|.claude|.copilot`。
+/// install.mjs 删 JS 拷贝逻辑、改调本命令(`--target all --source <pkg>/skills/team-agent`)。
+fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
+    // 卸载分支(单源:走同一 SkillTarget 表的 dest_dir;all → SINGLE_TARGETS 全集)。
+    if args.uninstall {
+        let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("."));
+        let targets: Vec<crate::packaging::SkillTarget> = match args.target {
+            crate::packaging::SkillTarget::All => {
+                crate::packaging::SkillTarget::SINGLE_TARGETS.to_vec()
+            }
+            t => vec![t],
+        };
+        let mut removed: Vec<serde_json::Value> = Vec::new();
+        for t in targets {
+            if let Some(dest) = t.dest_dir(&home) {
+                let existed = dest.0.exists();
+                if existed && !args.dry_run {
+                    std::fs::remove_dir_all(&dest.0).map_err(|e| CliError::Runtime(e.to_string()))?;
+                }
+                removed.push(serde_json::json!({
+                    "target": t,
+                    "dest": dest.0.to_string_lossy(),
+                    "removed": existed,
+                    "dry_run": args.dry_run,
+                }));
+            }
+        }
+        return Ok(CmdResult::from_json(
+            serde_json::json!({"ok": true, "uninstalled": removed}),
+            args.json,
+        ));
+    }
+    let source = args
+        .source
+        .clone()
+        .ok_or_else(|| CliError::Usage("missing --source <skill dir>".to_string()))?;
+    let outcomes = crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
+        target: args.target,
+        dest: args.dest.clone(),
+        dry_run: args.dry_run,
+        source,
+    })
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let installed: Vec<serde_json::Value> = outcomes
+        .iter()
+        .map(|o| {
+            serde_json::json!({
+                "target": o.target,
+                "dest": o.dest.0.to_string_lossy(),
+                "dry_run": o.dry_run,
+                "removed_stale": o.removed_stale.len(),
+            })
+        })
+        .collect();
+    Ok(CmdResult::from_json(
+        serde_json::json!({"ok": true, "installed": installed}),
+        args.json,
+    ))
+}
+
 pub fn cmd_validate(args: &ValidateArgs) -> Result<CmdResult, CliError> {
     let spec = resolve_path(&args.spec);
     let value = if spec.is_dir() {

package/crates/team-agent/src/cli/mod.rs

@@ -168,6 +168,7 @@ pub mod lifecycle_port {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
+        let state_for_kill = state.clone();
         let transport = if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
             crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
         } else {
@@ -176,17 +177,33 @@ pub mod lifecycle_port {
         let result =
             shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state));
         if team.is_none() {
-            // B5/F1: the leader terminal (`team-agent claude`) lives on this same
-            // workspace socket by design (leader/start.rs); a bare shutdown must not
-            // `kill-server` it away. Spare `team-agent-leader-*` sessions and clear the
-            // remaining non-leader sessions individually; only an empty-of-leader socket
-            // gets the whole-server teardown (the original leak-cleanup intent).
+            // E12 (P0): the leader terminal lives on this socket by design. A bare shutdown must
+            // NOT `kill-server` it away. spare = state-anchor sessions ∪ `team-agent-leader-*`
+            // prefix sessions (union; cr E12 ①). kill_server only when the socket is exclusively
+            // ours (no spare + no foreign session); shared socket → kill our sessions individually
+            // (cr E12 ②). All spare derivation comes from ONE snapshot (list_targets + the state
+            // already loaded) — no independent ps/tmux re-derivation (N39).
             let transport_dyn: &dyn crate::transport::Transport = &transport;
+            let pane_targets = transport_dyn.list_targets().unwrap_or_default();
             let sessions = socket_session_names(transport_dyn);
-            match sessions_to_kill_sparing_leader(&sessions) {
-                None => transport.kill_server(),
-                Some(non_leader_sessions) => {
-                    for session in &non_leader_sessions {
+            let event_log = crate::event_log::EventLog::new(&run_ws);
+            let anchor_sessions =
+                anchor_sessions_from_state(&state_for_kill, &pane_targets, &event_log);
+            let decision = sessions_to_kill(&sessions, &anchor_sessions);
+            match decision {
+                KillDecision::KillServerExclusive => transport.kill_server(),
+                KillDecision::KillIndividually { to_kill, spared } => {
+                    if !spared.is_empty() || to_kill.len() != sessions.len() {
+                        // shared socket / leader spared → never whole-server teardown.
+                        let _ = event_log.write(
+                            "shutdown.kill_server_skipped_shared_socket",
+                            json!({
+                                "spared_sessions": spared.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                                "killed_sessions": to_kill.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                            }),
+                        );
+                    }
+                    for session in &to_kill {
                         let _ = transport_dyn.kill_session(session);
                     }
                 }
@@ -195,6 +212,29 @@ pub mod lifecycle_port {
         result
     }
 
+    /// E12 ①:从 state 锚 pane_id(leader_receiver/team_owner,top+teams)映射到其所在 session
+    /// (经同一帧 list_targets pane→session)。state 无任何锚 → 退命名判据 + spare_fallback event。
+    fn anchor_sessions_from_state(
+        state: &Value,
+        pane_targets: &[crate::transport::PaneInfo],
+        event_log: &crate::event_log::EventLog,
+    ) -> std::collections::BTreeSet<String> {
+        let anchor_pane_ids = collect_state_leader_anchor_pane_ids(state);
+        if anchor_pane_ids.is_empty() {
+            // 无锚(state 损坏/未记)→ 退纯命名前缀判据(下游 sessions_to_kill 仍 spare 前缀)。
+            let _ = event_log.write(
+                "shutdown.spare_fallback_to_naming",
+                json!({"reason": "no leader_receiver/team_owner pane anchor in state"}),
+            );
+            return std::collections::BTreeSet::new();
+        }
+        pane_targets
+            .iter()
+            .filter(|pane| anchor_pane_ids.contains(pane.pane_id.as_str()))
+            .map(|pane| pane.session.as_str().to_string())
+            .collect()
+    }
+
     fn socket_session_names(
         transport: &dyn crate::transport::Transport,
     ) -> Vec<crate::transport::SessionName> {
@@ -208,26 +248,37 @@ pub mod lifecycle_port {
             .collect()
     }
 
-    /// B5/F1 pure kill decision for the bare-shutdown socket teardown.
-    /// `None` => no `team-agent-leader-*` session on the socket → safe to kill the whole
-    /// server. `Some(rest)` => leader present → kill only the non-leader sessions.
-    pub(crate) fn sessions_to_kill_sparing_leader(
+    /// E12 下沉纯函数:bare-shutdown socket 拆除决策。
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub(crate) enum KillDecision {
+        /// socket 独享(无 spare、无外来 session)→ 可整 server 拆除。
+        KillServerExclusive,
+        /// 有 spare(leader 锚/前缀)或非独享 → 逐 session kill,绝不 kill-server。
+        KillIndividually {
+            to_kill: Vec<crate::transport::SessionName>,
+            spared: Vec<crate::transport::SessionName>,
+        },
+    }
+
+    /// E12 纯决策(单测下沉):spare = `anchor_sessions` ∪ `team-agent-leader-*` 前缀(并集,锚优先)。
+    /// 全部 session 都不 spare 且非空 → `KillServerExclusive`(独享 socket 兜底);否则逐 session
+    /// kill 非 spare 的(共享 socket / leader 在 → 绝不整 server 拆)。空 session 集 → 逐 kill(no-op)。
+    pub(crate) fn sessions_to_kill(
         sessions: &[crate::transport::SessionName],
-    ) -> Option<Vec<crate::transport::SessionName>> {
-        let leader_present = sessions
-            .iter()
-            .any(|session| session.as_str().starts_with(crate::leader::LEADER_SESSION_PREFIX));
-        leader_present.then(|| {
-            sessions
-                .iter()
-                .filter(|session| {
-                    !session
-                        .as_str()
-                        .starts_with(crate::leader::LEADER_SESSION_PREFIX)
-                })
-                .cloned()
-                .collect()
-        })
+        anchor_sessions: &std::collections::BTreeSet<String>,
+    ) -> KillDecision {
+        let is_spared = |s: &crate::transport::SessionName| {
+            s.as_str().starts_with(crate::leader::LEADER_SESSION_PREFIX)
+                || anchor_sessions.contains(s.as_str())
+        };
+        let spared: Vec<_> = sessions.iter().filter(|s| is_spared(s)).cloned().collect();
+        let to_kill: Vec<_> = sessions.iter().filter(|s| !is_spared(s)).cloned().collect();
+        // 独享 = 非空 + 无 spare(socket 上每个 session 都是要 kill 的我方 session)。
+        if spared.is_empty() && !sessions.is_empty() {
+            KillDecision::KillServerExclusive
+        } else {
+            KillDecision::KillIndividually { to_kill, spared }
+        }
     }
 
     pub fn shutdown_with_transport(
@@ -1782,6 +1833,7 @@ pub mod lifecycle_port {
                 session_name,
                 state_path,
                 next_actions,
+                attach_commands,
             } => json!({
                 "ok": false,
                 "summary": "existing runtime",
@@ -1789,20 +1841,61 @@ pub mod lifecycle_port {
                 "session_name": session_name.map(|s| s.as_str().to_string()),
                 "state_path": state_path.map(|p| p.to_string_lossy().to_string()),
                 "next_actions": next_actions,
+                "attach_commands": attach_commands,
             }),
             crate::lifecycle::QuickStartReport::PreflightBlocked {
                 summary,
                 blockers,
                 next_actions,
+                attach_commands,
             } => json!({
                 "ok": false,
                 "summary": summary,
                 "blockers": blockers,
                 "next_actions": next_actions,
+                "attach_commands": attach_commands,
             }),
         }
     }
 
+    #[cfg(test)]
+    mod quick_start_value_tests {
+        use super::*;
+
+        #[test]
+        fn existing_runtime_json_includes_attach_commands() {
+            let value = quick_start_value(crate::lifecycle::QuickStartReport::ExistingRuntime {
+                team: Some("teamA".to_string()),
+                session_name: Some(crate::transport::SessionName::new("team-teamA")),
+                state_path: Some(PathBuf::from("/tmp/state.json")),
+                next_actions: vec!["restart".to_string()],
+                attach_commands: vec![
+                    "tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker".to_string(),
+                ],
+            });
+            assert_eq!(
+                value.pointer("/attach_commands/0").and_then(Value::as_str),
+                Some("tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker"),
+                "B-2: ExistingRuntime JSON must preserve attach_commands instead of only next_actions; value={value}"
+            );
+        }
+
+        #[test]
+        fn preflight_blocked_json_includes_empty_attach_commands() {
+            let value = quick_start_value(crate::lifecycle::QuickStartReport::PreflightBlocked {
+                summary: "blocked".to_string(),
+                blockers: vec!["missing TEAM.md".to_string()],
+                next_actions: vec!["fix preflight blockers".to_string()],
+                attach_commands: Vec::new(),
+            });
+            assert_eq!(
+                value.get("attach_commands").and_then(Value::as_array).map(Vec::len),
+                Some(0),
+                "B-2: PreflightBlocked JSON must include attach_commands: [] for schema parity with Ready/Restart; value={value}"
+            );
+        }
+    }
+
     fn restart_value(report: crate::lifecycle::RestartReport) -> Value {
         match report {
             crate::lifecycle::RestartReport::Restarted {

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

@@ -1,4 +1,41 @@
 use super::*;
+use serial_test::serial;
+
+struct EnvUnsetGuard {
+    previous: Vec<(&'static str, Option<String>)>,
+}
+
+impl EnvUnsetGuard {
+    fn unset(keys: &[&'static str]) -> Self {
+        let previous = keys
+            .iter()
+            .map(|key| (*key, std::env::var(key).ok()))
+            .collect::<Vec<_>>();
+        for key in keys {
+            std::env::remove_var(key);
+        }
+        Self { previous }
+    }
+}
+
+impl Drop for EnvUnsetGuard {
+    fn drop(&mut self) {
+        for (key, value) in self.previous.drain(..).rev() {
+            match value {
+                Some(value) => std::env::set_var(key, value),
+                None => std::env::remove_var(key),
+            }
+        }
+    }
+}
+
+struct WorkspaceCleanup(std::path::PathBuf);
+
+impl Drop for WorkspaceCleanup {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
 
     // =========================================================================
     // WAVE-2 NON-SUB CHECKPOINT — 9 MISSING CLI subcommands (ABSENT from cli/emit.rs dispatch).
@@ -131,6 +168,36 @@ tasks:
         std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
     }
 
+    fn seed_collect_runtime_state(ws: &std::path::Path) {
+        crate::state::persist::save_runtime_state(
+            ws,
+            &json!({
+                "active_team_key": "fake-e2e",
+                "team_dir": ws.to_string_lossy().to_string(),
+                "spec_path": ws.join("team.spec.yaml").to_string_lossy().to_string(),
+                "session_name": "team-agent-fake-e2e",
+                "leader": {"id": "leader"},
+                "agents": {
+                    "fake_impl": {
+                        "status": "running",
+                        "provider": "fake",
+                        "role": "implementation_engineer",
+                        "window": "fake_impl",
+                        "owner_team_id": "fake-e2e"
+                    }
+                },
+                "tasks": [{
+                    "id": "task_impl",
+                    "title": "Fake implementation",
+                    "type": "implementation",
+                    "status": "pending",
+                    "assignee": "fake_impl"
+                }]
+            }),
+        )
+        .unwrap();
+    }
+
     // ── sessions ── golden cli/parser.py:230 `cmd_sessions` -> runtime.sessions(ws). EXIT 0.
     // `team-agent sessions --workspace <ws> --json` on an empty ws ->
     //   {"ok":true,"sessions":[],"workspace":"<ws>"}  (--json sort_keys). RED: unrouted -> Error.
@@ -169,9 +236,25 @@ tasks:
     //    "delivered_messages":[],"invalid_results":[],"ok":true,"results":{...},"state_file":"<ws>/team_state.md"}
     // RED: unrouted -> Error.
     #[test]
+    #[serial(env)]
     fn dispatch_routes_collect_with_spec() {
+        let _env = EnvUnsetGuard::unset(&[
+            "TEAM_AGENT_WORKSPACE",
+            "TEAM_AGENT_TEAM_ID",
+            "TEAM_AGENT_OWNER_TEAM_ID",
+            "TEAM_AGENT_ACTIVE_TEAM",
+            "TEAM_AGENT_ID",
+            "TEAM_AGENT_LEADER_PANE_ID",
+            "TEAM_AGENT_LEADER_SESSION_UUID",
+            "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+            "TEAM_AGENT_LEADER_PROVIDER",
+            "TMUX",
+            "TMUX_PANE",
+        ]);
         let ws = tmp_workspace();
+        let _cleanup = WorkspaceCleanup(ws.clone());
         seed_team_spec(&ws);
+        seed_collect_runtime_state(&ws);
         let code = run(&cli_argv(&["collect", "--workspace", &ws.to_string_lossy(), "--json"]), &ws);
         assert_eq!(
             code,
@@ -180,7 +263,6 @@ tasks:
              {{collected,collected_results,coordinator,delivered_messages,invalid_results,ok,results,state_file}}; \
              today -> unknown-subcommand Error"
         );
-        let _ = std::fs::remove_dir_all(&ws);
     }
 
     // ── repair-state ── golden parser.py:303 `cmd_repair_state` -> runtime.repair_state (quick_start.py:285).

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

@@ -94,5 +94,6 @@ mod status_send;
 mod verb_validate;
 mod verb_settle;
 mod verb_profile;
+mod verb_install_skill;
 mod main_preserved;
 mod shutdown_kill_plan;