@mison/ag-kit-cn 2.0.1

package/bin/utils/managed-block.js

@@ -0,0 +1,65 @@
+const fs = require("fs");
+const path = require("path");
+
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function detectLineEnding(content) {
+    return content.includes("\r\n") ? "\r\n" : "\n";
+}
+
+function buildMarkers(blockId) {
+    const id = String(blockId || "default").trim();
+    return {
+        begin: `<!-- BEGIN AG-KIT MANAGED BLOCK: ${id} -->`,
+        end: `<!-- END AG-KIT MANAGED BLOCK: ${id} -->`,
+    };
+}
+
+function buildManagedBlock(blockId, body, lineEnding = "\n") {
+    const markers = buildMarkers(blockId);
+    const normalizedBody = String(body || "").replace(/\r?\n/g, lineEnding).trimEnd();
+    return `${markers.begin}${lineEnding}${normalizedBody}${lineEnding}${markers.end}`;
+}
+
+function upsertManagedBlock(filePath, blockId, body, options = {}) {
+    const dryRun = Boolean(options.dryRun);
+    const original = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+    const lineEnding = detectLineEnding(original);
+    const managedBlock = buildManagedBlock(blockId, body, lineEnding);
+    const markers = buildMarkers(blockId);
+    const blockRegex = new RegExp(
+        `${escapeRegex(markers.begin)}[\\s\\S]*?${escapeRegex(markers.end)}`,
+        "m",
+    );
+
+    let next = "";
+    let action = "unchanged";
+
+    if (!original) {
+        next = `${managedBlock}${lineEnding}`;
+        action = "created";
+    } else if (blockRegex.test(original)) {
+        next = original.replace(blockRegex, managedBlock);
+        action = next === original ? "unchanged" : "updated";
+        if (next && !/\r?\n$/.test(next)) {
+            next += lineEnding;
+        }
+    } else {
+        next = `${original.replace(/\r?\n?$/, "")}${lineEnding}${lineEnding}${managedBlock}${lineEnding}`;
+        action = "appended";
+    }
+
+    if (!dryRun && action !== "unchanged") {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, next, "utf8");
+    }
+
+    return { action };
+}
+
+module.exports = {
+    buildManagedBlock,
+    upsertManagedBlock,
+};

package/bin/utils/manifest.js

