@team-agent/installer 0.3.37 → 0.3.39

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -41,6 +41,10 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
         println!("{}", command_help(None));
         return ExitCode::Ok;
     }
+    if matches!(command, "-V" | "--version") {
+        println!("team-agent {}", env!("CARGO_PKG_VERSION"));
+        return ExitCode::Ok;
+    }
     // CR-063/G4: every registered subcommand's `--help` must short-circuit before dispatch,
     // before argument validation, leader-pane checks, or runtime-state writes.
     //

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

@@ -2805,6 +2805,7 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     let workspace = workspace.to_path_buf();
     let mut spec = crate::compiler::compile_team(agents_dir)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
+    override_spec_workspace(&mut spec, &workspace);
     if !open_display {
         override_spec_display_backend(&mut spec, "none");
     }
@@ -3548,6 +3549,7 @@ fn add_agent_with_transport_at_paths(
     // 就地读外部 role 文档编译,注入 base team spec 的 agents/routing。role 文件留在原处。
     let mut spec = crate::compiler::compile_team(team_dir)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
+    override_spec_workspace(&mut spec, run_workspace);
     let workspace_s = spec
         .get("team")
         .and_then(|team| team.get("workspace"))
@@ -4724,6 +4726,25 @@ pub(crate) fn override_spec_session_name(spec: &mut Value, session_name: &str) {
     override_spec_runtime_str(spec, "session_name", session_name);
 }
 
+pub(crate) fn override_spec_workspace(spec: &mut Value, workspace: &Path) {
+    let workspace_s = workspace.to_string_lossy().to_string();
+    let Value::Map(root) = spec else { return };
+    if let Some((_, Value::Map(team))) = root.iter_mut().find(|(k, _)| k == "team") {
+        if let Some((_, value)) = team.iter_mut().find(|(k, _)| k == "workspace") {
+            *value = Value::Str(workspace_s.clone());
+        }
+    }
+    if let Some((_, Value::List(agents))) = root.iter_mut().find(|(k, _)| k == "agents") {
+        for agent in agents {
+            if let Value::Map(fields) = agent {
+                if let Some((_, value)) = fields.iter_mut().find(|(k, _)| k == "working_directory") {
+                    *value = Value::Str(workspace_s.clone());
+                }
+            }
+        }
+    }
+}
+
 fn override_spec_display_backend(spec: &mut Value, display_backend: &str) {
     override_spec_runtime_str(spec, "display_backend", display_backend);
 }

package/crates/team-agent/src/lifecycle/restart/agent.rs

@@ -621,6 +621,10 @@ fn mark_agent_started(
         "spawned_at".to_string(),
         serde_json::json!(chrono::Utc::now().to_rfc3339()),
     );
+    agent.insert(
+        "spawn_cwd".to_string(),
+        serde_json::json!(spawn.spawn_cwd.to_string_lossy().to_string()),
+    );
     crate::lifecycle::launch::persist_command_plan_state(
         agent,
         &spawn.plan,

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -5,6 +5,7 @@ pub(super) struct SpawnedAgentWindow {
     pub plan: crate::provider::CommandPlan,
     pub profile_launch: crate::provider::ProviderProfileLaunch,
     pub layout_placement: Option<crate::lifecycle::launch::LayoutPlacement>,
+    pub spawn_cwd: std::path::PathBuf,
 }
 
 pub(super) fn spawn_agent_window(
@@ -238,6 +239,7 @@ pub(super) fn spawn_agent_window(
         plan,
         profile_launch,
         layout_placement: layout_placement.cloned(),
+        spawn_cwd: spawn_cwd.to_path_buf(),
     })
 }
 

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -309,7 +309,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             transport,
             Some(&safety),
             layout_placement.as_ref(),
-            Some(spec_workspace),
+            None,
         ) {
             Ok(spawn) => spawn,
             Err(error) => {
@@ -935,6 +935,10 @@ fn mark_agent_respawned(
         "spawned_at".to_string(),
         serde_json::json!(chrono::Utc::now().to_rfc3339()),
     );
+    agent.insert(
+        "spawn_cwd".to_string(),
+        serde_json::json!(spawn.spawn_cwd.to_string_lossy().to_string()),
+    );
     if matches!(
         restart_mode,
         StartMode::Fresh | StartMode::FreshAfterMissingRollout
@@ -1382,6 +1386,7 @@ fn rebuild_runtime_spec_from_roles(
     // 重建:compile_team(角色定义) + 保留运行期 session_name override。
     let mut spec = crate::compiler::compile_team(&team_dir)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
+    crate::lifecycle::launch::override_spec_workspace(&mut spec, run_workspace);
     if let Some(session_name) = state
         .get("session_name")
         .and_then(serde_json::Value::as_str)
@@ -1589,6 +1594,7 @@ mod tests {
             plan: crate::provider::CommandPlan::argv_only(vec!["codex".to_string()]),
             profile_launch: crate::provider::ProviderProfileLaunch::default(),
             layout_placement: None,
+            spawn_cwd: std::path::PathBuf::from("/tmp/team-epoch"),
         };
         let before = chrono::Utc::now();
 

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -225,6 +225,60 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
     );
 }
 
+#[test]
+fn quick_start_default_workspace_compiled_spec_uses_project_root() {
+    let workspace = temp_ws();
+    std::fs::create_dir_all(workspace.join("agents")).unwrap();
+    std::fs::write(workspace.join("TEAM.md"), QS_TEAM_MD).unwrap();
+    std::fs::write(workspace.join("agents").join("implementer.md"), QS_VALID_ROLE).unwrap();
+    seed_healthy_coordinator(&workspace);
+    let transport = OfflineTransport::new();
+
+    let report = quick_start_with_transport_in_workspace(
+        &workspace,
+        &workspace,
+        None,
+        true,
+        true,
+        None,
+        &transport,
+    )
+    .expect("quick-start workspace-root team should reach a report");
+    assert!(
+        matches!(report, QuickStartReport::Ready { .. }),
+        "quick-start failed: {report:?}"
+    );
+
+    let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+    let spec_path = state
+        .get("spec_path")
+        .and_then(serde_json::Value::as_str)
+        .map(PathBuf::from)
+        .expect("quick-start state should carry spec_path");
+    let spec = crate::model::yaml::loads(&std::fs::read_to_string(spec_path).unwrap()).unwrap();
+    assert_eq!(
+        spec.get("team")
+            .and_then(|team| team.get("workspace"))
+            .and_then(crate::model::yaml::Value::as_str),
+        Some(workspace.to_string_lossy().as_ref()),
+        "compiled team.workspace must be the project root, not its parent"
+    );
+    for agent in spec.get("agents").and_then(crate::model::yaml::Value::as_list).unwrap() {
+        assert_eq!(
+            agent
+                .get("working_directory")
+                .and_then(crate::model::yaml::Value::as_str),
+            Some(workspace.to_string_lossy().as_ref()),
+            "compiled agent working_directory must be the project root"
+        );
+    }
+    assert_eq!(
+        transport.spawn_cwd_records(),
+        vec![workspace],
+        "quick-start must spawn workers from the project root"
+    );
+}
+
 // P0 — quick_start over an INVALID role doc (missing `provider`) must surface the REAL compile
 // error, distinct from the stub's hardcoded "no role docs found". Golden: compile_team raises
 // "missing front matter field provider" (compiler.py:_validate_role_doc), before preflight.
@@ -1533,6 +1587,91 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
     );
 }
 
