@mison/ling 1.1.1 → 1.2.0

package/docs/PLAN.md

@@ -12,15 +12,17 @@
 ### 项目安装（功能最完整）
 - 命令：`ling init` / `ling update` / `ling status` / `ling doctor`
 - 目标输出：
-  - `gemini` -> 项目内 `.agent/`（兼容 Gemini/Antigravity 工作区规范）
+  - `gemini` -> 项目内 `.agent/`
+  - `antigravity` -> 项目内 `.agent/`（与 Gemini 复用工作区目录，但命令与注册独立）
   - `codex` -> 项目内 `.agents/`（受管目录）+ 注入工作区 `AGENTS.md` / `ling.rules` 托管区块
 
 ### 全局安装（跨项目复用 Skills）
 - 命令：`ling global sync` / `ling global status`
-- 默认行为：`ling global sync` 未指定 `--target/--targets` 时，同步 `codex + gemini`
+- 默认行为：`ling global sync` 未指定 `--target/--targets` 时，同步 `codex + gemini + antigravity`
 - 目标路径：
   - `codex` -> `$HOME/.codex/skills/`
-  - `gemini` -> 同时写入 `$HOME/.gemini/skills/` 与 `$HOME/.gemini/antigravity/skills/`
+  - `gemini` -> `$HOME/.gemini/skills/`
+  - `antigravity` -> `$HOME/.gemini/antigravity/skills/`
 - 安全边界：全局只同步 Skills，不写入全局 Rules/Agents/Workflows。
 
 ## 覆盖与回滚（全局同步）
@@ -28,27 +30,29 @@
 - 覆盖策略：只覆盖同名 Skill；不清理用户已有的其他 Skill。
 - 覆盖前备份：每次覆盖同名 Skill 前备份到 `$HOME/.ling/backups/global/<timestamp>/...`。
 
-## Spec Profile（可选进阶层）
+## Spec（核心进阶层）
 ### 当前阶段已落地
-- 命令：`ling spec enable` / `ling spec disable` / `ling spec status`
 - 默认关闭，必须显式启用
-- 当前只开放全局层，不进入项目级注入
-- 目标资源：
-  - Skills：`harness-engineering`、`cybernetic-systems-engineering`
-  - Templates：`$HOME/.ling/spec/templates/`
-  - References：`$HOME/.ling/spec/references/`
-- 回退原则：启用前先备份同名资源；停用时优先恢复原资源
-
-### 后续阶段
-- 项目级 `spec init / remove / doctor`
-- `.spec/profiles/` 的项目投影与可逆注入
+- 全局层（机器级）命令：`ling spec enable` / `ling spec disable` / `ling spec status`
+  - 目标资源：
+    - Skills：`harness-engineering`、`cybernetic-systems-engineering`
+    - Templates：`$HOME/.ling/spec/templates/`
+    - References：`$HOME/.ling/spec/references/`
+    - Profiles：`$HOME/.ling/spec/profiles/`
+  - 回退原则：启用前先备份同名资源；停用时优先恢复原资源
+- 项目层（工作区级）命令：`ling spec init` / `ling spec doctor`
+  - 默认作用于当前目录；`--spec-workspace` 才会使用 `$HOME/.ling/spec-workspace`
+  - 完整模式：写入 `.ling/spec/`、`issues.csv`、`docs/reviews/`、`docs/handoff/`
+  - 轻量模式：`--csv-only` 只写入 `issues.csv` 与 `docs/*`，项目内不落地 `.ling/spec/`
+  - 可选：通过 `--target/--targets` 同时安装 `.agent/.agents`
 
 ## 兼容策略
-- Gemini/Antigravity：输出 `.agent/`，保持与官方工作区机制一致。
+- Gemini/Antigravity：项目级继续输出 `.agent/`，保持与官方工作区机制一致；命令、状态、索引按独立目标处理。
+- 为避免共享 `.agent/` 丢失逻辑目标身份，工作区额外维护 `.ling/install-state.json`。
 - Codex：受管目录为 `.agents/`，并使用 `manifest.json` 做完整性与漂移检测；识别并迁移遗留 `.codex/`。
 - 全局同步遵循真实消费端目录，而不是仓库模板源目录；仓库内仍以 `.agents/` 作为唯一 Canonical。
 
 ## 成功标准
