@team-agent/installer 0.5.71 → 0.5.73

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

@@ -2,13 +2,19 @@ use std::os::unix::fs::PermissionsExt;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU32, Ordering};
 
+use crate::lifecycle::launch::launch_with_transport_in_workspace;
 use crate::lifecycle::launch::pi_mcp::{
+    PiAdapterIdentity, PiExecutableChain, PiExecutableFileType, PiMaterializeRequest,
+    PiSessionScope, PiWrapperRequest, materialize_pi_plan, materialize_pi_resume_plan,
     parse_pi_list_models_table, pi_seat_paths, resolve_pi_executable_chain,
     validate_pi_adapter_identity, validate_pi_executable_chain, validate_pi_wrapper_source,
-    write_pi_wrapper, write_pi_wrapper_with_publish, PiAdapterIdentity, PiExecutableChain,
-    PiExecutableFileType, PiWrapperRequest,
+    write_pi_wrapper, write_pi_wrapper_with_publish,
 };
-use crate::provider::McpConfig;
+use crate::lifecycle::start_agent_with_transport;
+use crate::model::enums::ProviderEffort;
+use crate::provider::session_scan::{CaptureSessionContext, scan_session_candidates_once};
+use crate::provider::{McpConfig, Provider, SessionId};
+use crate::transport::test_support::OfflineTransport;
 
 #[path = "../../../tests/support/hermetic.rs"]
 mod hermetic_guard;
@@ -34,6 +40,11 @@ const PI_SYMLINK_TEST: &str = concat!(
     "lifecycle::tests::pi_executable_mcp_red::",
     "pi_standard_npm_symlink_is_a_verified_launch_entry"
 );
