svharness 0.13.3 → 0.14.1

package/dist/commands/doctor/check-chinese-heuristic.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkChineseHeuristic = checkChineseHeuristic;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+const SCAN_PATHS = [
+    'requirements/yaml',
+    'specs',
+    'agent-env/rules',
+    'agent-env/skills',
+    'tasks/templates',
+    'baseline/wiki',
+    'agent-env/memory',
+];
+const LATIN_RUN_MIN = 24;
+const LATIN_RUN = /[A-Za-z][A-Za-z0-9_\-./]{23,}/g;
+const ALLOWED_IN_LINE = [
+    /^CMDID_/,
+    /^https?:\/\//,
+    /schema\.json/,
+    /\.yaml$/,
+    /\.md$/,
+    /frontmatter/,
+];
+function lineLooksAllowed(line) {
+    const t = line.trim();
+    if (!t)
+        return true;
+    return ALLOWED_IN_LINE.some((re) => re.test(t));
+}
+async function checkChineseHeuristic(ctx) {
+    const id = 'chinese-heuristic';
+    const findings = [];
+    for (const sub of SCAN_PATHS) {
+        const root = node_path_1.default.join(ctx.harnessRoot, sub);
+        const files = await (0, utils_1.listRealFilesRecursive)(root, { extensions: ['.yaml', '.yml', '.md', '.mdc'] });
+        for (const file of files) {
+            if (file.endsWith('schema.json'))
+                continue;
+            const content = await fs_extra_1.default.readFile(file, 'utf8');
+            const lines = content.split(/\r?\n/);
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (lineLooksAllowed(line))
+                    continue;
+                const matches = line.match(LATIN_RUN);
+                if (matches && matches.some((m) => m.length >= LATIN_RUN_MIN)) {
+                    findings.push({
+                        checkId: id,
+                        severity: 'warning',
+                        message: `第 ${i + 1} 行疑似过长英文描述，请确认已中文化：${matches[0].slice(0, 40)}…`,
+                        path: (0, utils_1.rel)(ctx.harnessRoot, file),
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return { id, title: '中文产出启发式', findings };
+}

package/dist/commands/doctor/check-convert-pairing.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConvertPairing = checkConvertPairing;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+async function checkPairingForSide(ctx, side, findings, checkId) {
+    const rawDir = node_path_1.default.join(ctx.harnessRoot, side, 'raw');
+    const mdDir = node_path_1.default.join(ctx.harnessRoot, side, 'md');
+    if (!(await fs_extra_1.default.pathExists(rawDir)))
+        return;
+    const rawNames = await (0, utils_1.listDirEntries)(rawDir);
+    const mdNames = new Set((await (0, utils_1.listDirEntries)(mdDir)).map((n) => (0, utils_1.basenameWithoutExt)(n)));
+    for (const name of rawNames) {
+        const rawPath = node_path_1.default.join(rawDir, name);
+        const stat = await fs_extra_1.default.stat(rawPath);
+        if (!stat.isFile())
+            continue;
+        const ext = node_path_1.default.extname(name).toLowerCase();
+        if (ext === '.md') {
+            const base = (0, utils_1.basenameWithoutExt)(name);
+            if (!mdNames.has(base)) {
+                findings.push({
+                    checkId,
+                    severity: 'warning',
+                    message: `${side}/raw 中 ${name} 为 .md，建议在 ${side}/md/ 保留同基名副本或确认已条目化`,
+                    path: (0, utils_1.rel)(ctx.harnessRoot, rawPath),
+                });
+            }
+            continue;
+        }
+        if (!(0, utils_1.isRealFileName)(name))
+            continue;
+        const base = (0, utils_1.basenameWithoutExt)(name);
+        if (!mdNames.has(base)) {
+            findings.push({
+                checkId,
+                severity: 'error',
+                message: `${side}/raw/${name} 在 ${side}/md/ 缺少同基名 .md（${base}.md）`,
+                path: (0, utils_1.rel)(ctx.harnessRoot, rawPath),
+            });
+        }
+    }
+}
+async function checkConvertPairing(ctx) {
+    const id = 'convert-pairing';
+    const findings = [];
+    await checkPairingForSide(ctx, 'requirements', findings, id);
+    await checkPairingForSide(ctx, 'references', findings, id);
+    return { id, title: 'raw/md 转换配对', findings };
+}

package/dist/commands/doctor/check-empty-dirs.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmptyDirs = checkEmptyDirs;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+async function collectEmptyDirs(harnessRoot, dir, findings, checkId) {
+    if (!(await fs_extra_1.default.pathExists(dir)))
+        return;
+    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+    for (const ent of entries) {
+        if (ent.name.startsWith('.') && ent.name !== '.gitkeep')
+            continue;
+        const full = node_path_1.default.join(dir, ent.name);
+        if (ent.isDirectory()) {
+            const relPath = (0, utils_1.rel)(harnessRoot, full);
+            if (utils_1.EMPTY_DIR_WHITELIST.has(relPath)) {
+                await collectEmptyDirs(harnessRoot, full, findings, checkId);
+                continue;
+            }
+            if (relPath === 'agent-env/_incoming/skills') {
+                const state = await (0, utils_1.readBuildState)(harnessRoot);
+                const s65 = state?.phases.S65_customize_agent_env;
+                if (s65?.status === 'DONE') {
+                    await collectEmptyDirs(harnessRoot, full, findings, checkId);
+                    continue;
+                }
+            }
+            if (await (0, utils_1.isEmptyOrGitkeepOnly)(full)) {
+                findings.push({
+                    checkId,
+                    severity: 'error',
+                    message: `目录为空或仅含 .gitkeep：${relPath}`,
+                    path: relPath,
+                });
+            }
+            else {
+                await collectEmptyDirs(harnessRoot, full, findings, checkId);
+            }
+        }
+    }
+}
+async function checkEmptyDirs(ctx) {
+    const id = 'empty-dirs';
+    const findings = [];
+    await collectEmptyDirs(ctx.harnessRoot, ctx.harnessRoot, findings, id);
+    return { id, title: '空目录检查', findings };
+}

package/dist/commands/doctor/check-incoming.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIncoming = checkIncoming;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+async function checkIncoming(ctx) {
+    const id = 'incoming';
+    const findings = [];
+    const incomingDir = node_path_1.default.join(ctx.harnessRoot, 'agent-env', '_incoming', 'skills');
+    const manifestPath = node_path_1.default.join(ctx.harnessRoot, 'agent-env', '_incoming', 'manifest.yaml');
+    if (!(await fs_extra_1.default.pathExists(incomingDir))) {
+        return { id, title: 'Incoming 资产', findings };
+    }
+    const entries = await (0, utils_1.listDirEntries)(incomingDir);
+    const fileNames = await Promise.all(entries.map(async (n) => {
+        const full = node_path_1.default.join(incomingDir, n);
+        const s = await fs_extra_1.default.stat(full);
+        return s.isFile() ? n : null;
+    }));
+    const realFiles = fileNames.filter((n) => !!n && (0, utils_1.isRealFileName)(n));
+    if (realFiles.length === 0) {
+        return { id, title: 'Incoming 资产', findings };
+    }
+    const state = await (0, utils_1.readBuildState)(ctx.harnessRoot);
+    const s65 = state?.phases.S65_customize_agent_env;
+    if (s65?.status === 'DONE') {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: `S65 已 DONE 但 _incoming/skills/ 仍有未处理文件：${realFiles.join(', ')}`,
+            path: (0, utils_1.rel)(ctx.harnessRoot, incomingDir),
+        });
+    }
+    else if (!(await fs_extra_1.default.pathExists(manifestPath))) {
+        findings.push({
+            checkId: id,
+            severity: 'warning',
+            message: '_incoming/skills/ 有文件但缺少 manifest.yaml',
+            path: (0, utils_1.rel)(ctx.harnessRoot, manifestPath),
+        });
+    }
+    return { id, title: 'Incoming 资产', findings };
+}

package/dist/commands/doctor/check-memory.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMemory = checkMemory;
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+async function checkMemory(ctx) {
+    const id = 'memory';
+    const findings = [];
+    const categoriesDir = node_path_1.default.join(ctx.harnessRoot, 'agent-env', 'memory', 'categories');
+    const mdFiles = await (0, utils_1.listRealFilesRecursive)(categoriesDir, { extensions: ['.md'] });
+    if (mdFiles.length === 0) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: 'agent-env/memory/categories/ 无分类 .md（S80 须播种）',
+            path: 'agent-env/memory/categories',
+        });
+    }
+    return { id, title: 'Memory 分类', findings };
+}