-- `ling global sync` 一条命令即可完成全局 Skills 安装/更新（默认 codex + gemini，其中 gemini 同步到 gemini-cli 与 antigravity）。
+- `ling global sync` 一条命令即可完成全局 Skills 安装/更新（默认 codex + gemini + antigravity）。
 - 覆盖可回滚：每次覆盖同名 Skill 都有可用备份。
 - 跨平台 CI（Linux/macOS/Windows）验证主链路通过。

package/docs/TECH.md

@@ -12,14 +12,16 @@ cd web && npm install && npm run lint
 ## 核心目录与职责
 - `.agents/`：仓库模板源（Canonical）
 - `bin/ling.js`：CLI 入口与命令分发
-- `bin/adapters/`：目标差异（`gemini` / `codex`）
+- `bin/adapters/`：目标差异（`gemini` / `antigravity` / `codex`）
 - `bin/core/`：构建/转换（将 Workflows 投影为 Codex Skills 等）
 - `bin/utils/`：原子写入、manifest、托管区块等通用能力
 
 ## 路径映射（最重要）
 ### 项目级（功能最完整）
 - `gemini`：项目根目录 `.agent/`
+- `antigravity`：项目根目录 `.agent/`（与 Gemini 复用目录，但索引与状态独立）
 - `codex`：项目根目录 `.agents/`（受管）+ `.agents-backup/`（漂移覆盖备份）
+- 工作区安装状态：共享 `.agent/` 目标时写入项目根目录 `.ling/install-state.json`（记录逻辑目标注册信息）
 - 项目级预备份（覆盖前快照）：
   - Gemini：`<project>/.agent-backup/<timestamp>/preflight/.agent/`
   - Codex：`<project>/.agents-backup/<timestamp>/preflight/.agents/` 或 `<project>/.agents-backup/<timestamp>/preflight/.codex/`
@@ -33,13 +35,14 @@ cd web && npm install && npm run lint
 
 ## 端到端链路（简述）
 ### 项目安装 / 更新
-- `init`：选择目标 -> 适配器 `install()` -> 落盘目标目录（Gemini: `.agent/`；Codex: `.agents/`）->（Codex）注入托管区块到工作区 `AGENTS.md` 与 `ling.rules`
+- `init`：选择目标 -> 适配器 `install()` -> 落盘目标目录（Gemini/Antigravity: `.agent/`；Codex: `.agents/`）->（Codex）注入托管区块到工作区 `AGENTS.md` 与 `ling.rules`
 - `update`：自动检测已安装目标（或通过 `--target/--targets` 指定）->（冲突时交互确认或默认预备份）-> 适配器 `update()` ->（Codex）漂移检测与备份 -> 原子替换
+- 共享 `.agent/` 的 `gemini` / `antigravity` 身份优先从 `.ling/install-state.json` 读取；若缺失则回退到工作区索引，再回退为历史默认 `gemini`
 - `doctor`：检查完整性；`--fix` 尝试修复（Codex 支持迁移 `.codex/` 与重写托管区块）
 
 ### 已有资产冲突处理（项目级）
 - 触发条件：
-  - `gemini`：`.agent/` 已存在且与内置模板不一致
+  - `gemini` / `antigravity`：`.agent/` 已存在且与内置模板不一致
   - `codex`：`.agents/` 或 `.codex/` 已存在且存在漂移、缺失 `manifest.json` 或包含未知文件
 - 交互终端会逐项询问处理方式：保留 / 备份后移除 / 直接移除，并支持按资产类别复用选择
 - 非交互环境不会进入询问：需要覆盖时默认执行“备份后覆盖”；`init` 若检测到已有资产且未显式 `--force` 则报错
@@ -51,8 +54,8 @@ cd web && npm install && npm run lint
 
 ## 全局同步：`ling global sync/status`
 ### 默认目标