+const PI_MATERIALIZER_CHILD: &str = "TEAM_AGENT_TEST_PI_MATERIALIZER_CHILD";
+const PI_MATERIALIZER_TEST: &str = concat!(
+    "lifecycle::tests::pi_executable_mcp_red::",
+    "pi_materializer_and_worker_routes_use_the_recorded_scope"
+);
 
 fn run_process_isolated(marker: &str, test_name: &str, body: impl FnOnce()) {
     if std::env::var_os(marker).is_some() {
@@ -504,3 +515,385 @@ fn pi_wrapper_import_failure_body(hermetic: &HermeticTestEnv) {
 
     std::fs::remove_dir_all(root).expect("remove wrapper fixture");
 }
+
+#[test]
+fn pi_materializer_and_worker_routes_use_the_recorded_scope() {
+    run_process_isolated(PI_MATERIALIZER_CHILD, PI_MATERIALIZER_TEST, || {
+        let hermetic = HermeticTestEnv::enter("pi-materializer-scope");
+        assert_isolated_child();
+        pi_materializer_and_worker_routes_body(&hermetic);
+    });
+}
+
+fn pi_materializer_and_worker_routes_body(hermetic: &HermeticTestEnv) {
+    let fixture_root = hermetic.root().join("materializer-fixture");
+    let bin = fixture_root.join("bin");
+    let adapter_root = fixture_root.join("pi-mcp-adapter");
+    let candidate = fixture_root.join("candidate/team-agent");
+    let real = fixture_root.join("pi-real");
+    std::fs::create_dir_all(&bin).expect("create Pi fixture bin");
+    std::fs::create_dir_all(&adapter_root).expect("create Pi adapter fixture");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+    std::fs::write(
+        adapter_root.join("package.json"),
+        br#"{"name":"pi-mcp-adapter","version":"2.30.0","pi":{"extensions":["./index.ts"]}}"#,
+    )
+    .expect("write adapter package");
+    std::fs::write(
+        adapter_root.join("index.ts"),
+        b"export const createMcpAdapter = () => {};\n",
+    )
+    .expect("write adapter entry");
+    let pi_script = format!(
+        "#!/bin/sh\ncase \"${{1-}}\" in\n  --version) printf '0.84.4\\n' ;;\n  --list-models) printf 'provider model\\nteam-agent qwen3.8-27b\\n' ;;\n  list) printf 'npm:pi-mcp-adapter\\n{}\\n' ;;\n  *) exit 0 ;;\nesac\n",
+        adapter_root.display()
+    );
+    std::fs::write(&real, &pi_script).expect("write Pi real fixture");
+    std::fs::set_permissions(&real, std::fs::Permissions::from_mode(0o755))
+        .expect("make Pi real fixture executable");
+    std::os::unix::fs::symlink(&real, bin.join("pi")).expect("create Pi PATH symlink");
+    let _path = hermetic.with_env(
+        "PATH",
+        std::env::join_paths([&bin])
+            .expect("join Pi fixture PATH")
+            .to_str()
+            .expect("Pi fixture PATH is UTF-8"),
+    );
+
+    let native_workspace = hermetic.workspace("native");
+    let native_paths = pi_seat_paths(&native_workspace, "team-a", "leader");
+    let native_config = mcp_config(&candidate, &native_workspace, "leader");
+    let native = materialize_pi_plan(PiMaterializeRequest {
+        workspace: &native_workspace,
+        team_id: "team-a",
+        agent_id: "leader",
+        model: None,
+        effort: None,
+        system_prompt: "native leader fixture",
+        tool_categories: &["mcp_team"],
+        team_mcp_tools: &["send_message"],
+        mcp_config: &native_config,
+        session_scope: PiSessionScope::NativeDefault,
+    })
+    .expect("NativeDefault materializer");
+    assert!(
+        native.provider_projects_root.is_none(),
+        "NativeDefault must not expose a provider capture root: {native:?}"
+    );
+    assert!(
+        !native_paths.sessions.exists(),
+        "NativeDefault must not create the Team Agent seat session root"
+    );
+    for forbidden in ["--session-dir", "--cwd", "--workspace", "--session"] {
+        assert!(
+            !native.argv.iter().any(|arg| arg == forbidden),
+            "NativeDefault fresh argv must omit {forbidden}: {:?}",
+            native.argv
+        );
+    }
+
+    let isolated_workspace = hermetic.workspace("isolated");
+    let isolated_paths = pi_seat_paths(&isolated_workspace, "team-a", "worker-a");
+    let isolated_config = mcp_config(&candidate, &isolated_workspace, "worker-a");
+    let isolated = materialize_pi_plan(PiMaterializeRequest {
+        workspace: &isolated_workspace,
+        team_id: "team-a",
+        agent_id: "worker-a",
+        model: Some("team-agent/qwen3.8-27b"),
+        effort: Some(ProviderEffort::Medium),
+        system_prompt: "isolated worker fixture",
+        tool_categories: &["mcp_team"],
+        team_mcp_tools: &["send_message"],
+        mcp_config: &isolated_config,
+        session_scope: PiSessionScope::Isolated,
+    })
+    .expect("Isolated materializer");
+    assert_eq!(
+        isolated.provider_projects_root.as_deref(),
+        Some(isolated_paths.sessions.as_path())
+    );
+    assert_session_pair(&isolated.argv, &isolated_paths.sessions);
+    assert!(!isolated.argv.iter().any(|arg| arg == "--cwd"));
+    assert!(!isolated.argv.iter().any(|arg| arg == "--workspace"));
+
+    let session_id = SessionId::new("pi-materializer-resume");
+    let exact = isolated_paths.sessions.join("2026/09/exact.jsonl");
+    std::fs::create_dir_all(exact.parent().expect("exact session parent"))
+        .expect("create exact session parent");
+    std::fs::write(&exact, b"{}\n").expect("write exact session fixture");
+    let resumed = materialize_pi_resume_plan(
+        PiMaterializeRequest {
+            workspace: &isolated_workspace,
+            team_id: "team-a",
+            agent_id: "worker-a",
+            model: None,
+            effort: None,
+            system_prompt: "isolated resume fixture",
+            tool_categories: &["mcp_team"],
+            team_mcp_tools: &["send_message"],
+            mcp_config: &isolated_config,
+            session_scope: PiSessionScope::Isolated,
+        },
+        &session_id,
+        &exact,
+        &isolated_workspace,
+    )
+    .expect("Isolated exact-path resume materializer");
+    assert_eq!(
+        resumed.provider_projects_root.as_deref(),
+        Some(isolated_paths.sessions.as_path())
+    );
+    assert_session_pair(&resumed.argv, &isolated_paths.sessions);
+    assert!(
+        resumed
+            .argv
+            .windows(2)
+            .any(|pair| { pair == ["--session", exact.to_string_lossy().as_ref()] })
+    );
+
+    let native_resume = materialize_pi_resume_plan(
+        PiMaterializeRequest {
+            workspace: &native_workspace,
+            team_id: "team-a",
+            agent_id: "leader",
+            model: None,
+            effort: None,
+            system_prompt: "native resume fixture",
+            tool_categories: &["mcp_team"],
+            team_mcp_tools: &["send_message"],
+            mcp_config: &native_config,
+            session_scope: PiSessionScope::NativeDefault,
+        },
+        &session_id,
+        &exact,
+        &native_workspace,
+    );
+    assert!(
+        matches!(
+            native_resume,
+            Err(crate::provider::ProviderError::ResumeUnavailable(_))
+        ),
+        "NativeDefault resume must fail closed before emitting a native HOME path: {native_resume:?}"
+    );
+
+    let home_candidate = hermetic.home().join(".pi/agent/sessions/home.jsonl");
+    std::fs::create_dir_all(home_candidate.parent().expect("home session parent"))
+        .expect("create home session parent");
+    std::fs::write(&home_candidate, b"{}\n").expect("write home candidate");
+    let other_paths = pi_seat_paths(&isolated_workspace, "team-a", "worker-b");
+    let other_candidate = other_paths.sessions.join("other.jsonl");
+    std::fs::create_dir_all(other_candidate.parent().expect("other session parent"))
+        .expect("create other session parent");
+    std::fs::write(&other_candidate, b"{}\n").expect("write other seat candidate");
+    for (label, outside) in [("HOME", &home_candidate), ("other seat", &other_candidate)] {
+        let refused = materialize_pi_resume_plan(
+            PiMaterializeRequest {
+                workspace: &isolated_workspace,
+                team_id: "team-a",
+                agent_id: "worker-a",
+                model: None,
+                effort: None,
+                system_prompt: "isolated negative resume fixture",
+                tool_categories: &["mcp_team"],
+                team_mcp_tools: &["send_message"],
+                mcp_config: &isolated_config,
+                session_scope: PiSessionScope::Isolated,
+            },
+            &session_id,
+            &outside,
+            &isolated_workspace,
+        );
+        assert!(
+            matches!(
+                refused,
+                Err(crate::provider::ProviderError::ResumeUnavailable(_))
+            ),
+            "{label} candidate must be refused by the exact seat-root check: {refused:?}"
+        );
+    }
+
+    let worker_workspace = hermetic.workspace("worker-spawn");
+    let spec_path = worker_workspace
+        .join(".team")
+        .join("team-a")
+        .join("team.spec.yaml");
+    std::fs::create_dir_all(spec_path.parent().expect("worker Pi spec parent"))
+        .expect("create worker Pi spec parent");
+    let spec = crate::model::yaml::loads(
+        "team:\n  name: team-a\nruntime:\n  session_name: team-workers\n  display_backend: tmux_attach\nagents:\n  - id: worker-a\n    role: Worker A\n    provider: pi\n    model: team-agent/qwen3.8-27b\n    auth_mode: subscription\n    dangerously_skip_permissions: false\n    tools:\n      - mcp_team\n  - id: worker-b\n    role: Worker B\n    provider: pi\n    model: team-agent/qwen3.8-27b\n    auth_mode: subscription\n    dangerously_skip_permissions: false\n    tools:\n      - mcp_team\n",
+    )
+    .expect("parse worker Pi spec");
+    std::fs::write(&spec_path, crate::model::yaml::dumps(&spec)).expect("write worker Pi spec");
+    let transport = OfflineTransport::new();
+    let started = launch_with_transport_in_workspace(
+        &worker_workspace,
+        &spec_path,
+        false,
+        true,
+        true,
+        &transport,
+    )
+    .expect("worker fresh spawn construction")
+    .started;
+    assert_eq!(started.len(), 2, "both Pi worker seats must be spawned");
+    for worker in ["worker-a", "worker-b"] {
+        let paths = pi_seat_paths(&worker_workspace, "team-a", worker);
+        let started_agent = started
+            .iter()
+            .find(|entry| entry.agent_id.as_str() == worker)
+            .expect("started worker entry");
+        assert_eq!(
+            started_agent.provider_projects_root.as_deref(),
+            Some(paths.sessions.as_path()),
+            "fresh worker must expose its exact seat capture root"
+        );
+        let record = transport
+            .spawn_records()
+            .into_iter()
+            .find(|(_, argv)| {
+                argv.iter()
+                    .any(|arg| arg.as_str() == paths.wrapper.to_string_lossy().as_ref())
+            })
+            .expect("transport spawn record for worker seat");
+        assert_session_pair(&record.1, &paths.sessions);
+        assert!(
+            !record
+                .1
+                .iter()
+                .any(|arg| arg.as_str() == home_candidate.to_string_lossy().as_ref())
+        );
+        assert!(
+            !record
+                .1
+                .iter()
+                .any(|arg| arg.as_str() == other_candidate.to_string_lossy().as_ref())
+        );
+
+        let pending_session_id = started_agent
+            .pending_session_id
+            .clone()
+            .expect("fresh worker carries a pending Pi session id");
+        write_pi_session_header(
+            &home_candidate,
+            pending_session_id.as_str(),
+            &worker_workspace,
+            "2099-01-01T00:00:00Z",
+        );
+        let other_worker = if worker == "worker-a" {
+            "worker-b"
+        } else {
+            "worker-a"
+        };
+        let cross_seat = pi_seat_paths(&worker_workspace, "team-a", other_worker)
+            .sessions
+            .join("foreign.jsonl");
+        write_pi_session_header(
+            &cross_seat,
+            pending_session_id.as_str(),
+            &worker_workspace,
+            "2099-01-01T00:00:00Z",
+        );
+        let candidates = scan_session_candidates_once(
+            Provider::Pi,
+            &CaptureSessionContext {
+                agent_id: worker.to_string(),
+                spawn_cwd: worker_workspace.clone(),
+                pane_id: None,
+                pane_pid: None,
+                spawned_at: Some(started_agent.spawned_at.clone()),
+                expected_session_id: Some(pending_session_id),
+                provider_projects_root: Some(paths.sessions.clone()),
+            },
+        )
+        .expect("scan the recorded worker seat only");
+        assert!(
+            candidates.is_empty(),
+            "HOME and another worker seat must not become capture candidates: {candidates:?}"
+        );
+    }
+
+    let restart_workspace = hermetic.workspace("worker-restart");
+    let restart_paths = pi_seat_paths(&restart_workspace, "team-a", "worker-a");
+    let restart_exact = restart_paths.sessions.join("2026/09/restart.jsonl");
+    write_pi_session_header(
+        &restart_exact,
+        "pi-restart-session",
+        &restart_workspace,
+        "2026-09-01T00:00:01Z",
+    );
+    crate::state::persist::save_runtime_state(
+        &restart_workspace,
+        &serde_json::json!({
+            "session_name": "team-workers",
+            "active_team_key": "team-a",
+            "agents": {
+                "worker-a": {
+                    "id": "worker-a",
+                    "status": "running",
+                    "provider": "pi",
+                    "role": "Worker A",
+                    "model": "team-agent/qwen3.8-27b",
+                    "auth_mode": "subscription",
+                    "tools": ["mcp_team"],
+                    "session_id": "pi-restart-session",
+                    "rollout_path": restart_exact.to_string_lossy(),
+                    "spawn_cwd": restart_workspace.to_string_lossy(),
+                    "first_send_at": "2026-09-01T00:00:00Z"
+                }
+            }
+        }),
+    )
+    .expect("write restart state");
+    let restart_transport = OfflineTransport::new();
+    let _ = start_agent_with_transport(
+        &restart_workspace,
+        &crate::model::ids::AgentId::new("worker-a"),
+        false,
+        false,
+        false,
+        None,
+        &restart_transport,
+    );
+    let restart_record = restart_transport
+        .spawn_records()
+        .into_iter()
+        .next()
+        .expect("restart must reach the worker spawn construction");
+    assert_session_pair(&restart_record.1, &restart_paths.sessions);
+    assert!(
+        restart_record
+            .1
+            .windows(2)
+            .any(|pair| { pair == ["--session", restart_exact.to_string_lossy().as_ref()] })
+    );
+    assert!(
+        !restart_record
+            .1
+            .iter()
+            .any(|arg| arg.as_str() == home_candidate.to_string_lossy().as_ref())
+    );
+}
+
+fn assert_session_pair(argv: &[String], session_root: &Path) {
+    let expected = session_root.to_string_lossy();
+    assert!(
+        argv.windows(2)
+            .any(|pair| pair[0] == "--session-dir" && pair[1].as_str() == expected.as_ref()),
+        "argv must contain exact --session-dir pair for {}: {argv:?}",
+        session_root.display()
+    );
+}
+
+fn write_pi_session_header(path: &Path, id: &str, cwd: &Path, timestamp: &str) {
+    std::fs::create_dir_all(path.parent().expect("session parent")).expect("create session parent");
+    let header = serde_json::json!({
+        "type": "session",
+        "version": 3,
+        "id": id,
+        "cwd": cwd,
+        "timestamp": timestamp,
+    });
+    std::fs::write(path, format!("{header}\n")).expect("write Pi session header");
+}

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

@@ -60,7 +60,9 @@ fn resume_argv(path: &Path) -> Result<Vec<String>, ProviderError> {
         effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
-        session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
+        session_dir: Some(Path::new(
+            "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
+        )),
         session: PiSessionSelector::Resume { path },
         agent_id: "worker-a",
     })

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

@@ -495,6 +495,14 @@ pub enum LifecycleError {
     /// 编译 spec / role doc 失败(`compile_team`/`compile_role_doc_agent`)。
     #[error("spec compile failed: {0}")]
     Compile(String),
+    /// Pi model/schema admission failed before lifecycle reservation or writes.
+    #[error("pi model preflight failed: {requested}")]
+    PiModelPreflight {
+        requested: String,
+        candidates: Vec<String>,
+        action: String,
+        not_ready: bool,
+    },
     /// provider 命令构造 / resume 不可用(`ResumeUnavailable`)。
     #[error("provider error: {0}")]
     Provider(String),

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -50,7 +50,8 @@ pub(crate) struct PiCommandRequest<'a> {
     pub effort: Option<ProviderEffort>,
     pub system_prompt: &'a str,
     pub tool_categories: &'a [&'a str],
-    pub session_dir: &'a Path,
+    /// Team-owned session root for isolated seats; `None` preserves Pi's native default.
+    pub session_dir: Option<&'a Path>,
     pub session: PiSessionSelector<'a>,
     pub agent_id: &'a str,
 }