package/dist/commands/doctor/check-policy-grep.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPolicyGrep = checkPolicyGrep;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+const SCAN_ROOTS = [
+    'specs',
+    'tasks',
+    'agent-env/rules',
+    'agent-env/skills',
+    'agent-env/memory',
+];
+const SCAN_EXTENSIONS = new Set(['.yaml', '.yml', '.md', '.mdc']);
+async function checkPolicyGrep(ctx) {
+    const id = 'policy-grep';
+    const findings = [];
+    for (const root of SCAN_ROOTS) {
+        const absRoot = node_path_1.default.join(ctx.harnessRoot, root);
+        const files = await (0, utils_1.listRealFilesRecursive)(absRoot);
+        for (const file of files) {
+            const ext = node_path_1.default.extname(file).toLowerCase();
+            if (!SCAN_EXTENSIONS.has(ext))
+                continue;
+            const content = (await fs_extra_1.default.readFile(file, 'utf8')).toLowerCase();
+            for (const term of utils_1.AGENT_BLACKLIST) {
+                const needle = term.toLowerCase();
+                if (content.includes(needle)) {
+                    findings.push({
+                        checkId: id,
+                        severity: 'error',
+                        message: `含 agent 绑定关键词 "${term}"`,
+                        path: (0, utils_1.rel)(ctx.harnessRoot, file),
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return { id, title: 'Agent-agnostic 策略', findings };
+}

package/dist/commands/doctor/check-references.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkReferences = checkReferences;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const utils_1 = require("./utils");
+async function checkReferences(ctx) {
+    const id = 'references';
+    const findings = [];
+    const rawDir = node_path_1.default.join(ctx.harnessRoot, 'references', 'raw');
+    const mdDir = node_path_1.default.join(ctx.harnessRoot, 'references', 'md');
+    const indexPath = node_path_1.default.join(ctx.harnessRoot, 'references', 'yaml', 'index.yaml');
+    const rawFiles = await (0, utils_1.listRealFilesRecursive)(rawDir);
+    const mdFiles = await (0, utils_1.listRealFilesRecursive)(mdDir, { extensions: ['.md'] });
+    if (rawFiles.length === 0 && mdFiles.length === 0) {
+        findings.push({
+            checkId: id,
+            severity: 'info',
+            message: 'references 无输入，若 S20 已确认「无新增」可忽略',
+        });
+        return { id, title: '参考资料', findings };
+    }
+    if (rawFiles.length > 0 && mdFiles.length === 0) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: 'references/raw 有文件但 references/md/ 无 Markdown 产物',
+            path: 'references/md',
+        });
+    }
+    if (rawFiles.length > 0 || mdFiles.length > 0) {
+        if (!(await fs_extra_1.default.pathExists(indexPath))) {
+            findings.push({
+                checkId: id,
+                severity: 'error',
+                message: '缺少 references/yaml/index.yaml 结构化索引（S60 产出）',
+                path: 'references/yaml/index.yaml',
+            });
+        }
+        else {
+            try {
+                const raw = await fs_extra_1.default.readFile(indexPath, 'utf8');
+                if (!raw.trim()) {
+                    findings.push({
+                        checkId: id,
+                        severity: 'error',
+                        message: 'references/yaml/index.yaml 为空',
+                        path: 'references/yaml/index.yaml',
+                    });
+                }
+                else {
+                    const doc = js_yaml_1.default.load(raw);
+                    if (!doc || typeof doc !== 'object') {
+                        findings.push({
+                            checkId: id,
+                            severity: 'error',
+                            message: 'references/yaml/index.yaml 解析为空',
+                            path: 'references/yaml/index.yaml',
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                findings.push({
+                    checkId: id,
+                    severity: 'error',
+                    message: `index.yaml 解析失败：${err.message}`,
+                    path: 'references/yaml/index.yaml',
+                });
+            }
+        }
+    }
+    return { id, title: '参考资料', findings };
+}

package/dist/commands/doctor/check-requirements.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRequirements = checkRequirements;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const utils_1 = require("./utils");
+async function checkRequirements(ctx) {
+    const id = 'requirements';
+    const findings = [];
+    const rawDir = node_path_1.default.join(ctx.harnessRoot, 'requirements', 'raw');
+    const yamlDir = node_path_1.default.join(ctx.harnessRoot, 'requirements', 'yaml');
+    const rawFiles = await (0, utils_1.listRealFilesRecursive)(rawDir);
+    if (rawFiles.length === 0) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: 'requirements/raw/ 无真实文档（不得仅含 .gitkeep）',
+            path: 'requirements/raw',
+        });
+    }
+    const yamlFiles = (await (0, utils_1.listRealFilesRecursive)(yamlDir, { extensions: ['.yaml', '.yml'] })).filter((f) => !f.endsWith('schema.json'));
+    if (yamlFiles.length === 0) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: 'requirements/yaml/ 无条目化 YAML 产出',
+            path: 'requirements/yaml',
+        });
+    }
+    else {
+        for (const file of yamlFiles) {
+            try {
+                const raw = await fs_extra_1.default.readFile(file, 'utf8');
+                if (!raw.trim()) {
+                    findings.push({
+                        checkId: id,
+                        severity: 'error',
+                        message: 'requirements YAML 文件为空',
+                        path: (0, utils_1.rel)(ctx.harnessRoot, file),
+                    });
+                    continue;
+                }
+                js_yaml_1.default.load(raw);
+            }
+            catch (err) {
+                findings.push({
+                    checkId: id,
+                    severity: 'error',
+                    message: `requirements YAML 解析失败：${err.message}`,
+                    path: (0, utils_1.rel)(ctx.harnessRoot, file),
+                });
+            }
+        }
+    }
+    const mdDir = node_path_1.default.join(ctx.harnessRoot, 'requirements', 'md');
+    if (rawFiles.length > 0 && (await (0, utils_1.listDirEntries)(mdDir)).length === 0) {
+        findings.push({
+            checkId: id,
+            severity: 'warning',
+            message: 'requirements/raw 有文件但 requirements/md/ 为空，请确认 S30 已完成',
+            path: 'requirements/md',
+        });
+    }
+    return { id, title: '需求文档', findings };
+}

package/dist/commands/doctor/check-skills-tasks.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSkillsTasks = checkSkillsTasks;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("./utils");
+const skill_md_validate_1 = require("../../utils/skill-md-validate");
+async function countTaskCategories(templatesDir) {
+    if (!(await fs_extra_1.default.pathExists(templatesDir)))
+        return 0;
+    const entries = await fs_extra_1.default.readdir(templatesDir, { withFileTypes: true });
+    let matched = 0;
+    const seen = new Set();
+    for (const ent of entries) {
+        if (!ent.isDirectory())
+            continue;
+        const dirPath = node_path_1.default.join(templatesDir, ent.name);
+        const mdFiles = (await fs_extra_1.default.readdir(dirPath)).filter((n) => n.endsWith('.md'));
+        if (mdFiles.length === 0)
+            continue;
+        const haystack = `${ent.name} ${mdFiles.join(' ')}`.toLowerCase();
+        for (let i = 0; i < utils_1.TASK_CATEGORY_HINTS.length; i++) {
+            if (seen.has(i))
+                continue;
+            if (utils_1.TASK_CATEGORY_HINTS[i].some((kw) => haystack.includes(kw.toLowerCase()))) {
+                seen.add(i);
+                matched++;
+            }
+        }
+    }
+    if (matched < 3) {
+        const flatMd = await fs_extra_1.default
+            .readdir(templatesDir)
+            .then((names) => names.filter((n) => n.endsWith('.md')));
+        if (flatMd.length >= 3)
+            matched = 3;
+    }
+    return matched;
+}
+async function checkSkillsTasks(ctx) {
+    const id = 'skills-tasks';
+    const findings = [];
+    const skillsDir = node_path_1.default.join(ctx.harnessRoot, 'agent-env', 'skills');
+    const templatesDir = node_path_1.default.join(ctx.harnessRoot, 'tasks', 'templates');
+    if (!(await fs_extra_1.default.pathExists(skillsDir))) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: '缺少 agent-env/skills/',
+            path: 'agent-env/skills',
+        });
+    }
+    else {
+        const skillDirs = (await fs_extra_1.default.readdir(skillsDir, { withFileTypes: true })).filter((d) => d.isDirectory() && !d.name.startsWith('.'));
+        const runtimeSkills = skillDirs.filter((d) => !d.name.startsWith('harness-build-'));
+        if (runtimeSkills.length === 0) {
+            findings.push({
+                checkId: id,
+                severity: 'error',
+                message: 'agent-env/skills/ 无运行期 skill 子目录',
+                path: 'agent-env/skills',
+            });
+        }
+        for (const dir of runtimeSkills) {
+            const skillMd = node_path_1.default.join(skillsDir, dir.name, 'SKILL.md');
+            if (!(await fs_extra_1.default.pathExists(skillMd))) {
+                findings.push({
+                    checkId: id,
+                    severity: 'error',
+                    message: `skill 目录缺少 SKILL.md：${dir.name}`,
+                    path: (0, utils_1.rel)(ctx.harnessRoot, node_path_1.default.join(skillsDir, dir.name)),
+                });
+                continue;
+            }
+            for (const msg of await (0, skill_md_validate_1.validateFrontmatterFields)({
+                targetRoot: ctx.harnessRoot,
+                file: skillMd,
+                requiredKeys: ['name', 'description'],
+            })) {
+                findings.push({ checkId: id, severity: 'error', message: msg, path: (0, utils_1.rel)(ctx.harnessRoot, skillMd) });
+            }
+            for (const msg of await (0, skill_md_validate_1.validateSkillNameMatchesDir)({
+                targetRoot: ctx.harnessRoot,
+                file: skillMd,
+            })) {
+                findings.push({ checkId: id, severity: 'warning', message: msg, path: (0, utils_1.rel)(ctx.harnessRoot, skillMd) });
+            }
+        }
+    }
+    const categoryCount = await countTaskCategories(templatesDir);
+    if (categoryCount < 3) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: `tasks/templates/ 须覆盖三类典型场景（当前识别 ${categoryCount}/3）`,
+            path: 'tasks/templates',
+        });
+    }
+    return { id, title: 'Skills 与 Tasks', findings };
+}

