@mison/ling 1.0.0

package/tests/phase-c.test.js

@@ -0,0 +1,107 @@
+const { test, describe, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const CodexAdapter = require('../bin/adapters/codex');
+const pkg = require('../package.json');
+
+describe('Phase C Integration', () => {
+    let workDir;
+    let geminiRepo;
+
+    beforeEach(() => {
+        workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'phase-c-test-'));
+        geminiRepo = path.join(workDir, 'gemini-repo');
+        
+        // Setup specialized Gemini-like structure
+        const agentDir = path.join(geminiRepo, '.agent');
+        const skillsDir = path.join(agentDir, 'skills');
+        const workflowsDir = path.join(agentDir, 'workflows');
+        
+        fs.mkdirSync(skillsDir, { recursive: true });
+        fs.mkdirSync(workflowsDir, { recursive: true });
+        
+        // Create a Skill
+        const skillPath = path.join(skillsDir, 'test-skill');
+        fs.mkdirSync(skillPath);
+        fs.writeFileSync(path.join(skillPath, 'SKILL.md'), '# Test Skill');
+        
+        // Create a Workflow
+        fs.writeFileSync(path.join(workflowsDir, 'test-flow.md'), '# Test Workflow');
+    });
+
+    afterEach(() => {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    });
+
+    test('CodexAdapter should build from Gemini structure on the fly', () => {
+        const options = { quiet: true, force: true };
+        const adapter = new CodexAdapter(workDir, options);
+        
+        // Install from Gemini Repo Root
+        adapter.install(geminiRepo);
+        
+        const codexDir = path.join(workDir, '.agents');
+        // Verification 1: Structure Created
+        assert.ok(fs.existsSync(codexDir));
+        
+        // Verification 2: Transformation Happened
+        const builtSkill = path.join(codexDir, 'skills', 'test-skill', 'SKILL.md');
+        assert.ok(fs.existsSync(builtSkill));
+        
+        // Workflow: workflow-test-flow
+        const builtWorkflow = path.join(codexDir, 'skills', 'workflow-test-flow', 'SKILL.md');
+        assert.ok(fs.existsSync(builtWorkflow));
+        
+        // Verification 3: Manifest & Meta
+        assert.ok(fs.existsSync(path.join(codexDir, 'codex.json')));
+        assert.ok(fs.existsSync(path.join(codexDir, 'AGENTS.md')));
+        assert.ok(fs.existsSync(path.join(codexDir, 'ling.rules')));
+        
+        const agentsMd = fs.readFileSync(path.join(codexDir, 'AGENTS.md'), 'utf8');
+        assert.ok(agentsMd.includes('test-skill'));
+        assert.ok(agentsMd.includes('(Codex Managed)'));
+
+        // 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('test-skill'));
+        assert.ok(workspaceRules.includes('BEGIN AG-KIT MANAGED BLOCK: codex-risk-controls'));
+
+        const codexJson = JSON.parse(fs.readFileSync(path.join(codexDir, 'codex.json'), 'utf8'));
+        assert.strictEqual(codexJson.version, pkg.version);
+        assert.ok(agentsMd.includes(`Version: ${pkg.version}`));
+        assert.ok(workspaceRules.includes(`version: ${pkg.version}`));
+    });
+
+    test('CodexBuilder should avoid ID collisions between skills and workflows', () => {
+        const skillCollisionPath = path.join(geminiRepo, '.agent', 'skills', 'wf-test-flow');
+        fs.mkdirSync(skillCollisionPath, { recursive: true });
+        fs.writeFileSync(path.join(skillCollisionPath, 'SKILL.md'), '# Skill wf-test-flow');
+
+        const options = { quiet: true, force: true };
+        const adapter = new CodexAdapter(workDir, options);
+        adapter.install(geminiRepo);
+
+        const codexJson = JSON.parse(
+            fs.readFileSync(path.join(workDir, '.agents', 'codex.json'), 'utf8')
+        );
+        const collisionEntries = (codexJson.skills || []).filter(
+            (item) => item.originalName === 'wf-test-flow' || item.originalName === 'test-flow'
+        );
+
+        assert.strictEqual(collisionEntries.length, 2, 'skill/workflow should both be preserved');
+        assert.notStrictEqual(
+            collisionEntries[0].id,
+            collisionEntries[1].id,
+            'colliding IDs should be disambiguated',
+        );
+
+        for (const entry of collisionEntries) {
+            const skillFile = path.join(workDir, '.agents', entry.path);
+            assert.ok(fs.existsSync(skillFile), `missing transformed file: ${entry.path}`);
+        }
+    });
+});