@@ -0,0 +1,241 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+class ManifestManager {
+    constructor(manifestPath, options = {}) {
+        this.manifestPath = manifestPath;
+        this.options = options;
+        this.manifest = {
+            version: 2,
+            target: typeof options.target === "string" ? options.target : "",
+            kitVersion: typeof options.kitVersion === "string" ? options.kitVersion : "",
+            updatedAt: "",
+            files: {},
+        };
+    }
+
+    /**
+     * Compute SHA-256 hash of a string or buffer
+     * @param {string|Buffer} content 
+     * @returns {string} sha256 hash
+     */
+    static computeHash(content) {
+        return crypto.createHash("sha256").update(content).digest("hex");
+    }
+
+    static normalizeFileEntry(entry) {
+        if (typeof entry === "string") {
+            return { hash: entry, source: "" };
+        }
+        if (!entry || typeof entry !== "object") {
+            return null;
+        }
+        const hash = typeof entry.hash === "string" ? entry.hash : "";
+        const source = typeof entry.source === "string" ? entry.source : "";
+        if (!hash) {
+            return null;
+        }
+        return { hash, source };
+    }
+
+    static extractHash(entry) {
+        if (typeof entry === "string") {
+            return entry;
+        }
+        if (entry && typeof entry === "object" && typeof entry.hash === "string") {
+            return entry.hash;
+        }
+        return "";
+    }
+
+    static normalizeManifestShape(input) {
+        const output = {
+            version: typeof input.version === "number" ? input.version : 2,
+            target: typeof input.target === "string" ? input.target : "",
+            kitVersion: typeof input.kitVersion === "string" ? input.kitVersion : "",
+            updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : "",
+            files: {},
+        };
+
+        if (!input.files || typeof input.files !== "object") {
+            return output;
+        }
+
+        for (const [relPath, entry] of Object.entries(input.files)) {
+            const normalized = ManifestManager.normalizeFileEntry(entry);
+            if (!normalized) {
+                continue;
+            }
+            output.files[relPath] = normalized;
+        }
+
+        return output;
+    }
+
+    /**
+     * Load manifest from disk
+     */
+    load() {
+        if (fs.existsSync(this.manifestPath)) {
+            try {
+                const raw = fs.readFileSync(this.manifestPath, "utf8");
+                this.manifest = ManifestManager.normalizeManifestShape(JSON.parse(raw));
+            } catch (err) {
+                this.manifest = {
+                    version: 2,
+                    target: typeof this.options.target === "string" ? this.options.target : "",
+                    kitVersion: typeof this.options.kitVersion === "string" ? this.options.kitVersion : "",
+                    updatedAt: "",
+                    files: {},
+                };
+            }
+        }
+        return this.manifest;
+    }
+
+    /**
+     * Save manifest to disk
+     */
+    save() {
+        this.manifest.updatedAt = new Date().toISOString();
+        if (!this.manifest.target && this.options.target) {
+            this.manifest.target = this.options.target;
+        }
+        if (!this.manifest.kitVersion && this.options.kitVersion) {
+            this.manifest.kitVersion = this.options.kitVersion;
+        }
+        const dir = path.dirname(this.manifestPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(this.manifestPath, `${JSON.stringify(this.manifest, null, 2)}\n`, "utf8");
+    }
+
+    /**
+     * Generate manifest entries from a directory recursively
+     * @param {string} rootDir Directory to scan
+     * @param {string} [baseDir] Base directory for relative paths (default: rootDir)
+     * @returns {object} { file: hash } map
+     */
+    static generateFromDir(rootDir, baseDir = rootDir) {
+        const entries = ManifestManager.generateFileEntriesFromDir(rootDir, {
+            baseDir,
+        });
+        const hashes = {};
+        for (const [relPath, entry] of Object.entries(entries)) {
+            hashes[relPath] = entry.hash;
+        }
+        return hashes;
+    }
+
+    /**
+     * Generate managed file entries from a directory recursively
+     * @param {string} rootDir Directory to scan
+     * @param {object} options
+     * @param {string} [options.baseDir=rootDir] Base directory for relative paths
+     * @param {string} [options.sourcePrefix=""] Prefix recorded in `source` field
+     * @returns {object} { file: { hash, source } } map
+     */
+    static generateFileEntriesFromDir(rootDir, options = {}) {
+        const baseDir = options.baseDir || rootDir;
+        const sourcePrefix = typeof options.sourcePrefix === "string" ? options.sourcePrefix.trim() : "";
+        const files = {};
+        
+        function scan(dir) {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    scan(fullPath);
+                } else if (entry.isFile()) {
+                    const content = fs.readFileSync(fullPath);
+                    const hash = ManifestManager.computeHash(content);
+                    const relPath = path.relative(baseDir, fullPath).split(path.sep).join("/");
+                    files[relPath] = {
+                        hash,
+                        source: sourcePrefix ? `${sourcePrefix}/${relPath}` : relPath,
+                    };
+                }
+            }
+        }
+        
+        if (fs.existsSync(rootDir)) {
+            scan(rootDir);
+        }
+        return files;
+    }
+
+    /**
+     * Compare existing manifest with current file system state to detect user changes
+     * @param {string} projectRoot 
+     * @returns {object} { modified: [], missing: [], unknown: [] } 
+     */
+    checkDrift(projectRoot) {
+        // This checks if the files listed in the manifest (which should match what we installed)
+        // still match what is currently on disk.
+        // Useful for doctor or update pre-check.
+        const drift = {
+            modified: [], // Hash mismatch
+            missing: [],  // File in manifest but not on disk
+        };
+
+        for (const [relPath, entry] of Object.entries(this.manifest.files || {})) {
+            const expectedHash = ManifestManager.extractHash(entry);
+            if (!expectedHash) {
+                continue;
+            }
+            const absPath = path.join(projectRoot, relPath);
+            if (!fs.existsSync(absPath)) {
+                drift.missing.push(relPath);
+            } else {
+                const content = fs.readFileSync(absPath);
+                const currentHash = ManifestManager.computeHash(content);
+                if (currentHash !== expectedHash) {
+                    drift.modified.push(relPath);
+                }
+            }
+        }
+        return drift;
+    }
+
+    /**
+     * Select user-modified files to backup during overwrite:
+     * currentHash != manifestHash AND currentHash != incomingHash
+     * @param {string} projectRoot
+     * @param {object} incomingFiles Next manifest files map
+     * @returns {string[]} relative file paths
+     */
+    collectSmartOverwriteConflicts(projectRoot, incomingFiles = {}) {
+        const modified = [];
+        const existingFiles = this.manifest.files || {};
+
+        for (const [relPath, manifestEntry] of Object.entries(existingFiles)) {
+            const expectedHash = ManifestManager.extractHash(manifestEntry);
+            if (!expectedHash) {
+                continue;
+            }
+
+            const absPath = path.join(projectRoot, relPath);
+            if (!fs.existsSync(absPath)) {
+                continue;
+            }
+
+            const currentHash = ManifestManager.computeHash(fs.readFileSync(absPath));
+            if (currentHash === expectedHash) {
+                continue;
+            }
+
+            const incomingHash = ManifestManager.extractHash(incomingFiles[relPath]);
+            if (incomingHash && currentHash === incomingHash) {
+                continue;
+            }
+
+            modified.push(relPath);
+        }
+
+        return modified;
+    }
+}
+
+module.exports = ManifestManager;

