@mison/ag-kit-cn 2.0.1 → 3.0.0

package/bin/ag-kit.js

@@ -5,19 +5,51 @@ const os = require("os");
 const path = require("path");
 
 const pkg = require("../package.json");
-const { readGlobalNpmDependencies } = require("./utils");
+const { readGlobalNpmDependencies, cloneBranchAgentDir } = require("./utils");
+const ManifestManager = require("./utils/manifest");
+const AtomicWriter = require("./utils/atomic-writer");
+const CodexBuilder = require("./core/builder");
 const GeminiAdapter = require("./adapters/gemini");
 const CodexAdapter = require("./adapters/codex");
 const { selectTargets } = require("./interactive");
 
-const BUNDLED_AGENT_DIR = path.resolve(__dirname, "../.agent");
+const BUNDLED_AGENT_DIR = path.resolve(__dirname, "../.agents");
 const WORKSPACE_INDEX_VERSION = 2;
 const UPSTREAM_GLOBAL_PACKAGE = "@vudovn/ag-kit";
 const TOOLKIT_PACKAGE_NAMES = new Set(["@mison/ag-kit-cn", "antigravity-kit-cn", "antigravity-kit"]);
 const SUPPORTED_TARGETS = ["gemini", "codex"];
+const LEGACY_INDEX_TARGET_ALIASES = {
+    full: "gemini",
+};
+const GLOBAL_TARGET_DESTINATIONS = {
+    codex: [
+        {
+            id: "codex",
+            rootParts: [".codex"],
+            skillsParts: [".codex", "skills"],
+        },
+    ],
+    gemini: [
+        {
+            id: "gemini-cli",
+            rootParts: [".gemini", "skills"],
+            skillsParts: [".gemini", "skills"],
+        },
+        {
+            id: "antigravity",
+            rootParts: [".gemini", "antigravity"],
+            skillsParts: [".gemini", "antigravity", "skills"],
+        },
+    ],
+};
 const INDEX_LOCK_RETRY_MS = 50;
 const INDEX_LOCK_TIMEOUT_MS = 3000;
 const INDEX_LOCK_STALE_MS = 30000;
+const QUIET_STATUS_EXIT_CODES = {
+    installed: 0,
+    broken: 1,
+    missing: 2,
+};
 
 function nowISO() {
     return new Date().toISOString();
@@ -40,12 +72,74 @@ function createEmptyWorkspaceIndex() {
     };
 }
 