package/tests/spec-profile.test.js

@@ -0,0 +1,86 @@
+const { test, describe, beforeEach, afterEach } = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("node:child_process");
+
+const REPO_ROOT = path.resolve(__dirname, "..");
+const CLI_PATH = path.join(REPO_ROOT, "bin", "ling.js");
+
+function runCli(args, options = {}) {
+    const env = {
+        ...process.env,
+        LING_SKIP_UPSTREAM_CHECK: "1",
+        ...options.env,
+    };
+
+    return spawnSync(process.execPath, [CLI_PATH, ...args], {
+        cwd: options.cwd || REPO_ROOT,
+        env,
+        encoding: "utf8",
+    });
+}
+
+describe("Spec Profile", () => {
+    let tempRoot;
+
+    beforeEach(() => {
+        tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ling-spec-test-"));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    });
+
+    test("spec status should report missing before enable", () => {
+        const result = runCli(["spec", "status", "--quiet"], {
+            env: { LING_GLOBAL_ROOT: tempRoot },
+        });
+        assert.strictEqual(result.status, 2);
+        assert.strictEqual((result.stdout || "").trim(), "missing");
+    });
+
+    test("spec enable should install skills and assets, and disable should remove them", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+
+        const enableResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+
+        const codexSkill = path.join(tempRoot, ".codex", "skills", "harness-engineering", "SKILL.md");
+        const stateFile = path.join(tempRoot, ".ling", "spec", "state.json");
+        const templatesDir = path.join(tempRoot, ".ling", "spec", "templates");
+        const referencesDir = path.join(tempRoot, ".ling", "spec", "references");
+
+        assert.ok(fs.existsSync(codexSkill), "missing installed codex spec skill");
+        assert.ok(fs.existsSync(stateFile), "missing spec state");
+        assert.ok(fs.existsSync(path.join(templatesDir, "issues.template.csv")), "missing spec template");
+        assert.ok(fs.existsSync(path.join(referencesDir, "harness-engineering-digest.md")), "missing spec reference");
+
+        const statusResult = runCli(["spec", "status", "--quiet"], { env });
+        assert.strictEqual(statusResult.status, 0);
+        assert.strictEqual((statusResult.stdout || "").trim(), "installed");
+
+        const disableResult = runCli(["spec", "disable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(disableResult.status, 0, disableResult.stderr || disableResult.stdout);
+        assert.ok(!fs.existsSync(path.join(tempRoot, ".codex", "skills", "harness-engineering")), "spec skill should be removed");
+        assert.ok(!fs.existsSync(stateFile), "spec state should be removed after final disable");
+        assert.ok(!fs.existsSync(templatesDir), "spec templates should be removed after final disable");
+        assert.ok(!fs.existsSync(referencesDir), "spec references should be removed after final disable");
+    });
+
+    test("spec disable should restore pre-existing skill backup", () => {
+        const env = { LING_GLOBAL_ROOT: tempRoot };
+        const skillDir = path.join(tempRoot, ".codex", "skills", "harness-engineering");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), "legacy skill", "utf8");
+
+        const enableResult = runCli(["spec", "enable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(enableResult.status, 0, enableResult.stderr || enableResult.stdout);
+        assert.notStrictEqual(fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8"), "legacy skill");
+
+        const disableResult = runCli(["spec", "disable", "--target", "codex", "--quiet"], { env });
+        assert.strictEqual(disableResult.status, 0, disableResult.stderr || disableResult.stdout);
+        assert.strictEqual(fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8"), "legacy skill");
+    });
+});

package/tests/standards-compliance.test.js

@@ -0,0 +1,303 @@
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const REF_ROOT = path.resolve('reference/antigravity-kit');
+const REF_AGENTS_ROOT = path.resolve('reference/antigravity-kit/.agents');
+const REF_LEGACY_AGENT_ROOT = path.resolve('reference/antigravity-kit/.agent');
+const REF_SCRIPTS_ROOT = fs.existsSync(REF_AGENTS_ROOT) ? REF_AGENTS_ROOT : REF_LEGACY_AGENT_ROOT;
+const HAS_REF_SCRIPTS_ROOT = fs.existsSync(REF_SCRIPTS_ROOT);
+
+function collectTokens(content, regex) {
+    const tokens = new Set();
+    for (const match of String(content || "").matchAll(regex)) {
+        tokens.add(match[1] || match[0]);
+    }
+    return tokens;
+}
+
+function collectFiles(rootDir, matcher) {
+    const matches = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const abs = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (matcher(abs)) {
+                matches.push(abs);
+            }
+        }
+    }
+    return matches.sort();
+}
+
+describe('Standards Compliance', () => {
+    test('all skill directories should include SKILL.md', () => {
+        const skillsRoot = path.resolve('.agents/skills');
+        assert.ok(fs.existsSync(skillsRoot), 'missing .agents/skills');
+
+        const skillDirs = fs
+            .readdirSync(skillsRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(skillsRoot, entry.name));
+
+        for (const dir of skillDirs) {
+            const skillMd = path.join(dir, 'SKILL.md');
+            assert.ok(fs.existsSync(skillMd), `missing SKILL.md in ${path.relative(process.cwd(), dir)}`);
+        }
+    });
+
+    test('deprecated .codex primary-layout wording should be removed from user-facing docs and generator', () => {
+        const targets = [
+            'README.md',
+            'docs/PLAN.md',
+            'docs/TECH.md',
+            'bin/core/generator.js',
+        ];
+        const skipped = [];
+
+        for (const rel of targets) {
+            const abs = path.resolve(rel);
+            if (!fs.existsSync(abs)) {
+                skipped.push(rel);
+                continue;
+            }
+            const content = fs.readFileSync(abs, 'utf8');
+            assert.ok(!content.includes('Managed resources are synchronized under `.codex/`.'), `${rel} still contains deprecated .codex guidance`);
+            assert.ok(!content.includes('Do not edit files under `.codex/` directly.'), `${rel} still contains deprecated .codex guidance`);
+        }
+
+        if (skipped.length > 0) {
+            console.warn(`[standards-compliance] skipped missing optional files: ${skipped.join(', ')}`);
+        }
+    });
+
+    test('critical mechanism tokens should remain aligned with reference snapshot', { skip: !fs.existsSync(REF_ROOT) }, () => {
+        const refRoot = REF_ROOT;
+        const tokenRegex = /(ag-kit|ling|python3?|checklist\.py|verify_all\.py|security_scan\.py|ux_audit\.py|accessibility_checker\.py|schema_validator\.py|lint_runner\.py|type_coverage\.py|playwright_runner\.py|lighthouse_audit\.py|api_validator\.py|mobile_audit\.py|seo_checker\.py|geo_checker\.py|i18n_checker\.py|\.agent\/|\.agents\/|\.agents-backup\/|\.codex\/|AGENTS\.md|antigravity\.rules|ling\.rules|manifest\.json|--target|--targets|--fix|--path|--no-index|--dry-run|--quiet|--force)/g;
+        const slashCommandRegex = /(?:^|[\s`"'(\[])(\/(?:brainstorm|create|debug|deploy|enhance|orchestrate|plan|preview|status|test|ui-ux-pro-max))(?=$|[\s`"'，。,.:：)\]])/gm;
+
+        const markdownFiles = [];
+        const stack = [refRoot];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+                const abs = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(abs);
+                    continue;
+                }
+                if (/\.(md|mdx|txt)$/i.test(entry.name)) {
+                    markdownFiles.push(abs);
+                }
+            }
+        }
+
+        const mismatches = [];
+        for (const refFile of markdownFiles) {
+            const rel = path.relative(refRoot, refFile);
+            const localFile = path.resolve(rel);
+            if (!fs.existsSync(localFile)) continue;
+
+            const refContent = fs.readFileSync(refFile, 'utf8');
+            const refTokens = new Set([
+                ...collectTokens(refContent, tokenRegex),
+                ...collectTokens(refContent, slashCommandRegex),
+            ]);
+            if (refTokens.size === 0) continue;
+
+            const localContent = fs.readFileSync(localFile, 'utf8');
+            const localTokens = new Set([
+                ...collectTokens(localContent, tokenRegex),
+                ...collectTokens(localContent, slashCommandRegex),
+            ]);
+
+            const missing = [...refTokens].filter((token) => !localTokens.has(token));
+            if (missing.length > 0) {
+                mismatches.push({ rel, missing });
+            }
+        }
+
+        assert.strictEqual(
+            mismatches.length,
+            0,
+            `critical mechanism tokens drifted:\n${mismatches
+                .slice(0, 10)
+                .map((item) => `${item.rel} -> ${item.missing.join(', ')}`)
+                .join('\n')}`,
+        );
+    });
+
+    test('user-facing docs should track current repo and global skill locations', () => {
+        const file = path.resolve('docs/TECH.md');
+        const content = fs.readFileSync(file, 'utf8');
+
+        assert.ok(content.includes('$HOME/.codex/skills/'), 'missing global skill path: $HOME/.codex/skills/');
+        assert.ok(content.includes('$HOME/.gemini/skills/'), 'missing global skill path: $HOME/.gemini/skills/');
+        assert.ok(content.includes('$HOME/.gemini/antigravity/skills/'), 'missing global skill path: $HOME/.gemini/antigravity/skills/');
+        assert.ok(content.includes('.agents/skills'), 'missing repo skill path: .agents/skills');
+        assert.ok(!content.includes('$HOME/.agents/skills/'), 'should not contain deprecated global path: $HOME/.agents/skills/');
+    });
+
+    test('.agents script files should stay identical to reference snapshot', { skip: !HAS_REF_SCRIPTS_ROOT }, () => {
+        const refScriptsRoot = REF_SCRIPTS_ROOT;
+        const mismatches = [];
+
+        const stack = [refScriptsRoot];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+                const abs = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(abs);
+                    continue;
+                }
+                if (!abs.includes(`${path.sep}scripts${path.sep}`)) continue;
+                if (abs.includes(`${path.sep}__pycache__${path.sep}`) || abs.endsWith('.pyc')) continue;
+
+                const rel = path.relative(refScriptsRoot, abs);
+                const localFile = path.resolve('.agents', rel);
+                if (!fs.existsSync(localFile)) {
+                    mismatches.push(`${rel} (missing local file)`);
+                    continue;
+                }
+
+                const refContent = fs.readFileSync(abs, 'utf8');
+                const localContent = fs.readFileSync(localFile, 'utf8');
+                if (refContent !== localContent) {
+                    mismatches.push(rel);
+                }
+            }
+        }
+
+        assert.strictEqual(
+            mismatches.length,
+            0,
+            `script content drifted:\n${mismatches.slice(0, 20).join('\n')}`,
+        );
+    });
+
+    test('critical path handling should avoid hardcoded platform separators in managed paths', () => {
+        const adapterFile = path.resolve('bin/adapters/codex.js');
+        const content = fs.readFileSync(adapterFile, 'utf8');
+
+        // Keep this focused on managed path constants that must remain path.join-driven.
+        assert.ok(content.includes('path.join'), 'codex adapter should use path.join for managed paths');
+        assert.ok(content.includes('os.tmpdir()'), 'codex adapter should use os.tmpdir() for temp paths');
+    });
+
+    test('cli and maintenance scripts should avoid emoji output markers', () => {
+        const targetFiles = [
+            ...collectFiles(path.resolve('bin'), (abs) => abs.endsWith('.js')),
+            ...collectFiles(path.resolve('scripts'), (abs) => abs.endsWith('.js')),
+        ];
+        const emojiRegex = /[\u{2600}-\u{27BF}\u{1F300}-\u{1FAFF}]/u;
+        const offenders = [];
+
+        for (const file of targetFiles) {
+            const content = fs.readFileSync(file, 'utf8');
+            if (emojiRegex.test(content)) {
+                offenders.push(path.relative(process.cwd(), file));
+            }
+        }
+
+        assert.deepStrictEqual(offenders, [], `cli/script files should not contain emoji markers:\n${offenders.join('\n')}`);
+    });
+
+    test('official antigravity docs baselines should be present in localized pages', () => {
+        const checks = [
+            {
+                file: 'web/src/app/docs/skills/page.tsx',
+                required: [
+                    'SKILL.md',
+                    'workspace-root',
+                    '~/.gemini/antigravity/skills',
+                    'description',
+                    'scripts/',
+                    'examples/',
+                    'resources/',
+                    'Discovery',
+                    'Activation',
+                    'Execution',
+                    '--help',
+                ],
+            },
+            {
+                file: 'web/src/app/docs/rules-workflows/page.tsx',
+                required: [
+                    '12,000',
+                    '~/.gemini/GEMINI.md',
+                    '.agent/rules',
+                    'Manual',
+                    'Always On',
+                    'Model Decision',
+                    'Glob',
+                    '@filename',
+                    '/workflow-name',
+                ],
+            },
+            {
+                file: 'web/src/app/docs/task-groups/page.tsx',
+                required: ['规划模式', '总体目标', '已编辑文件', '待处理区'],
+            },
+            {
+                file: 'web/src/app/docs/strict-mode/page.tsx',
+                required: ['Allowlist/Denylist', 'Request Review', '.gitignore', '工作区隔离'],
+            },
+            {
+                file: 'web/src/app/docs/sandbox-mode/page.tsx',
+                required: [
+                    'sandbox-exec',
+                    'Enable Terminal Sandboxing',
+                    'Sandbox Allow Network',
+                    'Bypass Sandbox',
+                    'Strict Mode',
+                ],
+            },
+            {
+                file: 'web/src/app/docs/mcp/page.tsx',
+                required: [
+                    'Model Context Protocol',
+                    'MCP Store',
+                    'Manage MCP Servers',
+                    'View raw config',
+                    'mcp_config.json',
+                ],
+            },
+            {
+                file: 'web/src/app/docs/command/page.tsx',
+                required: ['Command + I', 'Ctrl + I'],
+            },
+            {
+                file: 'web/src/app/docs/allowlist-denylist/page.tsx',
+                required: ['BadUrlsChecker', 'always allow', 'localhost'],
+            },
+            {
+                file: 'web/src/app/docs/browser-subagent/page.tsx',
+                required: ['DOM 捕获', '截图', '蓝色边框'],
+            },
+        ];
+
+        const missing = [];
+        for (const { file, required } of checks) {
+            const abs = path.resolve(file);
+            const content = fs.readFileSync(abs, 'utf8');
+            for (const token of required) {
+                if (!content.includes(token)) {
+                    missing.push(`${file} -> ${token}`);
+                }
+            }
+        }
+
+        assert.strictEqual(
+            missing.length,
+            0,
+            `localized docs missing official baseline tokens:\n${missing.join('\n')}`,
+        );
+    });
+});