package/dist/commands/doctor/check-specs.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSpecs = checkSpecs;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const utils_1 = require("./utils");
+const SPEC_DOMAINS = ['signals', 'ui', 'behavior', 'interfaces'];
+async function checkSpecs(ctx) {
+    const id = 'specs';
+    const findings = [];
+    const ajv = new ajv_1.default({ allErrors: true, strict: false });
+    (0, ajv_formats_1.default)(ajv);
+    for (const domain of SPEC_DOMAINS) {
+        const domainDir = node_path_1.default.join(ctx.harnessRoot, 'specs', domain);
+        const schemaPath = node_path_1.default.join(domainDir, 'schema.json');
+        if (!(await fs_extra_1.default.pathExists(schemaPath))) {
+            findings.push({
+                checkId: id,
+                severity: 'error',
+                message: `缺少 schema：specs/${domain}/schema.json`,
+                path: `specs/${domain}/schema.json`,
+            });
+            continue;
+        }
+        const specFiles = (await (0, utils_1.listRealFilesRecursive)(domainDir, { extensions: ['.yaml', '.yml'] })).filter((f) => !f.endsWith('schema.json') && !f.endsWith('schema.yaml'));
+        const moduleYaml = specFiles.filter((f) => node_path_1.default.basename(f) !== 'schema.json');
+        if (moduleYaml.length === 0) {
+            findings.push({
+                checkId: id,
+                severity: 'error',
+                message: `specs/${domain}/ 无模块 YAML（除 schema.json 外）`,
+                path: `specs/${domain}`,
+            });
+            continue;
+        }
+        let validate;
+        try {
+            const schema = JSON.parse(await fs_extra_1.default.readFile(schemaPath, 'utf8'));
+            validate = ajv.compile(schema);
+        }
+        catch (err) {
+            findings.push({
+                checkId: id,
+                severity: 'error',
+                message: `specs/${domain}/schema.json 无效：${err.message}`,
+                path: `specs/${domain}/schema.json`,
+            });
+            continue;
+        }
+        for (const file of moduleYaml) {
+            try {
+                const doc = js_yaml_1.default.load(await fs_extra_1.default.readFile(file, 'utf8'));
+                if (!validate(doc)) {
+                    const detail = (validate.errors ?? [])
+                        .slice(0, 3)
+                        .map((e) => `${e.instancePath || '/'} ${e.message}`)
+                        .join('; ');
+                    findings.push({
+                        checkId: id,
+                        severity: 'error',
+                        message: `schema 校验失败：${detail}`,
+                        path: (0, utils_1.rel)(ctx.harnessRoot, file),
+                    });
+                }
+            }
+            catch (err) {
+                findings.push({
+                    checkId: id,
+                    severity: 'error',
+                    message: `YAML 解析失败：${err.message}`,
+                    path: (0, utils_1.rel)(ctx.harnessRoot, file),
+                });
+            }
+        }
+    }
+    return { id, title: 'Specs 四域与 schema', findings };
+}