package/bin/utils.js

@@ -0,0 +1,82 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const REPO_URL = "https://github.com/MisonL/antigravity-kit-cn.git";
+
+function parseJsonSafe(raw) {
+    try {
+        return JSON.parse(raw);
+    } catch (err) {
+        return null;
+    }
+}
+
+function readGlobalNpmDependencies() {
+    const cmd = "npm ls --global --depth=0 --json --silent";
+    let output = "";
+
+    try {
+        output = execSync(cmd, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    } catch (err) {
+        output = typeof err.stdout === "string" ? err.stdout : "";
+    }
+
+    if (!output || output.trim() === "") {
+        return null;
+    }
+
+    const data = parseJsonSafe(output);
+    if (!data || typeof data !== "object") {
+        return null;
+    }
+
+    const deps = data.dependencies;
+    if (!deps || typeof deps !== "object") {
+        return {};
+    }
+
+    return deps;
+}
+
+function cloneBranchAgentDir(branch, options) {
+    const safeBranch = branch.trim();
+    if (!/^[A-Za-z0-9._/-]+$/.test(safeBranch)) {
+        throw new Error(`非法分支名: ${branch}`);
+    }
+
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-"));
+    const logFn = options && options.logger ? options.logger : console.log;
+
+    if (!options.quiet) logFn(`📥 正在从 ${REPO_URL} 拉取分支 ${safeBranch} ...`);
+
+    try {
+        execSync(`git clone --depth 1 --branch ${safeBranch} ${REPO_URL} "${tempDir}"`, {
+            stdio: options.quiet ? "ignore" : "pipe",
+        });
+    } catch (err) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        throw new Error(`无法拉取分支 ${safeBranch}，请确认分支存在且网络可用`);
+    }
+
+    const clonedAgentDir = path.join(tempDir, ".agent");
+    if (!fs.existsSync(clonedAgentDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        throw new Error(`分支 ${safeBranch} 中未找到 .agent 目录`);
+    }
+
+    return {
+        agentDir: clonedAgentDir,
+        cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true }),
+    };
+}
+
+module.exports = {
+    parseJsonSafe,
+    readGlobalNpmDependencies,
+    cloneBranchAgentDir
+};

package/docs/codex-rules-template.md