package/tests/transformer.test.js

@@ -0,0 +1,74 @@
+const { test, describe, beforeEach, afterEach } = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const ResourceTransformer = require("../bin/core/transformer");
+
+describe("ResourceTransformer", () => {
+    let tempDir;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ag-kit-transformer-test-"));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    function transformWorkflow(markdown) {
+        const workflowPath = path.join(tempDir, "workflow.md");
+        fs.writeFileSync(workflowPath, markdown, "utf8");
+
+        const result = ResourceTransformer.transform({
+            skills: [],
+            workflows: [{ name: "demo", path: workflowPath, type: "workflow" }],
+        });
+
+        return result.mappedFiles.find((item) => item.destPath.endsWith("/SKILL.md"));
+    }
+
+    test("workflow frontmatter should parse CRLF and keep colon in description", () => {
+        const mapped = transformWorkflow([
+            "---\r",
+            "description: \"Run /debug: inspect failures\"\r",
+            "---\r",
+            "",
+            "# Workflow body",
+        ].join("\n"));
+
+        assert.ok(mapped);
+        assert.ok(mapped.content.includes("description: \"Run /debug: inspect failures\""));
+        assert.ok(mapped.content.includes("# Workflow body"));
+    });
+
+    test("workflow frontmatter should parse folded multiline description", () => {
+        const mapped = transformWorkflow([
+            "---",
+            "description: >",
+            "  先执行 /plan",
+            "  再执行 /debug",
+            "---",
+            "",
+            "# Workflow body",
+        ].join("\n"));
+
+        assert.ok(mapped);
+        assert.ok(mapped.content.includes("description: \"先执行 /plan 再执行 /debug\""));
+    });
+
+    test("workflow frontmatter should parse indented multiline description", () => {
+        const mapped = transformWorkflow([
+            "---",
+            "description:",
+            "  统一排查流程: 先收集日志",
+            "  再定位根因",
+            "---",
+            "",
+            "# Workflow body",
+        ].join("\n"));
+
+        assert.ok(mapped);
+        assert.ok(mapped.content.includes("description: \"统一排查流程: 先收集日志 再定位根因\""));
+    });
+});

