@mison/ling 1.0.2 → 1.1.1

package/bin/ling.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require("./ag-kit.js");
+require("./ling-cli.js");

package/bin/utils/managed-block.js

@@ -10,6 +10,14 @@ function detectLineEnding(content) {
 }
 
 function buildMarkers(blockId) {
+    const id = String(blockId || "default").trim();
+    return {
+        begin: `<!-- BEGIN LING MANAGED BLOCK: ${id} -->`,
+        end: `<!-- END LING MANAGED BLOCK: ${id} -->`,
+    };
+}
+
+function buildLegacyMarkers(blockId) {
     const id = String(blockId || "default").trim();
     return {
         begin: `<!-- BEGIN AG-KIT MANAGED BLOCK: ${id} -->`,
@@ -29,10 +37,9 @@ function upsertManagedBlock(filePath, blockId, body, options = {}) {
     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",
-    );
+    const legacyMarkers = buildLegacyMarkers(blockId);
+    const blockRegex = new RegExp(`${escapeRegex(markers.begin)}[\\s\\S]*?${escapeRegex(markers.end)}`, "m");
+    const legacyRegex = new RegExp(`${escapeRegex(legacyMarkers.begin)}[\\s\\S]*?${escapeRegex(legacyMarkers.end)}`, "m");
 
     let next = "";
     let action = "unchanged";
@@ -46,6 +53,12 @@ function upsertManagedBlock(filePath, blockId, body, options = {}) {
         if (next && !/\r?\n$/.test(next)) {
             next += lineEnding;
         }
+    } else if (legacyRegex.test(original)) {
+        next = original.replace(legacyRegex, managedBlock);
+        action = "updated";
+        if (next && !/\r?\n$/.test(next)) {
+            next += lineEnding;
+        }
     } else {
         next = `${original.replace(/\r?\n?$/, "")}${lineEnding}${lineEnding}${managedBlock}${lineEnding}`;
         action = "appended";

package/bin/utils.js

@@ -1,9 +1,17 @@
-const { execSync } = require("child_process");
+const { execSync, spawnSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const REPO_URL = "https://github.com/MisonL/Ling.git";
+const DEFAULT_REPO_URL = "https://github.com/MisonL/Ling.git";
+
+function resolveRepoUrl() {
+    const override = process.env.LING_REPO_URL;
+    if (typeof override === "string" && override.trim()) {
+        return override.trim();
+    }
+    return DEFAULT_REPO_URL;
+}
 
 function parseJsonSafe(raw) {
     try {
@@ -49,16 +57,17 @@ function cloneBranchAgentDir(branch, options) {
         throw new Error(`非法分支名: ${branch}`);
     }
 
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-"));
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ling-"));
     const logFn = options && options.logger ? options.logger : console.log;
+    const repoUrl = resolveRepoUrl();
 
-    if (!options.quiet) logFn(`[download] 正在从 ${REPO_URL} 拉取分支 ${safeBranch} ...`);
+    if (!options.quiet) logFn(`[download] 正在从 ${repoUrl} 拉取分支 ${safeBranch} ...`);
 
-    try {
-        execSync(`git clone --depth 1 --branch ${safeBranch} ${REPO_URL} "${tempDir}"`, {
-            stdio: options.quiet ? "ignore" : "pipe",
-        });
-    } catch (err) {
+    const cloneResult = spawnSync("git", ["clone", "--depth", "1", "--branch", safeBranch, repoUrl, tempDir], {
+        encoding: "utf8",
+        stdio: options.quiet ? "ignore" : "pipe",
+    });
+    if (cloneResult.status !== 0) {
         fs.rmSync(tempDir, { recursive: true, force: true });
         throw new Error(`无法拉取分支 ${safeBranch}，请确认分支存在且网络可用`);
     }
@@ -82,8 +91,42 @@ function cloneBranchAgentDir(branch, options) {
     };
 }
 
+function cloneBranchSpecDir(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(), "ling-"));
+    const logFn = options && options.logger ? options.logger : console.log;
+    const repoUrl = resolveRepoUrl();
+
+    if (!options.quiet) logFn(`[download] 正在从 ${repoUrl} 拉取分支 ${safeBranch} (spec) ...`);
+
+    const cloneResult = spawnSync("git", ["clone", "--depth", "1", "--branch", safeBranch, repoUrl, tempDir], {
+        encoding: "utf8",
+        stdio: options.quiet ? "ignore" : "pipe",
+    });
+    if (cloneResult.status !== 0) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        throw new Error(`无法拉取分支 ${safeBranch}，请确认分支存在且网络可用`);
+    }
+
+    const specDir = path.join(tempDir, ".spec");
+    if (!fs.existsSync(specDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        throw new Error(`分支 ${safeBranch} 中未找到 .spec 目录`);
+    }
+
+    return {
+        specDir,
+        cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true }),
+    };
+}
+
 module.exports = {
     parseJsonSafe,
     readGlobalNpmDependencies,
-    cloneBranchAgentDir
+    cloneBranchAgentDir,
+    cloneBranchSpecDir
 };

package/docs/TECH.md

@@ -2,11 +2,11 @@
 
 ## 快速验证（维护者）
 ```bash
-bun install
-bun run test
-bun run ci:verify
-bun run health-check
-cd web && bun install && bun run lint
+npm install
+npm test
+npm run ci:verify
+npm run health-check
+cd web && npm install && npm run lint
 ```
 
 ## 核心目录与职责
@@ -20,6 +20,9 @@ cd web && bun install && bun run lint
 ### 项目级（功能最完整）
 - `gemini`：项目根目录 `.agent/`
 - `codex`：项目根目录 `.agents/`（受管）+ `.agents-backup/`（漂移覆盖备份）
+- 项目级预备份（覆盖前快照）：
+  - Gemini：`<project>/.agent-backup/<timestamp>/preflight/.agent/`
+  - Codex：`<project>/.agents-backup/<timestamp>/preflight/.agents/` 或 `<project>/.agents-backup/<timestamp>/preflight/.codex/`
 
 ### 全局级（仅同步 Skills）
 - `codex`：`$HOME/.codex/skills/`
@@ -31,9 +34,16 @@ cd web && bun install && bun run lint
 ## 端到端链路（简述）
 ### 项目安装 / 更新
 - `init`：选择目标 -> 适配器 `install()` -> 落盘目标目录（Gemini: `.agent/`；Codex: `.agents/`）->（Codex）注入托管区块到工作区 `AGENTS.md` 与 `ling.rules`
-- `update`：自动检测已安装目标（或通过 `--target/--targets` 指定）-> 适配器 `update()` ->（Codex）漂移检测与备份 -> 原子替换
+- `update`：自动检测已安装目标（或通过 `--target/--targets` 指定）->（冲突时交互确认或默认预备份）-> 适配器 `update()` ->（Codex）漂移检测与备份 -> 原子替换
 - `doctor`：检查完整性；`--fix` 尝试修复（Codex 支持迁移 `.codex/` 与重写托管区块）
 
+### 已有资产冲突处理（项目级）
+- 触发条件：
+  - `gemini`：`.agent/` 已存在且与内置模板不一致
+  - `codex`：`.agents/` 或 `.codex/` 已存在且存在漂移、缺失 `manifest.json` 或包含未知文件
+- 交互终端会逐项询问处理方式：保留 / 备份后移除 / 直接移除，并支持按资产类别复用选择
+- 非交互环境不会进入询问：需要覆盖时默认执行“备份后覆盖”；`init` 若检测到已有资产且未显式 `--force` 则报错
+
 ### Codex 构建（Workflow -> Skill）
 - 输入：`.agents/skills/` 与 `.agents/workflows/`
 - 规则：每个 Workflow `<name>.md` 会转换为一个 Skill：`workflow-<name>/SKILL.md`
@@ -55,19 +65,27 @@ cd web && bun install && bun run lint
 ### 测试隔离
 - `LING_GLOBAL_ROOT`：替代 `$HOME`（用于测试与 CI，避免污染真实用户目录）
 
-## Spec Profile：`ling spec enable/disable/status`
+## Spec Profile：`ling spec ...`
 ### 当前范围
-- 当前只实现全局层：
+- 全局 Spec Profile（机器级）：
   - `ling spec enable [--target codex|gemini] [--dry-run] [--quiet]`
   - `ling spec disable [--target codex|gemini] [--dry-run] [--quiet]`
   - `ling spec status [--quiet]`
-- 默认目标：未指定 `--target/--targets` 时启用 `codex + gemini`
-- 当前 Spec 源目录：`.spec/`
+  - 默认目标：未指定 `--target/--targets` 时启用 `codex + gemini`
+- 项目级 Spec 资产（工作区级）：
+  - `ling spec init [--path <dir>] [--target codex|gemini|--targets codex,gemini] [--branch <name>] [--dry-run] [--quiet]`
+    - 未指定 `--path` 时，默认初始化 Spec 工作区目录：`$HOME/.ling/spec-workspace`
+    - 指定 `--targets` 时，会同时执行对应目标的 `ling init` 安装（`.agent/.agents`）
+    - 指定 `--branch` 时，Spec 资产将从该分支的 `.spec/` 拉取（用于验证或灰度 Spec 模板）
+  - `ling spec doctor [--path <dir>] [--quiet]`
+    - 会校验 `issues.csv` 表头与状态枚举，并检查 `.ling/spec/` 目录是否完整
+- Spec 源目录：`.spec/`
 
 ### 落盘与状态
 - Spec 状态文件：`$HOME/.ling/spec/state.json`
 - Spec templates：`$HOME/.ling/spec/templates/`
 - Spec references：`$HOME/.ling/spec/references/`
+- Spec profiles：`$HOME/.ling/spec/profiles/`
 - Spec 备份目录：`$HOME/.ling/backups/spec/<timestamp>/before/...`
 
 ### 当前安装内容
@@ -84,6 +102,10 @@ cd web && bun install && bun run lint
   - `harness-engineering-digest.md`
   - `gda-framework.md`
   - 相关 quickstart / README
+- Profiles：
+  - `codex/AGENTS.spec.md`
+  - `codex/ling.spec.rules.md`
+  - `gemini/GEMINI.spec.md`
 
 ### 状态契约
 - `ling spec status --quiet` 输出：
@@ -98,11 +120,13 @@ cd web && bun install && bun run lint
 ### 回退语义
 - `spec enable`：
   - 若目标位置已存在同名 Skill，会先备份再覆盖
-  - 若 `templates/` 或 `references/` 已存在，也会先备份
+  - 若 `templates/`、`references/` 或 `profiles/` 已存在，也会先备份
 - `spec disable`：
   - 若存在备份，恢复启用前快照
   - 若启用前不存在资源，则删除由 Spec 安装的目录
-- 当前尚未实现项目级 `spec init / remove / doctor`
+- `spec init`：
+  - 会在工作区内写入 `.ling/spec/`（templates/references/profiles）与 `issues.csv`，并创建 `docs/reviews`、`docs/handoff`
+  - 当检测到冲突资产时，支持保留 / 备份后覆盖 / 直接覆盖
 
 ## 状态契约（自动化）
 - `ling status --quiet` / `ling global status --quiet` 只输出三态：
@@ -158,10 +182,10 @@ cp -a "$HOME/.ling/backups/global/$ts/antigravity/$skill" "$HOME/.gemini/antigra
 - `LING_INDEX_PATH`：工作区索引文件路径（默认 `~/.ling/workspaces.json`）
 - `LING_GLOBAL_ROOT`：全局目录根（替代 `$HOME`）
 - `LING_SKIP_UPSTREAM_CHECK`：跳过上游同名包安装提示（测试用）
+- `LING_REPO_URL`：覆盖默认仓库地址（主要用于测试与私有镜像）
 
 ## 安装提示机制
 - npm 全局安装：`postinstall` 会尽力检测并提示上游英文版 `@vudovn/ag-kit` 冲突。
-- Bun 全局安装：Bun 默认会阻止本包 `postinstall`；因此冲突提示以内置 CLI 运行期检查为准，会在 `init` / `update` / `update-all` / `global sync` 时提示。
 - 冲突提示只负责提醒，不会自动修改当前安装状态；如需清理可执行 `npm uninstall -g @vudovn/ag-kit`。
 
 ## 常见故障

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mison/ling",
-  "version": "1.0.2",
-  "description": "AI Agent templates - Skills, Agents, and Workflows for enhanced coding assistance",
+  "version": "1.1.1",
+  "description": "面向 Gemini CLI、Antigravity 与 Codex 的中文 AI Agent 模板工具包",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MisonL/Ling.git"
@@ -18,7 +18,10 @@
     "skills",
     "templates"
   ],
-  "author": "vudovn",
+  "author": "Mison",
+  "contributors": [
+    "vudovn"
+  ],
   "license": "MIT",
   "scripts": {
     "clean": "node scripts/clean.js",

package/scripts/ci-verify.js

@@ -9,6 +9,7 @@ const REPO_ROOT = path.resolve(__dirname, "..");
 const CLI_PATH = path.join(REPO_ROOT, "bin", "ling.js");
 
 function runCli(args, options = {}) {
+    const allowedStatuses = options.allowedStatuses || [0];
     const env = {
         ...process.env,
         LING_SKIP_UPSTREAM_CHECK: "1",
@@ -21,9 +22,11 @@ function runCli(args, options = {}) {
         encoding: "utf8",
     });
 
-    if (result.status !== 0) {
+    if (!allowedStatuses.includes(result.status)) {
         const message = result.stderr || result.stdout || "";
-        throw new Error(`命令失败: ling ${args.join(" ")}\n${message}`);
+        throw new Error(
+            `命令失败: ling ${args.join(" ")}\n(exit=${result.status})\n${message}`.trim(),
+        );
     }
 
     return result.stdout || "";
@@ -82,7 +85,10 @@ function main() {
         throw new Error(`spec status 结果异常: ${specStatus}`);
     }
     runCli(["spec", "disable", "--target", "codex", "--quiet"], { env });
-    const specStatusAfterDisable = runCli(["spec", "status", "--quiet"], { env }).trim();
+    const specStatusAfterDisable = runCli(["spec", "status", "--quiet"], {
+        env,
+        allowedStatuses: [0, 2],
+    }).trim();
     if (specStatusAfterDisable !== "missing") {
         throw new Error(`spec disable 后状态异常: ${specStatusAfterDisable}`);
     }

package/scripts/postinstall-check.js

@@ -58,7 +58,7 @@ async function main() {
         return;
     }
 
-    if (process.env.LING_SKIP_UPSTREAM_CHECK === "1" || process.env.AG_KIT_SKIP_UPSTREAM_CHECK === "1") {
+    if (process.env.LING_SKIP_UPSTREAM_CHECK === "1") {
         return;
     }
 
@@ -72,13 +72,12 @@ async function main() {
     }
 
     console.warn(`\n[warn] 检测到全局已安装上游英文版 ${UPSTREAM_GLOBAL_PACKAGE}`);
-    console.warn("[warn] 上游英文版与当前版本共用 `ag-kit` 兼容命令名，后安装者会覆盖该入口。");
-    console.warn("[warn] 为避免后续混淆，建议仅保留一个来源。\n");
+    console.warn("[warn] 为避免 Skills/模板来源混用导致的行为差异，建议仅保留一个来源。\n");
 
     if (!canPromptUser()) {
         console.warn("[info] 当前环境不是交互式终端，无法确认是否自动卸载。");
         console.warn(`[hint] 如需卸载，请手动执行: npm uninstall -g ${UPSTREAM_GLOBAL_PACKAGE}`);
-        console.warn("[info] 本次将继续安装；安装完成后正式命令请使用 `ling`。\n");
+        console.warn("[info] 本次将继续安装；安装完成后请使用 `ling`。\n");
         return;
     }
 
@@ -86,7 +85,7 @@ async function main() {
 
     if (!shouldUninstall) {
         console.warn(`[info] 已保留 ${UPSTREAM_GLOBAL_PACKAGE}，继续安装当前版本。`);
-        console.warn("[info] 结果说明：正式命令请使用 `ling`，旧 `ag-kit` 仅保留兼容入口。\n");
+        console.warn("[info] 结果说明：安装完成后请使用 `ling`。\n");
         return;
     }
 
@@ -101,7 +100,7 @@ async function main() {
     console.warn(`[error] 自动卸载 ${UPSTREAM_GLOBAL_PACKAGE} 失败，将继续安装当前版本。`);
     console.warn("[info] 若需手动处理，请执行：");
     console.warn(`   npm uninstall -g ${UPSTREAM_GLOBAL_PACKAGE}`);
-    console.warn("[info] 安装完成后，正式命令请使用 `ling`；旧 `ag-kit` 仅保留兼容入口。\n");
+    console.warn("[info] 安装完成后请使用 `ling`。\n");
 }
 
 main().catch((err) => {

package/tests/clean-script.test.js

@@ -9,7 +9,7 @@ describe("Clean Script", () => {
     let tempRoot;
 
     beforeEach(() => {
-        tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-clean-test-"));
+        tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ling-clean-test-"));
     });
 
     afterEach(() => {

package/tests/cli-smoke.test.js

@@ -27,6 +27,37 @@ describe("CLI Smoke", () => {
     let workspaceDir;
     let indexPath;
 
+    function findFirstTimestampDir(backupRoot) {
+        if (!fs.existsSync(backupRoot)) {
+            return "";
+        }
+        const entries = fs
+            .readdirSync(backupRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+        return entries.length > 0 ? path.join(backupRoot, entries[entries.length - 1]) : "";
+    }
+
+    function findTimestampDirContaining(backupRoot, relPath) {
+        if (!fs.existsSync(backupRoot)) {
+            return "";
+        }
+        const entries = fs
+            .readdirSync(backupRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+
+        for (const name of entries) {
+            const candidate = path.join(backupRoot, name, relPath);
+            if (fs.existsSync(candidate)) {
+                return path.join(backupRoot, name);
+            }
+        }
+        return "";
+    }
+
     beforeEach(() => {
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ling-cli-test-"));
         workspaceDir = path.join(tempDir, "workspace");
@@ -273,6 +304,60 @@ describe("CLI Smoke", () => {
         assert.strictEqual(result.status, 0, result.stderr || result.stdout);
     });
 
+    test("init --force should create preflight backup for existing gemini .agent", () => {
+        const agentDir = path.join(workspaceDir, ".agent");
+        fs.mkdirSync(agentDir, { recursive: true });
+        fs.writeFileSync(path.join(agentDir, "custom.txt"), "custom", "utf8");
+
+        const result = runCli(
+            ["init", "--target", "gemini", "--path", workspaceDir, "--force", "--quiet"],
+            { env: { LING_INDEX_PATH: indexPath } },
+        );
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const backupRoot = path.join(workspaceDir, ".agent-backup");
+        const tsDir = findFirstTimestampDir(backupRoot);
+        assert.ok(tsDir, "expected .agent-backup timestamp directory to exist");
+        assert.ok(fs.existsSync(path.join(tsDir, "preflight", ".agent", "custom.txt")));
+    });
+
+    test("update should create preflight backup for gemini when overwriting in non-interactive mode", () => {
+        const agentDir = path.join(workspaceDir, ".agent");
+        fs.mkdirSync(agentDir, { recursive: true });
+        fs.writeFileSync(path.join(agentDir, "custom.txt"), "custom", "utf8");
+
+        const result = runCli(
+            ["update", "--target", "gemini", "--path", workspaceDir, "--quiet"],
+            { env: { LING_INDEX_PATH: indexPath } },
+        );
+        assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+
+        const backupRoot = path.join(workspaceDir, ".agent-backup");
+        const tsDir = findFirstTimestampDir(backupRoot);
+        assert.ok(tsDir, "expected .agent-backup timestamp directory to exist");
+        assert.ok(fs.existsSync(path.join(tsDir, "preflight", ".agent", "custom.txt")));
+    });
+
+    test("update should create preflight backup for codex when unknown files exist in managed dir", () => {
+        const initResult = runCli(
+            ["init", "--target", "codex", "--path", workspaceDir, "--quiet"],
+            { env: { LING_INDEX_PATH: indexPath } },
+        );
+        assert.strictEqual(initResult.status, 0, initResult.stderr || initResult.stdout);
+
+        fs.writeFileSync(path.join(workspaceDir, ".agents", "unknown.txt"), "unknown", "utf8");
+
+        const updateResult = runCli(
+            ["update", "--target", "codex", "--path", workspaceDir, "--quiet"],
+            { env: { LING_INDEX_PATH: indexPath } },
+        );
+        assert.strictEqual(updateResult.status, 0, updateResult.stderr || updateResult.stdout);
+
+        const backupRoot = path.join(workspaceDir, ".agents-backup");
+        const tsDir = findTimestampDirContaining(backupRoot, path.join("preflight", ".agents", "unknown.txt"));
+        assert.ok(tsDir, "expected .agents-backup preflight backup to exist");
+    });
+
     test("status --quiet should report missing with exit code 2 when nothing is installed", () => {
         const result = runCli(
             ["status", "--path", workspaceDir, "--quiet"],

package/tests/managed-block.test.js

@@ -25,7 +25,7 @@ describe("ManagedBlock", () => {
         assert.strictEqual(result.action, "appended");
         const content = fs.readFileSync(targetFile, "utf8");
         assert.ok(content.includes("User Content"));
-        assert.ok(content.includes("BEGIN AG-KIT MANAGED BLOCK: codex-core-rules"));
+        assert.ok(content.includes("BEGIN LING MANAGED BLOCK: codex-core-rules"));
         assert.ok(content.includes("managed line"));
     });
 
@@ -38,4 +38,21 @@ describe("ManagedBlock", () => {
         assert.ok(content.includes("v2"));
         assert.ok(!content.includes("v1"));
     });
+
+    test("should migrate legacy AG-KIT markers when updating managed block", () => {
+        fs.writeFileSync(
+            targetFile,
+            `# User Content\n\n<!-- BEGIN AG-KIT MANAGED BLOCK: codex-core-rules -->\nlegacy\n<!-- END AG-KIT MANAGED BLOCK: codex-core-rules -->\n`,
+            "utf8",
+        );
+
+        const result = upsertManagedBlock(targetFile, "codex-core-rules", "v2");
+
+        assert.strictEqual(result.action, "updated");
+        const content = fs.readFileSync(targetFile, "utf8");
+        assert.ok(content.includes("BEGIN LING MANAGED BLOCK: codex-core-rules"));
+        assert.ok(!content.includes("BEGIN AG-KIT MANAGED BLOCK: codex-core-rules"));
+        assert.ok(content.includes("v2"));
+        assert.ok(!content.includes("legacy"));
+    });
 });

package/tests/phase-c.test.js

@@ -66,9 +66,9 @@ describe('Phase C Integration', () => {
         // Verification 4: Workspace managed block injection
         const workspaceAgents = fs.readFileSync(path.join(workDir, 'AGENTS.md'), 'utf8');
         const workspaceRules = fs.readFileSync(path.join(workDir, 'ling.rules'), 'utf8');
-        assert.ok(workspaceAgents.includes('BEGIN AG-KIT MANAGED BLOCK: codex-core-rules'));
+        assert.ok(workspaceAgents.includes('BEGIN LING MANAGED BLOCK: codex-core-rules'));
         assert.ok(workspaceAgents.includes('test-skill'));
-        assert.ok(workspaceRules.includes('BEGIN AG-KIT MANAGED BLOCK: codex-risk-controls'));
+        assert.ok(workspaceRules.includes('BEGIN LING MANAGED BLOCK: codex-risk-controls'));
 
         const codexJson = JSON.parse(fs.readFileSync(path.join(codexDir, 'codex.json'), 'utf8'));
         assert.strictEqual(codexJson.version, pkg.version);