+#[test]
+fn restart_runtime_spec_spawns_from_run_workspace_not_runtime_dir() {
+    let workspace = temp_ws();
+    std::fs::create_dir_all(workspace.join("agents")).unwrap();
+    let rollout = workspace.join("alpha-rollout.jsonl");
+    std::fs::write(&rollout, "{}\n").unwrap();
+    std::fs::write(
+        workspace.join("TEAM.md"),
+        "---\nname: current\nobjective: Restart cwd probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(workspace.join("agents").join("alpha.md"), DELEG_ROLE_ALPHA).unwrap();
+    let spec = crate::compiler::compile_team(&workspace).expect("compile project-root team");
+    let spec_path = crate::model::paths::runtime_spec_path(&workspace, "current");
+    std::fs::create_dir_all(spec_path.parent().unwrap()).unwrap();
+    std::fs::write(&spec_path, crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &workspace,
+        &json!({
+            "active_team_key": "current",
+            "session_name": "team-current",
+            "spec_path": spec_path.to_string_lossy(),
+            "team_dir": workspace.to_string_lossy(),
+            "agents": {
+                "alpha": {
+                    "status": "running",
+                    "provider": "codex",
+                    "session_id": "sess-a",
+                    "rollout_path": rollout.to_string_lossy(),
+                    "first_send_at": "2026-05-27T10:00:00+00:00",
+                    "spawn_cwd": null
+                }
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&workspace);
+    let transport = OfflineTransport::new();
+
+    let result = restart_with_transport(&workspace, false, Some("current"), &transport);
+
+    assert!(
+        matches!(result, Ok(RestartReport::Restarted { .. })),
+        "restart should succeed for a resumable project-root team: {result:?}"
+    );
+    assert_eq!(
+        transport.spawn_cwd_records(),
+        vec![workspace.clone()],
+        "restart must spawn from run_workspace, not .team/runtime/<team>"
+    );
+    let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+    assert_eq!(
+        state
+            .get("agents")
+            .and_then(|agents| agents.get("alpha"))
+            .and_then(|agent| agent.get("spawn_cwd"))
+            .and_then(serde_json::Value::as_str),
+        Some(workspace.to_string_lossy().as_ref()),
+        "restart must persist the actual spawn cwd for later diagnostics"
+    );
+    let rebuilt_spec =
+        crate::model::yaml::loads(&std::fs::read_to_string(&spec_path).unwrap()).unwrap();
+    assert_eq!(
+        rebuilt_spec
+            .get("team")
+            .and_then(|team| team.get("workspace"))
+            .and_then(crate::model::yaml::Value::as_str),
+        Some(workspace.to_string_lossy().as_ref()),
+        "restart spec rebuild must keep team.workspace at the project root"
+    );
+    for agent in rebuilt_spec
+        .get("agents")
+        .and_then(crate::model::yaml::Value::as_list)
+        .unwrap()
+    {
+        assert_eq!(
+            agent
+                .get("working_directory")
+                .and_then(crate::model::yaml::Value::as_str),
+            Some(workspace.to_string_lossy().as_ref()),
+            "restart spec rebuild must keep agent working_directory at the project root"
+        );
+    }
+}
+
 #[test]
 fn restart_allow_fresh_does_not_force_fresh_other_agents_when_one_session_capture_times_out() {
     let ws = temp_ws().join("restartatomic");

package/crates/team-agent/src/transport/test_support.rs

@@ -18,6 +18,7 @@ pub struct SpawnRecord {
     pub session: SessionName,
     pub window: WindowName,
     pub argv: Vec<String>,
+    pub cwd: std::path::PathBuf,
 }
 
 #[derive(Debug, Clone)]
@@ -200,6 +201,10 @@ impl OfflineTransport {
         })
     }
 
+    pub fn spawn_cwd_records(&self) -> Vec<std::path::PathBuf> {
+        self.with_state(|state| state.spawns.iter().map(|record| record.cwd.clone()).collect())
+    }
+
     pub fn pane_title_records(&self) -> Vec<(String, String, String, String)> {
         self.with_state(|state| state.pane_titles.clone())
     }
@@ -238,6 +243,7 @@ impl OfflineTransport {
         session: &SessionName,
         window: &WindowName,
         argv: &[String],
+        cwd: &Path,
     ) -> Result<SpawnResult, TransportError> {
         let pane_index = self.with_state(|state| {
             state.calls.push(kind);
@@ -246,6 +252,7 @@ impl OfflineTransport {
                 session: session.clone(),
                 window: window.clone(),
                 argv: argv.to_vec(),
+                cwd: cwd.to_path_buf(),
             });
             if let Some(error) = state.spawn_failures.get(window.as_str()) {
                 return Err(TransportError::Spawn {
@@ -296,10 +303,10 @@ impl Transport for OfflineTransport {
         session: &SessionName,
         window: &WindowName,
         argv: &[String],
-        _cwd: &Path,
+        cwd: &Path,
         _env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn_result("spawn_first", session, window, argv)
+        self.spawn_result("spawn_first", session, window, argv, cwd)
     }
 
     fn spawn_into(
@@ -307,10 +314,10 @@ impl Transport for OfflineTransport {
         session: &SessionName,
         window: &WindowName,
         argv: &[String],
-        _cwd: &Path,
+        cwd: &Path,
         _env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn_result("spawn_into", session, window, argv)
+        self.spawn_result("spawn_into", session, window, argv, cwd)
     }
 
     fn spawn_split_with_env_unset(
@@ -318,11 +325,11 @@ impl Transport for OfflineTransport {
         session: &SessionName,
         window: &WindowName,
         argv: &[String],
-        _cwd: &Path,
+        cwd: &Path,
         _env: &BTreeMap<String, String>,
         _env_unset: &[String],
     ) -> Result<SpawnResult, TransportError> {
-        self.spawn_result("spawn_split", session, window, argv)
+        self.spawn_result("spawn_split", session, window, argv, cwd)
     }
 
     fn inject(

package/npm/install.mjs

@@ -149,9 +149,16 @@ function install(argv) {
 
   const runtimeBinary = path.join(dest, "bin", "team-agent");
   fs.mkdirSync(binDir, { recursive: true });
-  writeExecWrapper(path.join(binDir, "team-agent"), runtimeBinary, []);
+  writeExecWrapper(path.join(binDir, "team-agent"), runtimeBinary, [], { allowForeign: true });
   writeExecWrapper(path.join(binDir, "team_orchestrator"), runtimeBinary, ["mcp-server"]);
   writeExecWrapper(path.join(binDir, "team-agent-coordinator"), runtimeBinary, ["coordinator"]);
+  const shadowRepairs = repairPathShadowingTeamAgentCommands({
+    env: process.env,
+    home: os.homedir(),
+    binDir,
+    runtimeBinary,
+    log: (line) => console.log(line),
+  });
   installSkills(runtimeBinary);
   writeInstallManifest(runtimeRoot, {
     version,
@@ -160,6 +167,7 @@ function install(argv) {
     runtimeBinary,
     installedAt: new Date().toISOString(),
     installTargetKind: installTarget.kind,
+    pathShadowRepairs: shadowRepairs.map((repair) => repair.file),
   });
 
   const teamAgent = path.join(binDir, "team-agent");
@@ -209,6 +217,11 @@ function install(argv) {
   } finally {
     fs.rmSync(doctorWorkspace, { recursive: true, force: true });
   }
+  const pathCheck = verifyInstalledTeamAgentOnPath({
+    env: process.env,
+    expectedVersion: version,
+  });
+  console.log(`post-install: ${pathCheck.entry} --version = ${pathCheck.version}`);
 }
 
 function runDoctor(argv) {
@@ -309,6 +322,162 @@ export function resolveInstallBinDir(options = {}) {
   return { binDir, kind: "shell_rc", readyNow: false, rc };
 }
 
+export function repairPathShadowingTeamAgentCommands(options = {}) {
+  const env = options.env || process.env;
+  const home = options.home || os.homedir();
+  const binDir = path.resolve(expandHomeFor(options.binDir || "", home));
+  const runtimeBinary = options.runtimeBinary;
+  const log = typeof options.log === "function" ? options.log : null;
+  if (!runtimeBinary) {
+    throw new Error("runtimeBinary is required");
+  }
+  const installedWrapper = path.join(binDir, "team-agent");
+  const repairs = [];
+  const candidates = pathShadowRepairCandidates(env.PATH || "", home, binDir);
+  log?.(`path-shadow: scanning ${candidates.length} candidate bin dirs before ${binDir}`);
+  for (const candidateDir of candidates) {
+    const entry = candidateDir.dir;
+    const candidate = path.join(entry, "team-agent");
+    if (isVersionManagedPath(entry)) {
+      log?.(`path-shadow: skip ${candidate} source=${candidateDir.source} reason=version-managed-path`);
+      continue;
+    }
+    if (!fs.existsSync(candidate)) {
+      if (candidateDir.source === "home-local-bin") {
+        log?.(`path-shadow: checked ${candidate} source=${candidateDir.source} reason=not-found`);
+      }
+      continue;
+    }
+    log?.(`path-shadow: found ${candidate} source=${candidateDir.source}`);
+    if (!isExecutableFile(candidate)) {
+      log?.(`path-shadow: skip ${candidate} source=${candidateDir.source} reason=not-executable-file`);
+      continue;
+    }
+    if (sameFile(candidate, installedWrapper)) {
+      log?.(`path-shadow: skip ${candidate} source=${candidateDir.source} reason=installed-wrapper`);
+      continue;
+    }
+    if (sameFile(candidate, runtimeBinary)) {
+      log?.(`path-shadow: skip ${candidate} source=${candidateDir.source} reason=runtime-binary`);
+      continue;
+    }
+    try {
+      writeExecWrapper(candidate, runtimeBinary, [], { allowForeign: true });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`failed to update PATH-shadowing team-agent at ${candidate}: ${detail}`);
+    }
+    log?.(`path-shadow: updated ${candidate} source=${candidateDir.source} to runtime shim`);
+    repairs.push({ file: candidate, binDir: entry, source: candidateDir.source });
+  }
+  if (repairs.length === 0) {
+    log?.("path-shadow: no stale team-agent command repaired");
+  }
+  return repairs;
+}
+
+export function verifyInstalledTeamAgentOnPath(options = {}) {
+  const env = options.env || process.env;
+  const expectedVersion = options.expectedVersion;
+  if (!expectedVersion) {
+    throw new Error("expectedVersion is required");
+  }
+  const which = spawnSync("which", ["team-agent"], {
+    text: true,
+    encoding: "utf8",
+    env,
+    timeout: VERSION_SMOKE_TIMEOUT_MS,
+  });
+  const entry = (which.stdout || "").split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  if (which.status !== 0 || !entry) {
+    throw new Error(
+      `post-install version check failed: \`which team-agent\` did not find the installed command. ` +
+        `Expected version ${expectedVersion}. Add the install bin directory to PATH or restart your shell.`,
+    );
+  }
+  const versionProbe = spawnSync(entry, ["--version"], {
+    text: true,
+    encoding: "utf8",
+    env,
+    timeout: VERSION_SMOKE_TIMEOUT_MS,
+  });
+  const versionOutput = `${versionProbe.stdout || ""}\n${versionProbe.stderr || ""}`;
+  if (versionProbe.status !== 0) {
+    const log = versionOutput.trim() || "no stderr/stdout";
+    throw new Error(
+      `post-install version check failed: PATH resolves team-agent to ${entry}, but \`${entry} --version\` failed ` +
+        `(status=${versionProbe.status ?? "signal"}). Expected version ${expectedVersion}. ` +
+        `A stale binary may be shadowing the installed shim. LOG: ${log}`,
+    );
+  }
+  const actualVersion = parseTeamAgentVersion(versionOutput);
+  if (actualVersion !== expectedVersion) {
+    throw new Error(
+      `post-install version check failed: PATH resolves team-agent to ${entry}, version ${actualVersion || "unknown"} ` +
+        `but installer installed ${expectedVersion}. Remove or update the earlier PATH entry that shadows Team Agent.`,
+    );
+  }
+  return { entry, version: actualVersion };
+}
+
+export function parseTeamAgentVersion(output) {
+  const text = String(output || "").trim();
+  const prefixed = text.match(/^team-agent\s+([^\s]+)$/m);
+  if (prefixed) {
+    return prefixed[1];
+  }
+  const bare = text.match(/^([0-9]+\.[0-9]+\.[0-9]+(?:[-+][^\s]+)?)$/m);
+  return bare ? bare[1] : null;
+}
+
+function shadowingPathEntries(searchPath, home, binDir) {
+  const entries = uniquePathEntries(searchPath, home);
+  const installedIndex = entries.findIndex((entry) => path.resolve(entry) === path.resolve(binDir));
+  if (installedIndex === -1) {
+    return entries;
+  }
+  return entries.slice(0, installedIndex);
+}
+
+function pathShadowRepairCandidates(searchPath, home, binDir) {
+  const candidates = [];
+  const seen = new Set();
+  const add = (dir, source) => {
+    const resolved = path.resolve(expandHomeFor(dir, home));
+    if (seen.has(resolved)) {
+      return;
+    }
+    seen.add(resolved);
+    candidates.push({ dir: resolved, source });
+  };
+  for (const entry of shadowingPathEntries(searchPath, home, binDir)) {
+    add(entry, "path-before-install");
+  }
+
+  const homeLocalBin = path.join(home, ".local", "bin");
+  if (!sameFile(homeLocalBin, binDir)) {
+    add(homeLocalBin, "home-local-bin");
+  }
+  return candidates;
+}
+
+function isExecutableFile(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function sameFile(left, right) {
+  try {
+    return fs.realpathSync(left) === fs.realpathSync(right);
+  } catch {
+    return path.resolve(left) === path.resolve(right);
+  }
+}
+
 function uniquePathEntries(searchPath, home) {
   const seen = new Set();
   const entries = [];
@@ -499,8 +668,8 @@ function copyExecutable(src, dest) {
   fs.chmodSync(dest, 0o755);
 }
 
-function writeExecWrapper(file, binary, fixedArgs) {
-  if (fs.existsSync(file) && !isInstallerManagedWrapper(file)) {
+function writeExecWrapper(file, binary, fixedArgs, options = {}) {
+  if (fs.existsSync(file) && !options.allowForeign && !isInstallerManagedWrapper(file)) {
     throw new Error(`refusing to overwrite non-Team Agent installer wrapper: ${file}`);
   }
   const args = fixedArgs.map(shellQuote).join(" ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.37",
+  "version": "0.3.39",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.37",
-    "@team-agent/cli-darwin-x64": "0.3.37",
-    "@team-agent/cli-linux-x64": "0.3.37"
+    "@team-agent/cli-darwin-arm64": "0.3.39",
+    "@team-agent/cli-darwin-x64": "0.3.39",
+    "@team-agent/cli-linux-x64": "0.3.39"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",