@@ -0,0 +1,36 @@
+# Codex `.rules` 模板（手动配置）
+
+> 用途：给 Codex 官方规则引擎提供命令审批策略。  
+> 注意：这不是 `antigravity.rules` 的替代品，二者职责不同。
+
+## 路径约定
+
+- 全局默认路径：`~/.codex/rules/default.rules`
+- 本项目不会自动写入该文件，请按需手动创建。
+
+## 最小模板（Starlark）
+
+```python
+# default.rules
+# 允许常见只读命令直接执行，其余命令走人工审批
+
+load("builtin://rules/rules.star", "prefix_rule")
+
+rules = [
+    prefix_rule(["ls"], action="allow"),
+    prefix_rule(["cat"], action="allow"),
+    prefix_rule(["rg"], action="allow"),
+    prefix_rule(["git", "status"], action="allow"),
+]
+```
+
+## 建议策略
+
+1. 先放行只读命令（`ls`/`cat`/`rg`/`git status`）。
+2. 对写操作、网络请求、脚本执行保持 `review` 或 `deny`。
+3. 团队场景下，将策略文件纳入内部安全评审流程。
+
+## 与 `antigravity.rules` 的关系
+
+- `antigravity.rules`：本仓库在工作区注入的托管说明内容，用于记录受管资源与运维约束。
+- `.rules`：Codex 官方可执行审批规则（Starlark），影响命令放行策略。

package/docs/mapping-spec.md

@@ -0,0 +1,68 @@
+# Codex（代码智能体环境）资源映射规范
+
+Codex（代码智能体环境）适配器包含一个内置的资源转换层（`bin/core/`），负责将通用的 Agent（智能体）能力描述、Skill（技能）与 Workflow（工作流）转换为 Codex 兼容的标准化格式。
+
+## 转换规则
+
+### 1. Skill（技能）
+
+- **源路径**: `.agent/skills/<name>/SKILL.md`
+- **Codex ID（标识）**: `<name>`（保持与上游技能名一致）
+- **目标路径**: `.agents/skills/<name>/SKILL.md`
+
+### 2. Workflow（工作流）
+
+- **源路径**: `.agent/workflows/<name>.md`
+- **Codex ID（标识）**: `workflow-<name>`
+- **目标路径**: `.agents/skills/workflow-<name>/SKILL.md`
+- **说明**: 工作流会转换为符合 Codex 规范的 `SKILL.md`（自动补齐 `name` / `description` Frontmatter（文档头元数据））。
+- **冲突处理**: 若生成 ID 与现有 Skill/Workflow 冲突，构建器会自动追加 `-2`、`-3`... 后缀，确保 ID 和目录唯一。
+
+## 托管文件生成
+
+### `codex.json` 元数据
+
+包含版本信息和所有资源的清单映射。
+
+### `AGENTS.md` 规则接入点
+
+自动生成的 Markdown 文件，列出所有 Capabilities（能力）并声明版本。
+安装/更新时，CLI（命令行界面）会把该内容注入工作区根目录 `AGENTS.md` 的托管区块中（不会覆盖用户自定义内容）。
+
+### `antigravity.rules` 风险控制
+
+自动生成风险控制规则，安装/更新时同样会注入工作区根目录 `antigravity.rules` 的托管区块。
+
+> 注意：这里的 `antigravity.rules` 是本项目的托管说明文件，不是 Codex 官方 `.rules` 审批策略文件。  
+> 如需配置 Codex 官方审批规则，请单独维护 `~/.codex/rules/default.rules`（参考 `docs/codex-rules-template.md`）。
+
+### `manifest.json` 托管清单
+
+用于完整性与漂移检测，核心结构如下：
+
+```json
+{
+  "version": 2,
+  "target": "codex",
+  "kitVersion": "2.0.1",
+  "files": {
+    "skills/example-skill/SKILL.md": {
+      "hash": "sha256...",
+      "source": "bundled/skills/example-skill/SKILL.md"
+    }
+  }
+}
+```
+
+覆盖策略：仅当当前文件 hash（哈希）同时满足 `当前文件 hash != manifest hash` 且 `当前文件 hash != 新版本 hash` 时，才会备份并覆盖。
+
+## 动态构建
+
+当使用 `ag-kit init --target codex` 安装旧版 Gemini 结构的仓库时，CLI 会自动触发 Just-in-Time Build（即时构建）流程：
+
+1. 克隆/读取源仓库。
+2. 识别为 Legacy（旧版）结构（`.agent/skills` 存在但无 `manifest.json`）。
+3. 在临时目录启动构建流水线。
+4. 将构建产物安装到项目的 `.agents` 目录（若检测到旧版 `.codex` 会自动迁移/清理）。
+
+此过程对用户透明。