@@ -65,14 +66,15 @@ pub(crate) fn build_pi_command_argv(
 ) -> Result<Vec<String>, ProviderError> {
     if request.executable.as_os_str().is_empty()
         || request.extension.as_os_str().is_empty()
-        || request.session_dir.as_os_str().is_empty()
+        || request
+            .session_dir
+            .is_some_and(|session_dir| session_dir.as_os_str().is_empty())
         || request.model.is_some_and(|model| model.trim().is_empty())
         || request.system_prompt.trim().is_empty()
         || request.agent_id.trim().is_empty()
     {
         return Err(ProviderError::Command(
-            "Pi command requires executable, extension, prompt, session directory, and agent id"
-                .to_string(),
+            "Pi command requires executable, extension, prompt, and agent id".to_string(),
         ));
     }
 
@@ -110,9 +112,13 @@ pub(crate) fn build_pi_command_argv(
     argv.extend([
         "--append-system-prompt".to_string(),
         request.system_prompt.to_string(),
-        "--session-dir".to_string(),
-        request.session_dir.to_string_lossy().into_owned(),
     ]);
+    if let Some(session_dir) = request.session_dir {
+        argv.extend([
+            "--session-dir".to_string(),
+            session_dir.to_string_lossy().into_owned(),
+        ]);
+    }
     // The shared lifecycle materializer always revalidates resume root/path/header.
     // Keep the pure argv builder usable before a fixture root is materialized, while
     // refusing a missing exact file once the recorded path's parent exists.

package/npm/check-skill-links.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/** Resolve local Markdown links and optionally validate package/installed inventories. */
+import fs from "node:fs";
+import path from "node:path";
+
+const args = process.argv.slice(2);
+const value = (name) => { const i = args.indexOf(name); return i < 0 ? null : args[i + 1]; };
+const rootArg = value("--root") ?? "skills/team-agent";
+const root = path.resolve(rootArg);
+const installedArg = value("--installed");
+const inventoryArg = value("--inventory");
+const markdownLink = /!?(?:\[[^\]]*\])\(([^)]+)\)/g;
+const files = [];
+const fail = (message) => { throw new Error(message); };
+const real = (file) => { try { return fs.realpathSync.native(file); } catch (error) { fail(`cannot resolve ${file}: ${error.message}`); } };
+const rootReal = real(root);
+const inside = (candidate, base = rootReal) => candidate === base || candidate.startsWith(`${base}${path.sep}`);
+const lexicalInside = (candidate, base = root) => candidate === base || candidate.startsWith(`${base}${path.sep}`);
+
+function walk(dir, boundary = rootReal) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)); }
+  catch (error) { fail(`cannot read ${dir}: ${error.message}`); }
+  for (const entry of entries) {
+    const file = path.join(dir, entry.name);
+    const fileReal = real(file);
+    if (!inside(fileReal, boundary)) fail(`${file}: realpath escapes tree`);
+    if (entry.isDirectory()) walk(file, boundary);
+    else if (entry.isFile() && file.endsWith(".md")) files.push(file);
+  }
+}
+function normalizeFragment(fragment) {
+  return decodeURIComponent(fragment).toLowerCase().trim().replace(/<[^>]+>/g, "")
+    .replace(/[`*_~]/g, "").replace(/[^\p{L}\p{N} -]/gu, "").replace(/\s+/g, "-");
+}
+function anchors(text) {
+  const found = new Set();
+  const used = new Map();
+  const add = (value) => {
+    const base = normalizeFragment(value); if (!base) return;
+    const n = used.get(base) ?? 0; used.set(base, n + 1); found.add(n ? `${base}-${n}` : base);
+  };
+  for (const m of text.matchAll(/^(?: {0,3})#{1,6}\s+(.+?)\s*#*\s*$/gm) ) add(m[1]);
+  for (const m of text.matchAll(/^(?: {0,3})([^\n#]+)\n(?:=+|-+)\s*$/gm)) add(m[1]);
+  for (const m of text.matchAll(/<(?:a|[^>]+)\s+[^>]*(?:id|name)=["']([^"']+)["'][^>]*>/gi)) add(m[1]);
+  return found;
+}
+function checkTree(dir, baseRoot, baseReal) {
+  files.length = 0; walk(dir, baseReal);
+  const errors = [];
+  for (const file of [...files].sort()) {
+    const text = fs.readFileSync(file, "utf8");
+    const known = anchors(text);
+    for (const match of text.matchAll(markdownLink)) {
+      const href = match[1].trim();
+      if (!href || /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(href)) continue;
+      const hash = href.indexOf("#");
+      const rawPath = hash < 0 ? href : href.slice(0, hash);
+      const fragment = hash < 0 ? "" : href.slice(hash + 1).split("?", 1)[0];
+      const target = rawPath ? path.resolve(path.dirname(file), rawPath) : file;
+      if (!lexicalInside(target, baseRoot)) { errors.push(`${file}: lexical target escapes tree: ${href}`); continue; }
+      const targetReal = real(target);
+      if (!inside(targetReal, baseReal)) { errors.push(`${file}: realpath target escapes tree: ${href}`); continue; }
+      if (!fs.statSync(targetReal).isFile()) { errors.push(`${file}: target is not a file: ${href}`); continue; }
+      if (fragment && targetReal.endsWith(".md")) {
+        const targetAnchors = targetReal === real(file) ? known : anchors(fs.readFileSync(targetReal, "utf8"));
+        if (!targetAnchors.has(normalizeFragment(fragment))) errors.push(`${file}: missing fragment: ${href}`);
+      }
+    }
+  }
+  if (errors.length) fail(errors.sort().join("\n"));
+  return [...files].sort().length;
+}
+const count = checkTree(root, root, rootReal);
+if (inventoryArg) {
+  const inventory = path.resolve(inventoryArg);
+  for (const relative of fs.readFileSync(inventory, "utf8").split(/\r?\n/).filter(Boolean).sort()) {
+    if (path.isAbsolute(relative)) fail(`inventory path must be relative: ${relative}`);
+    const candidate = path.resolve(root, relative);
+    if (!lexicalInside(candidate)) fail(`inventory path escapes tree: ${relative}`);
+    const candidateReal = real(candidate);
+    if (!inside(candidateReal)) fail(`inventory realpath escapes tree: ${relative}`);
+  }
+}
+if (installedArg) {
+  const installed = path.resolve(installedArg); console.log(`checked ${checkTree(installed, installed, real(installed))} Markdown files in ${installed}`);
+}
+console.log(`checked ${count} Markdown files in ${root}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.71",
+  "version": "0.5.73",
   "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.5.71",
-    "@team-agent/cli-darwin-x64": "0.5.71",
-    "@team-agent/cli-linux-x64": "0.5.71"
+    "@team-agent/cli-darwin-arm64": "0.5.73",
+    "@team-agent/cli-darwin-x64": "0.5.73",
+    "@team-agent/cli-linux-x64": "0.5.73"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",
@@ -33,6 +33,7 @@
   "files": [
     "npm/bincheck.mjs",
     "npm/install.mjs",
+    "npm/check-skill-links.mjs",
     "skills",
     "templates",
     "examples",