-- 未指定 `--target/--targets`：默认同步 `codex + gemini`
-- `--target gemini` / `--targets codex,gemini` 中的 `gemini` 会同时写入 gemini-cli 与 antigravity 两个消费端目录
+- 未指定 `--target/--targets`：默认同步 `codex + gemini + antigravity`
+- `--target gemini` 只写入 gemini-cli；`--target antigravity` 只写入 antigravity
 
 ### 来源与覆盖策略
 - 来源：默认使用本包内置 `.agents/`；也可用 `--branch <name>` 从远端分支拉取模板源
@@ -65,22 +68,31 @@ cd web && npm install && npm run lint
 ### 测试隔离
 - `LING_GLOBAL_ROOT`：替代 `$HOME`（用于测试与 CI，避免污染真实用户目录）
 
-## Spec Profile：`ling spec ...`
+## Spec：`ling spec ...`
 ### 当前范围
 - 全局 Spec Profile（机器级）：
-  - `ling spec enable [--target codex|gemini] [--dry-run] [--quiet]`
-  - `ling spec disable [--target codex|gemini] [--dry-run] [--quiet]`
+  - `ling spec enable [--target codex|gemini|antigravity] [--dry-run] [--quiet]`
+  - `ling spec disable [--target codex|gemini|antigravity] [--dry-run] [--quiet]`
   - `ling spec status [--quiet]`
-  - 默认目标：未指定 `--target/--targets` 时启用 `codex + gemini`
+  - 默认目标：未指定 `--target/--targets` 时启用 `codex + gemini + antigravity`
 - 项目级 Spec 资产（工作区级）：
-  - `ling spec init [--path <dir>] [--target codex|gemini|--targets codex,gemini] [--branch <name>] [--dry-run] [--quiet]`
-    - 未指定 `--path` 时，默认初始化 Spec 工作区目录：`$HOME/.ling/spec-workspace`
+  - `ling spec init [--path <dir>] [--spec-workspace] [--csv-only] [--target codex|gemini|antigravity|--targets codex,gemini,antigravity] [--branch <name>] [--dry-run] [--quiet]`
+    - 默认初始化当前目录
+    - `--path <dir>`：初始化指定项目目录
+    - `--spec-workspace`：初始化 `$HOME/.ling/spec-workspace`（本机独立演练工作区，默认会包含 `.agent/.agents`）
     - 指定 `--targets` 时，会同时执行对应目标的 `ling init` 安装（`.agent/.agents`）
     - 指定 `--branch` 时，Spec 资产将从该分支的 `.spec/` 拉取（用于验证或灰度 Spec 模板）
-  - `ling spec doctor [--path <dir>] [--quiet]`
-    - 会校验 `issues.csv` 表头与状态枚举，并检查 `.ling/spec/` 目录是否完整
+    - `--csv-only`：仅生成 `issues.csv` 与 `docs/*`，不写入 `.ling/spec/`（适用于依赖全局 Spec 模板的项目）
+  - `ling spec doctor [--path <dir>] [--spec-workspace] [--quiet]`
+    - 会校验 `issues.csv` 表头与状态枚举
+    - 当项目缺少 `.ling/spec/` 但已启用全局 Spec 时，会使用全局 Spec 资产作为后备
 - Spec 源目录：`.spec/`
 