package/docs/multi-target-adapter.md

@@ -0,0 +1,80 @@
+# 多目标适配器
+
+当前版本引入多目标适配器架构，支持在同一项目中共存并管理不同类型的 Agent（智能体）模板源。
+
+## 架构概览
+
+```mermaid
+graph TD
+    CLI[ag-kit CLI] --> Router[Target Router]
+    Router --> |target=gemini| Gemini[GeminiAdapter (.agent)]
+    Router --> |target=codex| Codex[CodexAdapter (.agents)]
+```
+
+## 支持的目标
+
+### 1. Gemini（旧版）
+
+- **标识**: `gemini`
+- **存储**: `.agent/`（直连模式）
+- **特点**: 轻量级，直接克隆自 Git 仓库或本地模板。
+- **适用**: 个人开发者、快速原型、不强制版本控制的场景。
+
+### 2. Codex（代码智能体环境）
+
+- **标识**: `codex`
+- **存储**:
+    - `.agents/`（托管上游，用户不可修改）
+    - `.agents-backup/`（发生覆盖冲突时自动备份）
+    - `AGENTS.md` / `antigravity.rules`（工作区托管区块注入）
+- **特点**:
+    - **Drift Detection（漂移检测）**: 自动识别用户对托管文件的修改。
+    - **Atomic Update（原子更新）**: 防止更新中断导致损坏。
+    - **资源映射**: 自动将标准 Skill（技能）/Workflow（工作流）转换为 Codex 规范。
+    - **遗留迁移**: 自动识别旧版 `.codex/` 并迁移到 `.agents/`。
+- **适用**: 团队协作、生产环境、需要严格版本管理和升级保障的场景。
+
+> 说明：`antigravity.rules` 是 Ag-Kit 注入的托管说明内容，不等同于 Codex 官方 `.rules`（命令审批执行规则）。
+
+## 命令行用法
+
+CLI（命令行界面）命令如下。
+
+### 安装/初始化
+
+```bash
+# 安装 Gemini
+ag-kit init --target gemini
+
+# 安装 Codex
+ag-kit init --target codex
+
+# 交互选择目标，TTY（终端）下无默认值
+ag-kit init
+
+# 临时目录验证（跳过全局索引登记）
+ag-kit init --target codex --no-index
+```
+
+### 更新
+
+```bash
+# 更新当前项目（自动检测已安装目标）
+ag-kit update
+
+# 强制更新指定目标
+ag-kit update --target codex
+
+# 更新但不刷新全局索引
+ag-kit update --target codex --no-index
+```
+
+### 诊断与修复
+
+```bash
+# 检查所有目标健康状态
+ag-kit doctor
+
+# 尝试自动修复
+ag-kit doctor --fix
+```

package/docs/official/README.md