package/tests/versioning.test.js

@@ -0,0 +1,51 @@
+const { test } = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("node:child_process");
+
+const REPO_ROOT = path.resolve(__dirname, "..");
+const LING_CLI = path.join(REPO_ROOT, "bin", "ling.js");
+const AG_KIT_CLI = path.join(REPO_ROOT, "bin", "ag-kit.js");
+const pkg = require(path.join(REPO_ROOT, "package.json"));
+
+function runCli(cliPath, args, envOverrides = {}) {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ling-version-test-"));
+    const env = {
+        ...process.env,
+        LING_SKIP_UPSTREAM_CHECK: "1",
+        LING_INDEX_PATH: path.join(tempRoot, "workspaces.json"),
+        ...envOverrides,
+    };
+
+    const result = spawnSync(process.execPath, [cliPath, ...args], {
+        cwd: REPO_ROOT,
+        env,
+        encoding: "utf8",
+    });
+
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+    return result;
+}
+
+test("npm package version should remain SemVer", () => {
+    assert.match(pkg.version, /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/);
+});
+
+test("ling --version should print ling- prefixed version tag", () => {
+    const result = runCli(LING_CLI, ["--version"]);
+    assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+    const stdout = String(result.stdout || "").trim();
+    assert.strictEqual(stdout, `ling version ling-${pkg.version}`);
+    assert.ok(!stdout.includes("[warn]"), "ling entry should not include legacy alias warning");
+});
+
+test("ag-kit --version should warn and print ling- prefixed version tag", () => {
+    const result = runCli(AG_KIT_CLI, ["--version"]);
+    assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+    const lines = String(result.stdout || "").trim().split(/\r?\n/);
+    assert.ok(lines.some((line) => line.includes("[warn]")), "ag-kit entry should include legacy alias warning");
+    assert.strictEqual(lines[lines.length - 1], `ling version ling-${pkg.version}`);
+});
+