+### 心智模型
+- `ling spec enable`：给这台电脑安装 Spec 工具箱
+- `ling spec init`：给当前项目创建真正要用的 `issues.csv`
+- `issues.csv` 永远在项目根目录；全局 Spec 不保存项目任务
+
 ### 落盘与状态
 - Spec 状态文件：`$HOME/.ling/spec/state.json`
 - Spec templates：`$HOME/.ling/spec/templates/`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mison/ling",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "面向 Gemini CLI、Antigravity 与 Codex 的中文 AI Agent 模板工具包",
   "repository": {
     "type": "git",

package/scripts/ci-verify.js

@@ -51,13 +51,16 @@ function main() {
         LING_GLOBAL_ROOT: globalRoot,
     };
 
-    runCli(["init", "--targets", "gemini,codex", "--path", workspaceDir, "--quiet"], { env });
+    runCli(["init", "--targets", "gemini,antigravity,codex", "--path", workspaceDir, "--quiet"], { env });
 
     const status = runCli(["status", "--path", workspaceDir, "--quiet"], { env }).trim();
     if (status !== "installed") {
         throw new Error(`status 结果异常: ${status}`);
     }
 
+    const installStatePath = path.join(workspaceDir, ".ling", "install-state.json");
+    ensureExists(installStatePath, "工作区安装状态文件");
+
     runCli(["doctor", "--path", workspaceDir, "--quiet"], { env });
     runCli(["update", "--path", workspaceDir, "--quiet"], { env });
     runCli(["update-all", "--dry-run", "--quiet"], { env });

package/scripts/health-check.js

@@ -48,17 +48,12 @@ function main() {
         throw new Error("缺少命令: node");
     }
 
-    const packageRunner = commandExists("bun --version") ? "bun" : "npm";
-    if (!commandExists(`${packageRunner} --version`)) {
-        throw new Error(`缺少命令: ${packageRunner}`);
+    if (!commandExists("npm --version")) {
+        throw new Error("缺少命令: npm");
     }
 
     logStep("执行测试套件");
-    if (packageRunner === "bun") {
-        runCommand("bun run test");
-    } else {
-        runCommand("npm test --silent");
-    }
+    runCommand("npm test --silent");
 
     logStep("验证 CLI 核心链路");
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ling-health-check-"));
@@ -132,11 +127,7 @@ function main() {
     }
 
     logStep("执行清理预检");
-    if (packageRunner === "bun") {
-        runCommand("bun run clean:dry-run");
-    } else {
-        runCommand("npm run clean:dry-run --silent");
-    }
+    runCommand("npm run clean:dry-run --silent");
 
     console.log("[ok] 健康检查通过");
 }

package/tests/cli-smoke.test.js

@@ -338,6 +338,78 @@ describe("CLI Smoke", () => {
         assert.ok(fs.existsSync(path.join(tsDir, "preflight", ".agent", "custom.txt")));
     });
 
+    test("init should allow registering antigravity independently on shared .agent", () => {
+        const localWorkspace = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-antigravity-init-"));
+        try {
+            const result = runCli(
+                ["init", "--target", "antigravity", "--path", localWorkspace, "--quiet"],
+                { env: { LING_INDEX_PATH: indexPath } },
+            );
+            assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+            assert.ok(fs.existsSync(path.join(localWorkspace, ".agent")), "shared .agent should be created");
+
+            const indexData = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+            const record = (indexData.workspaces || []).find((item) => item.path === localWorkspace);
+            assert.ok(record, "workspace should be indexed");
+            assert.ok(record.targets && record.targets.antigravity, "antigravity target should be indexed");
+            assert.ok(!record.targets.gemini, "gemini target should not be auto-indexed");
+        } finally {
+            fs.rmSync(localWorkspace, { recursive: true, force: true });
+        }
+    });
+
+    test("status should reflect antigravity target when workspace is registered as antigravity", () => {
+        const localWorkspace = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-antigravity-status-"));
+        try {
+            const initResult = runCli(
+                ["init", "--target", "antigravity", "--path", localWorkspace, "--quiet"],
+                { env: { LING_INDEX_PATH: indexPath } },
+            );
+            assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+            const result = runCli(
+                ["status", "--path", localWorkspace],
+                { env: { LING_INDEX_PATH: indexPath } },
+            );
+            assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+            assert.match(result.stdout || "", /Targets: antigravity/);
+            assert.match(result.stdout || "", /\[antigravity\]/);
+            assert.doesNotMatch(result.stdout || "", /\[gemini\]/);
+        } finally {
+            fs.rmSync(localWorkspace, { recursive: true, force: true });
+        }
+    });
+
+    test("antigravity status should remain correct without index via local install-state", () => {
+        const localWorkspace = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-antigravity-no-index-"));
+        try {
+            const initResult = runCli(
+                ["init", "--target", "antigravity", "--path", localWorkspace, "--no-index", "--quiet"],
+                { env: { LING_INDEX_PATH: indexPath } },
+            );
+            assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+            const installStatePath = path.join(localWorkspace, ".ling", "install-state.json");
+            assert.ok(fs.existsSync(installStatePath), "local install-state should be created");
+
+            const result = runCli(
+                ["status", "--path", localWorkspace],
+                { env: { LING_INDEX_PATH: indexPath } },
+            );
+            assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+            assert.match(result.stdout || "", /Targets: antigravity/);
+            assert.match(result.stdout || "", /\[antigravity\]/);
+
+            if (fs.existsSync(indexPath)) {
+                const indexData = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+                const hasWorkspace = (indexData.workspaces || []).some((item) => item.path === localWorkspace);
+                assert.ok(!hasWorkspace, "workspace should still be absent from global index");
+            }
+        } finally {
+            fs.rmSync(localWorkspace, { recursive: true, force: true });
+        }
+    });
+
     test("update should create preflight backup for codex when unknown files exist in managed dir", () => {
         const initResult = runCli(
             ["init", "--target", "codex", "--path", workspaceDir, "--quiet"],
@@ -502,6 +574,49 @@ describe("CLI Smoke", () => {
         }
     });
 
+    test("update-all should allow explicit antigravity target on shared .agent workspace", () => {
+        const localWorkspace = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-update-all-antigravity-"));
+        try {
+            const initResult = runCli(
+                ["init", "--target", "gemini", "--path", localWorkspace, "--quiet"],
+                { env: { LING_INDEX_PATH: indexPath } },
+            );
+            assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+            const now = new Date().toISOString();
+            const seedIndex = {
+                version: 2,
+                updatedAt: now,
+                workspaces: [
+                    {
+                        path: localWorkspace,
+                        targets: {
+                            gemini: {
+                                version: "2.0.1",
+                                installedAt: now,
+                                updatedAt: now,
+                            },
+                        },
+                    },
+                ],
+                excludedPaths: [],
+            };
+            fs.writeFileSync(indexPath, `${JSON.stringify(seedIndex, null, 2)}\n`, "utf8");
+
+            const result = runCli(["update-all", "--targets", "antigravity", "--quiet"], {
+                env: { LING_INDEX_PATH: indexPath },
+            });
+            assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+            const indexData = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+            const record = (indexData.workspaces || []).find((item) => item.path === localWorkspace);
+            assert.ok(record, "workspace should remain in index");
+            assert.ok(record.targets && record.targets.antigravity, "antigravity target should be added into index");
+        } finally {
+            fs.rmSync(localWorkspace, { recursive: true, force: true });
+        }
+    });
+
     test("init should respect --no-index on non-temp workspace", () => {
         const localWorkspace = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-no-index-"));
         try {

package/tests/global-sync.test.js

@@ -63,7 +63,7 @@ describe("Global Sync", () => {
         assert.ok(fs.existsSync(path.join(skillsRoot, "workflow-plan", "SKILL.md")), "missing expected workflow skill: workflow-plan");
     });
 
-    test("global sync should default to syncing codex and gemini when no target is provided", () => {
+    test("global sync should default to syncing codex, gemini, and antigravity when no target is provided", () => {
         const result = runCli(["global", "sync", "--quiet"], {
             env: { LING_GLOBAL_ROOT: tempDir },
         });
@@ -93,7 +93,7 @@ describe("Global Sync", () => {
         assert.strictEqual((statusResult.stdout || "").trim(), "installed");
     });
 
-    test("global sync should install gemini skills into both ~/.gemini/skills and ~/.gemini/antigravity/skills", () => {
+    test("global sync should install gemini skills only into ~/.gemini/skills", () => {
         const result = runCli(["global", "sync", "--target", "gemini", "--quiet"], {
             env: { LING_GLOBAL_ROOT: tempDir },
         });
@@ -103,6 +103,19 @@ describe("Global Sync", () => {
         assert.ok(fs.existsSync(geminiCliRoot), "missing global gemini-cli skills root");
         assert.ok(fs.existsSync(path.join(geminiCliRoot, "clean-code", "SKILL.md")), "missing expected gemini-cli skill: clean-code");
 
+        const antigravityRoot = path.join(tempDir, ".gemini", "antigravity", "skills");
+        assert.ok(!fs.existsSync(antigravityRoot), "gemini sync should not create antigravity skills root");
+    });
+
+    test("global sync should install antigravity skills only into ~/.gemini/antigravity/skills", () => {
+        const result = runCli(["global", "sync", "--target", "antigravity", "--quiet"], {
+            env: { LING_GLOBAL_ROOT: tempDir },
+        });
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const geminiCliRoot = path.join(tempDir, ".gemini", "skills");
+        assert.ok(!fs.existsSync(geminiCliRoot), "antigravity sync should not create gemini-cli skills root");
+
         const antigravityRoot = path.join(tempDir, ".gemini", "antigravity", "skills");
         assert.ok(fs.existsSync(antigravityRoot), "missing global antigravity skills root");
         assert.ok(fs.existsSync(path.join(antigravityRoot, "clean-code", "SKILL.md")), "missing expected antigravity skill: clean-code");

package/tests/spec-init-doctor.test.js

@@ -62,6 +62,64 @@ describe("Spec init/doctor", () => {
         assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
     });
 
+    test("spec init --csv-only should generate issues.csv and rely on global spec assets", () => {
+        const env = {
+            LING_GLOBAL_ROOT: tempRoot,
+            LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        };
+
+        const enableResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const initResult = runCli(["spec", "init", "--path", workspaceRoot, "--csv-only", "--quiet"], { env });
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "issues.csv")), "issues.csv should be created");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "docs", "reviews")), "docs/reviews should exist");
+        assert.ok(fs.existsSync(path.join(workspaceRoot, "docs", "handoff")), "docs/handoff should exist");
+        assert.ok(!fs.existsSync(path.join(workspaceRoot, ".ling", "spec")), "spec assets should not be created in csv-only mode");
+
+        const doctorResult = runCli(["spec", "doctor", "--path", workspaceRoot, "--quiet"], { env });
+        assert.strictEqual(doctorResult.status, 0, doctorResult.stderr || doctorResult.stdout);
+        assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
+    });
+
+    test("spec init without --path should initialize default spec-workspace and include targets", () => {
+        const nonTempRoot = fs.mkdtempSync(path.join(REPO_ROOT, ".tmp-ling-spec-global-"));
+        const indexPath = path.join(nonTempRoot, "workspaces.json");
+        const env = {
+            LING_GLOBAL_ROOT: nonTempRoot,
+            LING_INDEX_PATH: indexPath,
+        };
+
+        try {
+            const initResult = runCli(["spec", "init", "--spec-workspace", "--quiet"], { env });
+            assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+            const defaultWorkspace = path.join(nonTempRoot, ".ling", "spec-workspace");
+            assert.ok(fs.existsSync(path.join(defaultWorkspace, "issues.csv")), "default workspace should include issues.csv");
+            assert.ok(
+                fs.existsSync(path.join(defaultWorkspace, ".ling", "spec", "templates", "driver-prompt.md")),
+                "default workspace should include spec templates",
+            );
+            assert.ok(fs.existsSync(path.join(defaultWorkspace, ".agent")), "default workspace should include gemini .agent");
+            assert.ok(fs.existsSync(path.join(defaultWorkspace, ".agents")), "default workspace should include codex .agents");
+
+            const doctorResult = runCli(["spec", "doctor", "--spec-workspace", "--quiet"], { env });
+            assert.strictEqual(doctorResult.status, 0, doctorResult.stderr || doctorResult.stdout);
+            assert.strictEqual((doctorResult.stdout || "").trim(), "installed");
+
+            assert.ok(fs.existsSync(indexPath), "workspace index should be created for non-temp global root");
+            const index = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+            assert.ok(
+                (index.workspaces || []).some((workspace) => workspace && workspace.path === defaultWorkspace),
+                "default spec-workspace should be registered into index",
+            );
+        } finally {
+            fs.rmSync(nonTempRoot, { recursive: true, force: true });
+        }
+    });
+
     test("spec doctor should report broken when multiple tasks are in 进行中", () => {
         const env = {
             LING_GLOBAL_ROOT: tempRoot,

package/tests/spec-profile.test.js

@@ -114,6 +114,22 @@ describe("Spec Profile", () => {
         assert.ok(fs.existsSync(path.join(codexSkillDir, "SKILL.md")), "spec skill should be repaired");
     });
 
+    test("spec enable should install antigravity skills independently", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+
+        const enableResult = runCli(["spec", "enable", "--target", "antigravity", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const antigravitySkill = path.join(tempRoot, ".gemini", "antigravity", "skills", "harness-engineering", "SKILL.md");
+        const geminiSkill = path.join(tempRoot, ".gemini", "skills", "harness-engineering", "SKILL.md");
+        assert.ok(fs.existsSync(antigravitySkill), "missing installed antigravity spec skill");
+        assert.ok(!fs.existsSync(geminiSkill), "antigravity spec enable should not install gemini skill");
+
+        const statusResult = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(statusResult.status, 0);
+        assert.strictEqual((statusResult.stdout || "").trim(), "installed");
+    });
+
     test("spec status should report broken when an asset file is missing", () => {
         const env = { LING_GLOBAL_ROOT: tempRoot };
 

package/tests/standards-compliance.test.js

@@ -144,6 +144,37 @@ describe('Standards Compliance', () => {
         assert.ok(!content.includes('$HOME/.agents/skills/'), 'should not contain deprecated global path: $HOME/.agents/skills/');
     });
 
+    test('README spec section should reflect implemented spec commands', () => {
+        const file = path.resolve('README.md');
+        const content = fs.readFileSync(file, 'utf8');
+
+        assert.ok(content.includes('ling spec init'), 'README should mention ling spec init');
+        assert.ok(content.includes('ling spec doctor'), 'README should mention ling spec doctor');
+        assert.ok(content.includes('~/.ling/spec/profiles/'), 'README should mention spec profiles path');
+        assert.ok(!content.includes('本版本尚未开放'), 'README should not claim spec project commands are unavailable');
+        assert.ok(!content.includes('spec init/remove/doctor'), 'README should not mention unsupported spec remove subcommand');
+    });
+
+    test('docs should describe gemini and antigravity as separate command targets', () => {
+        const readme = fs.readFileSync(path.resolve('README.md'), 'utf8');
+        const tech = fs.readFileSync(path.resolve('docs/TECH.md'), 'utf8');
+
+        assert.ok(readme.includes('ling init --target antigravity'), 'README should document project antigravity target');
+        assert.ok(readme.includes('ling global sync --target antigravity'), 'README should document global antigravity target');
+        assert.ok(tech.includes('`--target gemini` 只写入 gemini-cli；`--target antigravity` 只写入 antigravity'), 'TECH should describe split global targets');
+        assert.ok(!tech.includes('gemini 会同时写入 gemini-cli 与 antigravity'), 'TECH should not describe gemini as bundled antigravity target');
+    });
+
+    test('gitignore should whitelist curated reference materials only', () => {
+        const rootIgnore = fs.readFileSync(path.resolve('.gitignore'), 'utf8');
+        const referenceIgnore = fs.readFileSync(path.resolve('reference/.gitignore'), 'utf8');
+
+        assert.ok(rootIgnore.includes('!reference/official/**'), 'root .gitignore should keep reference/official tracked');
+        assert.ok(rootIgnore.includes('!reference/docs-archive/**'), 'root .gitignore should keep reference/docs-archive tracked');
+        assert.ok(referenceIgnore.includes('!official/**'), 'reference/.gitignore should keep official subtree tracked');
+        assert.ok(referenceIgnore.includes('!docs-archive/**'), 'reference/.gitignore should keep docs-archive subtree tracked');
+    });
+
     test('.agents script files should stay identical to reference snapshot', { skip: !HAS_REF_SCRIPTS_ROOT }, () => {
         const refScriptsRoot = REF_SCRIPTS_ROOT;
         const mismatches = [];