@@ -0,0 +1,53 @@
+# 官方文档本地归档
+
+本目录用于保存官方规范文档的本地快照，作为本仓库在 Antigravity + Codex 双适配时的对照基线。
+
+- 归档时间：2026-02-12
+- 归档方式：先抓取官方源，再整理为中文 Markdown 版本（不改机制语义）
+- 证据索引：`docs/official/sources-index.md`（记录来源 URL、拉取时间、SHA256）
+
+## Antigravity
+
+- `docs/official/antigravity/agent-modes-settings.md`
+  - 来源：`https://antigravity.google/docs/agent-modes-settings`
+  - 抓取源：`https://antigravity.google/assets/docs/agent/agent-modes-settings.md`
+- `docs/official/antigravity/rules-workflows.md`
+  - 来源：`https://antigravity.google/docs/rules-workflows`
+  - 抓取源：`https://antigravity.google/assets/docs/agent/rules-workflows.md`
+- `docs/official/antigravity/skills.md`
+  - 来源：`https://antigravity.google/docs/skills`
+  - 抓取源：`https://antigravity.google/assets/docs/agent/skills.md`
+
+## Codex
+
+- `docs/official/codex/config-basic.md`
+  - 来源：`https://developers.openai.com/codex/config-basic`
+  - 抓取源：`https://developers.openai.com/codex/config-basic.md`
+- `docs/official/codex/config-advanced.md`
+  - 来源：`https://developers.openai.com/codex/config-advanced`
+  - 抓取源：`https://developers.openai.com/codex/config-advanced.md`
+- `docs/official/codex/config-reference.md`
+  - 来源：`https://developers.openai.com/codex/config-reference`
+  - 抓取源：`https://developers.openai.com/codex/config-reference.md`
+- `docs/official/codex/config-sample.md`
+  - 来源：`https://developers.openai.com/codex/config-sample`
+  - 抓取源：`https://developers.openai.com/codex/config-sample.md`
+- `docs/official/codex/rules.md`
+  - 来源：`https://developers.openai.com/codex/rules`
+  - 抓取源：`https://developers.openai.com/codex/rules.md`
+- `docs/official/codex/agents-md.md`
+  - 来源：`https://developers.openai.com/codex/guides/agents-md`
+  - 抓取源：`https://developers.openai.com/codex/guides/agents-md.md`
+- `docs/official/codex/mcp.md`
+  - 来源：`https://developers.openai.com/codex/mcp`
+  - 抓取源：`https://developers.openai.com/codex/mcp.md`
+- `docs/official/codex/skills.md`
+  - 来源：`https://developers.openai.com/codex/skills`
+  - 抓取源：`https://developers.openai.com/codex/skills.md`
+
+## 更新建议
+
+后续更新时，优先覆盖本目录快照，再做差异评审：
+
+1. 对比上次归档与新版官方文档差异。
+2. 若差异影响本仓库机制，再同步到 `docs/`、`.agent/` 相关规范文档。

package/docs/official/antigravity/agent-modes-settings.md

@@ -0,0 +1,64 @@
+---
+slug: agent-modes-settings
+section: 代理
+title: Agent 模式与设置
+path:
+  - 代理
+  - 模式与设置
+---
+
+# Agent 模式与设置（中文整理）
+
+> 来源：`https://antigravity.google/docs/agent-modes-settings`  
+> 同步日期：2026-02-12  
+> 说明：本文件为官方内容的中文整理版，采用标准 Markdown 语法。
+
+## 会话级模式
+
+开始新的 Agent 会话时，用户可以选择不同模式：
+
+- `Planning`：先规划后执行，适合深度研究、复杂任务、协作任务。该模式下，Agent 会使用任务分组、产出 Artifacts，并在执行前进行更充分的分析与规划。
+- `Fast`：直接执行，适合简单且局部的任务，例如重命名变量、执行少量命令等，强调速度。
+
+## 全局设置
+
+全局设置位于设置面板的 `Agent` 标签页，影响所有会话。重点配置如下。
+
+### Artifact 审阅策略
+
+可选项：
+
+- `Always Proceed`：Agent 不等待人工审阅，继续执行。
+- `Request Review`：Agent 在请求审阅后停止，等待用户确认和补充意见。
+
+适用建议：
+
+- 需要严格把关实施计划时，使用 `Request Review`。
+- 追求流程速度且信任当前指令时，使用 `Always Proceed`。
+
+### 终端命令自动执行
+
+针对终端命令生成工具：
+
+- `Request Review`：默认不自动执行命令（允许名单中的命令可自动执行）。
+- `Always Proceed`：默认自动执行命令（拒绝名单中的命令例外）。
+
+补充规则：
+
+- 允许名单（Allow list）和拒绝名单（Deny list）可在 `Agent` 设置中配置。
+- 设置变更仅对后续新消息生效，不影响当前正在进行的回复。
+- 在 Unix shell 中，规则按“命令 token 前缀匹配”。
+- 在 PowerShell 中，规则可匹配命令 token 的任意连续子序列。
+
+### 非工作区文件访问
+
+该选项控制 Agent 是否可访问和编辑当前工作区之外的文件。
+
+默认情况下，Agent 仅能访问：
+
+- 当前工作区文件
+- 应用根目录 `~/.antigravity/` 下的 Antigravity 相关数据（如 Artifacts、Knowledge Items）
+
+风险提示：
+
+- 开启该能力可能暴露本地敏感信息或密钥，请谨慎使用。