+function resolveGlobalRootDir() {
+    const customRoot = process.env.AG_KIT_GLOBAL_ROOT;
+    if (typeof customRoot === "string" && customRoot.trim()) {
+        return path.resolve(process.cwd(), customRoot);
+    }
+    return os.homedir();
+}
+
+function getGlobalDestinations(targetName, globalRoot = resolveGlobalRootDir()) {
+    const config = GLOBAL_TARGET_DESTINATIONS[targetName];
+    if (!config) {
+        throw new Error(`未知目标: ${targetName}`);
+    }
+    return config.map((item) => ({
+        ...item,
+        targetName,
+        rootDir: path.join(globalRoot, ...item.rootParts),
+        skillsRoot: path.join(globalRoot, ...item.skillsParts),
+    }));
+}
+
+function listGlobalDestinations(globalRoot = resolveGlobalRootDir()) {
+    return Object.keys(GLOBAL_TARGET_DESTINATIONS).flatMap((targetName) => getGlobalDestinations(targetName, globalRoot));
+}
+
+function resolveGlobalBackupRoot(timestamp) {
+    const globalRoot = resolveGlobalRootDir();
+    return path.join(globalRoot, ".ag-kit", "backups", "global", timestamp);
+}
+
+function copyDirRecursive(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+function areDirectoriesEqual(leftDir, rightDir) {
+    const left = ManifestManager.generateFromDir(leftDir);
+    const right = ManifestManager.generateFromDir(rightDir);
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const key of leftKeys) {
+        if (left[key] !== right[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+
 function printUsage() {
     console.log("用法:");
     console.log("  ag-kit init [--force] [--path <dir>] [--branch <name>] [--target <name>|--targets <a,b>] [--non-interactive] [--no-index] [--quiet] [--dry-run]");
     console.log("  ag-kit update [--path <dir>] [--branch <name>] [--target <name>|--targets <a,b>] [--no-index] [--quiet] [--dry-run]");
     console.log("  ag-kit update-all [--branch <name>] [--targets <a,b>] [--prune-missing] [--quiet] [--dry-run]");
     console.log("  ag-kit doctor [--path <dir>] [--target <name>|--targets <a,b>] [--fix] [--quiet]");
+    console.log("  ag-kit global sync [--target <name>|--targets <a,b>] [--branch <name>] [--quiet] [--dry-run]  # 默认同步 codex + gemini(cli+antigravity)");
+    console.log("  ag-kit global status [--quiet]");
     console.log("  ag-kit exclude list [--quiet]");
     console.log("  ag-kit exclude add --path <dir> [--dry-run] [--quiet]");
     console.log("  ag-kit exclude remove --path <dir> [--dry-run] [--quiet]");
@@ -79,12 +173,12 @@ function parseArgs(argv) {
     const providedFlags = [];
 
     let startIndex = 1;
-    if (command === "exclude") {
+    if (command === "exclude" || command === "global") {
         if (argv.length > 1 && !argv[1].startsWith("--")) {
             options.subcommand = argv[1];
             startIndex = 2;
         } else {
-            options.subcommand = "list";
+            options.subcommand = command === "global" ? "status" : "list";
             startIndex = 1;
         }
     }
@@ -151,6 +245,8 @@ const COMMAND_ALLOWED_FLAGS = {
     "update-all": ["--branch", "--targets", "--prune-missing", "--quiet", "--dry-run"],
     doctor: ["--path", "--target", "--targets", "--fix", "--quiet"],
     status: ["--path", "--quiet"],
+    "global:sync": ["--target", "--targets", "--branch", "--quiet", "--dry-run"],
+    "global:status": ["--quiet"],
     "exclude:list": ["--quiet"],
     "exclude:add": ["--path", "--dry-run", "--quiet"],
     "exclude:remove": ["--path", "--dry-run", "--quiet"],
@@ -162,6 +258,11 @@ function resolveAllowedFlags(command, options) {
         const key = `exclude:${subcommand}`;
         return COMMAND_ALLOWED_FLAGS[key] || null;
     }
+    if (command === "global") {
+        const subcommand = String(options.subcommand || "status").toLowerCase();
+        const key = `global:${subcommand}`;
+        return COMMAND_ALLOWED_FLAGS[key] || null;
+    }
     return COMMAND_ALLOWED_FLAGS[command] || null;
 }
 
@@ -170,6 +271,10 @@ function resolveCommandLabel(command, options) {
         const subcommand = String(options.subcommand || "list").toLowerCase();
         return `exclude ${subcommand}`;
     }
+    if (command === "global") {
+        const subcommand = String(options.subcommand || "status").toLowerCase();
+        return `global ${subcommand}`;
+    }
     return command;
 }
 
@@ -341,13 +446,34 @@ function normalizeTargetState(value) {
     };
 }
 
+function normalizeIndexTargetName(targetName) {
+    if (typeof targetName !== "string") {
+        return null;
+    }
+    const normalized = targetName.trim().toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (Object.prototype.hasOwnProperty.call(LEGACY_INDEX_TARGET_ALIASES, normalized)) {
+        return LEGACY_INDEX_TARGET_ALIASES[normalized];
+    }
+    if (SUPPORTED_TARGETS.includes(normalized)) {
+        return normalized;
+    }
+    return null;
+}
+
 function normalizeWorkspaceRecordV2(item, normalizedPath) {
     const targets = {};
     if (item && item.targets && typeof item.targets === "object") {
         for (const [targetName, state] of Object.entries(item.targets)) {
+            const normalizedTargetName = normalizeIndexTargetName(targetName);
+            if (!normalizedTargetName) {
+                continue;
+            }
             const normalizedState = normalizeTargetState(state);
             if (normalizedState) {
-                targets[targetName] = normalizedState;
+                targets[normalizedTargetName] = normalizedState;
             }
         }
     }
@@ -669,7 +795,12 @@ function maybeWarnUpstreamGlobalConflict(command, options) {
     if (process.env.AG_KIT_SKIP_UPSTREAM_CHECK === "1") {
         return;
     }
-    if (command !== "init" && command !== "update" && command !== "update-all") {
+    const shouldWarn =
+        command === "init"
+        || command === "update"
+        || command === "update-all"
+        || (command === "global" && String(options.subcommand || "").toLowerCase() === "sync");
+    if (!shouldWarn) {
         return;
     }
 
@@ -685,6 +816,7 @@ function maybeWarnUpstreamGlobalConflict(command, options) {
     log(options, `⚠️ 检测到全局已安装上游英文版 ${UPSTREAM_GLOBAL_PACKAGE}。`);
     log(options, "⚠️ 上游英文版与当前中文版共用 `ag-kit` 命令名，后安装者会覆盖命令入口。");
     log(options, `👉 建议执行: npm uninstall -g ${UPSTREAM_GLOBAL_PACKAGE}`);
+    log(options, "ℹ️ 若你通过 bun install -g 安装，Bun 默认会阻止本包 postinstall；因此这里会在首次执行 CLI 时再次提醒。");
 }
 
 function normalizeTargets(rawTargets) {
@@ -735,6 +867,100 @@ function isTargetInstalled(workspaceRoot, targetName) {
     return false;
 }
 
+function setQuietStatusExitCode(state) {
+    process.exitCode = Object.prototype.hasOwnProperty.call(QUIET_STATUS_EXIT_CODES, state)
+        ? QUIET_STATUS_EXIT_CODES[state]
+        : 1;
+}
+
+function normalizeIntegrityState(result) {
+    if (!result || result.status === "missing") {
+        return "missing";
+    }
+    if (result.status === "ok") {
+        return "installed";
+    }
+    return "broken";
+}
+
+function evaluateWorkspaceState(workspaceRoot, options) {
+    const targets = detectInstalledTargets(workspaceRoot);
+    if (targets.length === 0) {
+        return {
+            state: "missing",
+            targets: [],
+        };
+    }
+
+    const targetStates = targets.map((targetName) => {
+        const adapter = createAdapter(targetName, workspaceRoot, {
+            ...options,
+            quiet: true,
+        });
+        const integrity = adapter.checkIntegrity();
+        return {
+            targetName,
+            state: normalizeIntegrityState(integrity),
+            integrity,
+            version: typeof adapter.getInstalledVersion === "function" ? adapter.getInstalledVersion() : null,
+        };
+    });
+
+    const hasIssue = targetStates.some((item) => item.state !== "installed");
+    return {
+        state: hasIssue ? "broken" : "installed",
+        targets: targetStates,
+    };
+}
+
+function evaluateGlobalState() {
+    const globalRoot = resolveGlobalRootDir();
+    const targetStates = listGlobalDestinations(globalRoot).map((destination) => {
+        const rootExists = fs.existsSync(destination.rootDir);
+        const skillsExists = fs.existsSync(destination.skillsRoot);
+        const skillsCount = skillsExists ? countSkillsRecursive(destination.skillsRoot) : 0;
+        let state = "missing";
+        const issues = [];
+
+        if (rootExists || skillsExists) {
+            if (!skillsExists) {
+                state = "broken";
+                issues.push("Skills 根目录缺失");
+            } else if (skillsCount === 0) {
+                state = "broken";
+                issues.push("未检测到任何 SKILL.md");
+            } else {
+                state = "installed";
+            }
+        }
+
+        return {
+            targetName: destination.id,
+            family: destination.targetName,
+            state,
+            rootDir: destination.rootDir,
+            skillsRoot: destination.skillsRoot,
+            skillsCount,
+            issues,
+        };
+    }).filter((item) => item.state !== "missing");
+
+    if (targetStates.length === 0) {
+        return {
+            globalRoot,
+            state: "missing",
+            targets: [],
+        };
+    }
+
+    const hasIssue = targetStates.some((item) => item.state !== "installed");
+    return {
+        globalRoot,
+        state: hasIssue ? "broken" : "installed",
+        targets: targetStates,
+    };
+}
+
 function createAdapter(targetName, workspaceRoot, options) {
     if (targetName === "gemini") {
         return new GeminiAdapter(workspaceRoot, options);
@@ -776,6 +1002,248 @@ function resolveTargetsForUpdate(workspaceRoot, options) {
     return detectInstalledTargets(workspaceRoot);
 }
 
+function resolveTargetsForGlobalSync(options) {
+    const requested = normalizeTargets(options.targets);
+    if (requested.length > 0) {
+        return requested;
+    }
+    // 保持 global sync 简洁：默认同步 codex + gemini；其中 gemini 会展开为 gemini-cli 与 antigravity。
+    return ["codex", "gemini"];
+}
+
+function resolveAgentInstallSource(options) {
+    let agentDir = BUNDLED_AGENT_DIR;
+    let cleanup = null;
+    let sourceLabel = "bundled";
+
+    if (options.branch) {
+        const remote = cloneBranchAgentDir(options.branch, {
+            quiet: options.quiet,
+            logger: log.bind(null, options),
+        });
+        agentDir = remote.agentDir;
+        cleanup = remote.cleanup;
+        sourceLabel = `branch:${options.branch}`;
+    }
+
+    if (!fs.existsSync(agentDir) && !options.branch) {
+        const legacyDir = path.resolve(__dirname, "../.agent");
+        if (fs.existsSync(legacyDir)) {
+            agentDir = legacyDir;
+            sourceLabel = "bundled:legacy";
+        }
+    }
+
+    if (!fs.existsSync(agentDir)) {
+        throw new Error(`未找到模板目录: ${agentDir}`);
+    }
+
+    return { agentDir, cleanup, sourceLabel };
+}
+
+function listSkillDirectories(skillsRoot) {
+    if (!fs.existsSync(skillsRoot)) {
+        return [];
+    }
+    return fs
+        .readdirSync(skillsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => fs.existsSync(path.join(skillsRoot, name, "SKILL.md")));
+}
+
+function backupSkillDirectory(targetName, skillName, sourceDir, timestamp, options) {
+    const backupRoot = resolveGlobalBackupRoot(timestamp);
+    const backupDir = path.join(backupRoot, targetName, skillName);
+    fs.mkdirSync(path.dirname(backupDir), { recursive: true });
+    copyDirRecursive(sourceDir, backupDir);
+    log(options, `📦 已备份 ${targetName} 全局 Skill: ${skillName} -> ${backupDir}`);
+}
+
+function syncSkillDirectory(destination, srcDir, destDir, timestamp, options) {
+    const exists = fs.existsSync(destDir);
+    if (exists) {
+        if (areDirectoriesEqual(srcDir, destDir)) {
+            log(options, `⏭️ 全局 Skill 已最新，无需同步: ${destination.id}/${path.basename(destDir)}`);
+            return { skipped: 1, synced: 0, backedUp: 0 };
+        }
+    }
+
+    if (options.dryRun) {
+        log(options, `[dry-run] 将同步全局 Skill: ${destination.id}/${path.basename(destDir)}`);
+        return { skipped: 0, synced: 0, backedUp: exists ? 1 : 0 };
+    }
+
+    let backedUp = 0;
+    if (exists) {
+        backupSkillDirectory(destination.id, path.basename(destDir), destDir, timestamp, options);
+        backedUp = 1;
+    }
+
+    const logger = options.quiet ? (() => {}) : log.bind(null, options);
+    AtomicWriter.atomicCopyDir(srcDir, destDir, { logger });
+    log(options, `✅ 已同步全局 Skill: ${destination.id}/${path.basename(destDir)}`);
+
+    return { skipped: 0, synced: 1, backedUp };
+}
+
+function syncGlobalSkillsFromRoot(targetName, skillsRoot, timestamp, options) {
+    const destinations = getGlobalDestinations(targetName);
+    const skillNames = listSkillDirectories(skillsRoot);
+    if (skillNames.length === 0) {
+        throw new Error(`未检测到可同步的 Skills: ${skillsRoot}`);
+    }
+
+    if (options.dryRun) {
+        for (const destination of destinations) {
+            log(options, `[dry-run] 将同步 ${skillNames.length} 个全局 Skills -> ${destination.skillsRoot}`);
+        }
+    }
+
+    let synced = 0;
+    let skipped = 0;
+    let backedUp = 0;
+    const destinationResults = [];
+
+    for (const destination of destinations) {
+        let destinationSynced = 0;
+        let destinationSkipped = 0;
+        let destinationBackedUp = 0;
+
+        for (const skillName of skillNames) {
+            const srcDir = path.join(skillsRoot, skillName);
+            const destDir = path.join(destination.skillsRoot, skillName);
+            const result = syncSkillDirectory(destination, srcDir, destDir, timestamp, options);
+            synced += result.synced;
+            skipped += result.skipped;
+            backedUp += result.backedUp;
+            destinationSynced += result.synced;
+            destinationSkipped += result.skipped;
+            destinationBackedUp += result.backedUp;
+        }
+
+        destinationResults.push({
+            targetName: destination.id,
+            family: destination.targetName,
+            destRoot: destination.skillsRoot,
+            total: skillNames.length,
+            synced: destinationSynced,
+            skipped: destinationSkipped,
+            backedUp: destinationBackedUp,
+        });
+    }
+
+    return {
+        total: skillNames.length * destinations.length,
+        skillsPerDestination: skillNames.length,
+        synced,
+        skipped,
+        backedUp,
+        destinations: destinationResults,
+    };
+}
+
+function applyGlobalSync(targetName, agentDir, timestamp, options) {
+    if (targetName === "codex") {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-global-codex-"));
+        const mockRoot = path.join(tempRoot, "source");
+        const mockAgent = path.join(mockRoot, ".agents");
+        const outputDir = path.join(tempRoot, "out");
+
+        try {
+            copyDirRecursive(agentDir, mockAgent);
+            CodexBuilder.build(mockRoot, outputDir);
+            const skillsRoot = path.join(outputDir, "skills");
+            return syncGlobalSkillsFromRoot(targetName, skillsRoot, timestamp, options);
+        } finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    }
+
+    if (targetName === "gemini") {
+        const skillsRoot = path.join(agentDir, "skills");
+        return syncGlobalSkillsFromRoot(targetName, skillsRoot, timestamp, options);
+    }
+
+    throw new Error(`未知目标: ${targetName}`);
+}
+
+async function commandGlobalSync(options) {
+    const targets = await resolveTargetsForGlobalSync(options);
+    const { agentDir, cleanup, sourceLabel } = resolveAgentInstallSource(options);
+    const timestamp = nowISO().replace(/[:.]/g, "-");
+
+    try {
+        log(options, `🌍 全局同步源: ${sourceLabel}`);
+        for (const target of targets) {
+            log(options, `📦 正在同步全局目标 [${target}] ...`);
+            const result = applyGlobalSync(target, agentDir, timestamp, options);
+            if (!options.dryRun) {
+                log(options, `📊 全局同步完成 [${target}]：总计 ${result.total}，新增/覆盖 ${result.synced}，跳过 ${result.skipped}，备份 ${result.backedUp}`);
+                for (const item of result.destinations) {
+                    log(options, `   - ${item.targetName}: ${item.destRoot}（每目标 ${item.total} 个 Skills）`);
+                }
+            }
+        }
+    } finally {
+        if (cleanup) cleanup();
+    }
+}
+
+function commandGlobalStatus(options) {
+    const summary = evaluateGlobalState();
+
+    if (summary.state === "missing") {
+        if (options.quiet) {
+            console.log("missing");
+        }
+        if (!options.quiet) {
+            console.log("❌ 未检测到全局安装的 Skills");
+            console.log(`   全局根目录: ${summary.globalRoot}`);
+        }
+        setQuietStatusExitCode("missing");
+        return;
+    }
+
+    if (options.quiet) {
+        console.log(summary.state);
+        setQuietStatusExitCode(summary.state);
+        return;
+    }
+
+    console.log(summary.state === "installed" ? "✅ 全局 Skills 状态正常" : "⚠️ 全局 Skills 存在问题");
+    console.log(`   全局根目录: ${summary.globalRoot}`);
+    console.log(`   总体状态: ${summary.state}`);
+    console.log(`   Targets: ${summary.targets.map((item) => item.targetName).join(", ")}`);
+
+    for (const item of summary.targets) {
+        console.log(`\n[${item.targetName}:global]`);
+        console.log(`   家族: ${item.family}`);
+        console.log(`   状态: ${item.state}`);
+        console.log(`   路径: ${item.skillsRoot}`);
+        if (item.state === "installed") {
+            console.log(`   Skills: ${item.skillsCount}`);
+            continue;
+        }
+        for (const issue of item.issues) {
+            console.log(`   Issue: ${issue}`);
+        }
+    }
+
+    setQuietStatusExitCode(summary.state);
+}
+
+function commandGlobal(options) {
+    const subcommand = String(options.subcommand || "status").toLowerCase();
+    if (subcommand === "sync") {
+        return commandGlobalSync(options);
+    }
+    if (subcommand === "status") {
+        return commandGlobalStatus(options);
+    }
+    throw new Error(`未知 global 子命令: ${subcommand}`);
+}
+
 async function commandInit(options) {
     const workspaceRoot = resolveWorkspaceRoot(options.path);
     const targets = await resolveTargetsForInit(options);
@@ -1225,40 +1693,54 @@ function countSkillsRecursive(dir) {
 
 function commandStatus(options) {
     const workspaceRoot = resolveWorkspaceRoot(options.path);
-    const installedTargets = detectInstalledTargets(workspaceRoot);
+    const summary = evaluateWorkspaceState(workspaceRoot, options);
 
-    if (installedTargets.length === 0) {
+    if (summary.state === "missing") {
+        if (options.quiet) {
+            console.log("missing");
+        }
         if (!options.quiet) {
             console.log("❌ 未检测到 Antigravity Kit 安装");
             console.log(`   目标目录: ${workspaceRoot}`);
         }
-        process.exitCode = 1;
+        setQuietStatusExitCode("missing");
         return;
     }
 
     if (options.quiet) {
-        console.log("installed");
+        console.log(summary.state);
+        setQuietStatusExitCode(summary.state);
         return;
     }
 
-    console.log("✅ Antigravity Kit 已安装");
+    console.log(summary.state === "installed" ? "✅ Antigravity Kit 状态正常" : "⚠️ Antigravity Kit 存在问题");
     console.log(`   CLI 版本: ${pkg.version}`);
     console.log(`   工作区: ${workspaceRoot}`);
-    console.log(`   Targets: ${installedTargets.join(", ")}`);
+    console.log(`   总体状态: ${summary.state}`);
+    console.log(`   Targets: ${summary.targets.map((item) => item.targetName).join(", ")}`);
 
-    if (installedTargets.includes("gemini")) {
+    const geminiState = summary.targets.find((item) => item.targetName === "gemini");
+    if (geminiState) {
         const agentDir = path.join(workspaceRoot, ".agent");
         const agentsCount = countFilesIfExists(path.join(agentDir, "agents"), (name) => name.endsWith(".md"));
         const workflowsCount = countFilesIfExists(path.join(agentDir, "workflows"), (name) => name.endsWith(".md"));
         const skillsCount = countSkillsRecursive(path.join(agentDir, "skills"));
         console.log("\n[gemini]");
+        console.log(`   状态: ${geminiState.state}`);
         console.log(`   路径: ${agentDir}`);
-        console.log(`   Agents: ${agentsCount}`);
-        console.log(`   Skills: ${skillsCount}`);
-        console.log(`   Workflows: ${workflowsCount}`);
+        if (geminiState.state === "installed") {
+            console.log(`   Agents: ${agentsCount}`);
+            console.log(`   Skills: ${skillsCount}`);
+            console.log(`   Workflows: ${workflowsCount}`);
+        } else {
+            for (const issue of geminiState.integrity.issues || []) {
+                console.log(`   Issue: ${issue}`);
+            }
+        }
     }
 
-    if (installedTargets.includes("codex")) {
+    const codexState = summary.targets.find((item) => item.targetName === "codex");
+    if (codexState) {
         const managedDir = path.join(workspaceRoot, ".agents");
         const legacyDir = path.join(workspaceRoot, ".codex");
         const activeDir = fs.existsSync(managedDir) ? managedDir : legacyDir;
@@ -1266,13 +1748,21 @@ function commandStatus(options) {
         const hasManifest = fs.existsSync(path.join(activeDir, "manifest.json"));
         const legacyDetected = fs.existsSync(legacyDir);
         console.log("\n[codex]");
+        console.log(`   状态: ${codexState.state}`);
         console.log(`   路径: ${activeDir}`);
         console.log(`   Skills: ${skillsCount}`);
         console.log(`   Manifest: ${hasManifest ? "yes" : "no"}`);
         if (legacyDetected) {
             console.log("   Legacy: 检测到 .codex（建议执行 ag-kit update 迁移清理）");
         }
+        if (codexState.state !== "installed") {
+            for (const issue of codexState.integrity.issues || []) {
+                console.log(`   Issue: ${issue}`);
+            }
+        }
     }
+
+    setQuietStatusExitCode(summary.state);
 }
 
 async function main() {
@@ -1314,6 +1804,11 @@ async function main() {
             return;
         }
 
+        if (command === "global") {
+            await commandGlobal(options);
+            return;
+        }
+
         if (command === "exclude") {
             commandExclude(options);
             return;

package/bin/core/builder.js

@@ -9,7 +9,7 @@ const pkg = require("../../package.json");
 class CodexBuilder {
     /**
      * Build a Codex structure from a legacy/source repository
-     * @param {string} sourceRoot Root of the repo (containing .agent/)
+     * @param {string} sourceRoot Root of the repo (containing .agents/)
      * @param {string} outputDir Directory to output the built .agents-compatible structure
      */
     static build(sourceRoot, outputDir) {