@dinoxx/dinox-cli 1.1.1 → 2.1.0

package/dist/skills/check.js

@@ -1,11 +1,25 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { isMap, isScalar, parseDocument } from 'yaml';
 import { findCommandSchema, listCommandSchemas } from '../commands/schema/spec.js';
-const EXEMPT_SHARED_REFERENCE = new Set(['dino-dinox', 'dino-shared']);
-const SHARED_REFERENCE_PATTERN = /\.\.\/dino-shared\/SKILL\.md/;
-const BINS_PATTERN = /^metadata:\s*[\s\S]*?^  requires:\s*[\s\S]*?^    bins:\s*\[(.*?)\]\s*$/m;
-const CLI_HELP_PATTERN = /^metadata:\s*[\s\S]*?^  cliHelp:\s*.+$/m;
-const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const SKILL_NAME_PATTERN = /^(?!.*--)[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SKILL_DESCRIPTION_CATALOG_MAX_CHARS = 160;
+const SKILL_DESCRIPTION_FIRST_SENTENCE_MAX_CHARS = 60;
+const PORTABLE_FRONTMATTER_FIELDS = new Set([
+    'name',
+    'description',
+    'license',
+    'compatibility',
+    'metadata',
+    'allowed-tools',
+]);
+const SKILL_MAX_LINES = 500;
+const SKILL_EVALS_RELATIVE_PATH = path.join('evals', 'evals.json');
+const MIN_OUTPUT_EVALS = 3;
+const MIN_TRIGGER_EVALS_PER_SPLIT = 4;
 const commandSchemas = listCommandSchemas();
 const commandSchemaPrefixes = commandSchemas
     .map((schema) => ({
@@ -26,17 +40,58 @@ function parseFrontmatter(content) {
 }
 function extractRelativeMarkdownLinks(body) {
     const links = new Set();
-    const pattern = /\[[^\]]+\]\(([^)]+\.md)\)/g;
-    let match = null;
-    while ((match = pattern.exec(body)) !== null) {
-        const target = match[1]?.trim();
-        if (!target || target.startsWith('http://') || target.startsWith('https://')) {
+    const root = unified().use(remarkParse).parse(body);
+    const pending = [root];
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node.children) {
+            pending.push(...node.children);
+        }
+        if (!['definition', 'image', 'link'].includes(node.type ?? '') || typeof node.url !== 'string') {
+            continue;
+        }
+        const rawTarget = node.url.trim();
+        if (!rawTarget) {
+            continue;
+        }
+        if (rawTarget.startsWith('#')) {
+            continue;
+        }
+        const scheme = rawTarget.match(/^([A-Za-z][A-Za-z0-9+.-]*):/);
+        if (scheme && scheme[1]?.toLowerCase() !== 'file') {
+            continue;
+        }
+        const withoutFragment = rawTarget.split(/[?#]/, 1)[0] ?? '';
+        if (!withoutFragment.toLowerCase().endsWith('.md')) {
             continue;
         }
-        links.add(target);
+        try {
+            links.add(decodeURIComponent(withoutFragment));
+        }
+        catch {
+            links.add(withoutFragment);
+        }
     }
     return [...links];
 }
+function countLines(content) {
+    const normalized = content.replace(/\r\n/g, '\n');
+    const withoutFinalNewline = normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+    return withoutFinalNewline === '' ? 0 : withoutFinalNewline.split('\n').length;
+}
+function characterCount(value) {
+    return Array.from(value).length;
+}
+function normalizeTriggerQuery(value) {
+    return value.normalize('NFKC').trim().replace(/\s+/g, ' ').toLocaleLowerCase('en-US');
+}
+function isPathWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function walkMarkdownFiles(skillDir) {
     const files = [];
     for (const entry of fs.readdirSync(skillDir, { withFileTypes: true })) {
@@ -156,8 +211,18 @@ function checkMarkdownDocument(skill, content, relativePath, skillDir) {
     const issues = [];
     for (const relativeTarget of extractRelativeMarkdownLinks(content)) {
         const resolved = path.resolve(path.dirname(path.join(skillDir, relativePath)), relativeTarget);
-        if (!fs.existsSync(resolved)) {
+        if (!isPathWithin(path.resolve(skillDir), resolved)) {
+            issues.push({ skill, message: `${relativePath}: referenced markdown file must stay within the skill directory: ${relativeTarget}` });
+            continue;
+        }
+        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
             issues.push({ skill, message: `${relativePath}: referenced markdown file does not exist: ${relativeTarget}` });
+            continue;
+        }
+        const realSkillDir = fs.realpathSync(skillDir);
+        const realResolved = fs.realpathSync(resolved);
+        if (!isPathWithin(realSkillDir, realResolved)) {
+            issues.push({ skill, message: `${relativePath}: referenced markdown file resolves outside the skill directory: ${relativeTarget}` });
         }
     }
     for (const command of extractDinoCommands(content)) {
@@ -167,74 +232,442 @@ function checkMarkdownDocument(skill, content, relativePath, skillDir) {
     }
     return issues;
 }
-export function checkSkillContent(skill, content, skillDir, expectedVersion) {
-    const issues = [];
-    const parsed = parseFrontmatter(content);
-    if (!parsed) {
-        return [{ skill, message: 'SKILL.md must start with valid YAML frontmatter.' }];
+function checkOpenAiAdapter(skill, adapterPath) {
+    const relativePath = 'agents/openai.yaml';
+    if (!fs.statSync(adapterPath).isFile()) {
+        return [{ skill, message: `${relativePath}: adapter path must be a file.` }];
+    }
+    const skillDir = path.dirname(path.dirname(adapterPath));
+    if (!isPathWithin(fs.realpathSync(skillDir), fs.realpathSync(adapterPath))) {
+        return [{ skill, message: `${relativePath}: adapter must stay within the skill directory.` }];
+    }
+    const document = parseDocument(fs.readFileSync(adapterPath, 'utf8'), {
+        prettyErrors: false,
+        uniqueKeys: true,
+    });
+    const yamlProblems = [...document.errors, ...document.warnings];
+    if (yamlProblems.length > 0) {
+        const detail = yamlProblems.map((error) => error.message).join('; ');
+        return [{ skill, message: `${relativePath}: invalid YAML: ${detail}` }];
+    }
+    if (!isMap(document.contents)) {
+        return [{ skill, message: `${relativePath}: adapter must be a YAML mapping.` }];
+    }
+    let values;
+    try {
+        const parsedValues = document.toJS({ maxAliasCount: 100 });
+        if (typeof parsedValues !== 'object' || parsedValues === null || Array.isArray(parsedValues)) {
+            return [{ skill, message: `${relativePath}: adapter must be a YAML mapping.` }];
+        }
+        values = parsedValues;
     }
-    const { frontmatter, body } = parsed;
-    const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
-    if (!nameMatch) {
-        issues.push({ skill, message: "Frontmatter is missing 'name'." });
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [{ skill, message: `${relativePath}: adapter could not be decoded: ${message}` }];
     }
-    else if (nameMatch[1]?.trim() !== skill) {
-        issues.push({ skill, message: `Frontmatter name must match directory name (${skill}).` });
+    const issues = [];
+    const interfaceValue = values.interface;
+    if (typeof interfaceValue !== 'object' || interfaceValue === null || Array.isArray(interfaceValue)) {
+        return [{ skill, message: `${relativePath}: 'interface' must be a YAML mapping.` }];
     }
-    if (!/^description:\s*/m.test(frontmatter)) {
-        issues.push({ skill, message: "Frontmatter is missing 'description'." });
+    const interfaceFields = interfaceValue;
+    const displayName = interfaceFields.display_name;
+    if (typeof displayName !== 'string' || displayName.trim() === '') {
+        issues.push({ skill, message: `${relativePath}: interface.display_name must be a non-empty string.` });
     }
-    const versionMatch = frontmatter.match(/^version:\s*(.+)$/m);
-    if (!versionMatch) {
-        issues.push({ skill, message: "Frontmatter is missing 'version'." });
+    const shortDescription = interfaceFields.short_description;
+    if (typeof shortDescription !== 'string') {
+        issues.push({ skill, message: `${relativePath}: interface.short_description must be a string of 25-64 characters.` });
     }
     else {
-        const version = versionMatch[1]?.trim() ?? '';
-        if (!SEMVER_PATTERN.test(version)) {
-            issues.push({ skill, message: "Frontmatter 'version' must be a semver string." });
+        const length = characterCount(shortDescription.trim());
+        if (length < 25 || length > 64) {
+            issues.push({ skill, message: `${relativePath}: interface.short_description must be 25-64 characters.` });
         }
-        if (expectedVersion && version !== expectedVersion) {
-            issues.push({ skill, message: `Frontmatter version must match skills/VERSION (${expectedVersion}).` });
+    }
+    const defaultPrompt = interfaceFields.default_prompt;
+    if (typeof defaultPrompt !== 'string' || defaultPrompt.trim() === '') {
+        issues.push({ skill, message: `${relativePath}: interface.default_prompt must be a non-empty string.` });
+    }
+    else {
+        const skillMention = new RegExp(`\\$${escapeRegExp(skill)}(?![a-z0-9-])`);
+        if (!skillMention.test(defaultPrompt)) {
+            issues.push({
+                skill,
+                message: `${relativePath}: interface.default_prompt must contain the exact skill mention '$${skill}'.`,
+            });
         }
     }
-    if (!/^metadata:\s*$/m.test(frontmatter)) {
-        issues.push({ skill, message: "Frontmatter is missing 'metadata'." });
+    return issues;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function isEvalId(value) {
+    return (typeof value === 'string' && value.trim() !== '')
+        || (typeof value === 'number' && Number.isFinite(value));
+}
+function checkEvaluationFileReference(skill, skillDir, value, location) {
+    if (!isNonEmptyString(value)) {
+        return [{ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location} must be a non-empty string.` }];
+    }
+    const resolved = path.resolve(skillDir, value);
+    if (!isPathWithin(path.resolve(skillDir), resolved)) {
+        return [{ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location} must stay within the skill directory: ${value}` }];
+    }
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+        return [{ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location} does not exist: ${value}` }];
+    }
+    if (!isPathWithin(fs.realpathSync(skillDir), fs.realpathSync(resolved))) {
+        return [{ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location} resolves outside the skill directory: ${value}` }];
+    }
+    return [];
+}
+function checkSkillEvaluations(skill, skillDir) {
+    const manifestPath = path.join(skillDir, SKILL_EVALS_RELATIVE_PATH);
+    if (!fs.existsSync(manifestPath)) {
+        return [];
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [{ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: invalid JSON: ${message}` }];
+    }
+    if (typeof manifest !== 'object' || manifest === null || Array.isArray(manifest)) {
+        return [{ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: manifest must be a JSON object.` }];
+    }
+    const values = manifest;
+    const issues = [];
+    if (values.skill_name !== skill) {
+        issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: skill_name must match directory name (${skill}).` });
+    }
+    if (values.schema_version !== 1) {
+        issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: schema_version must be 1.` });
     }
-    const binsMatch = frontmatter.match(BINS_PATTERN);
-    if (!binsMatch) {
-        issues.push({ skill, message: "Frontmatter must include metadata.requires.bins." });
+    const outputEvals = values.evals;
+    if (!Array.isArray(outputEvals) || outputEvals.length < MIN_OUTPUT_EVALS) {
+        issues.push({
+            skill,
+            message: `${SKILL_EVALS_RELATIVE_PATH}: evals must contain at least ${MIN_OUTPUT_EVALS} output-quality cases.`,
+        });
     }
     else {
-        const bins = binsMatch[1]?.split(',').map((value) => value.replace(/["'\s]/g, '')).filter(Boolean) ?? [];
-        if (!bins.includes('dino')) {
-            issues.push({ skill, message: "metadata.requires.bins must include 'dino'." });
+        const ids = new Set();
+        outputEvals.forEach((entry, index) => {
+            const location = `evals[${index}]`;
+            if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location} must be an object.` });
+                return;
+            }
+            const evalCase = entry;
+            if (!isEvalId(evalCase.id)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.id must be a non-empty string or finite number.` });
+            }
+            else {
+                const id = String(evalCase.id);
+                if (ids.has(id)) {
+                    issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: duplicate output eval id '${id}'.` });
+                }
+                ids.add(id);
+            }
+            if (!isNonEmptyString(evalCase.prompt)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.prompt must be a non-empty string.` });
+            }
+            if (!isNonEmptyString(evalCase.expected_output)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.expected_output must be a non-empty string.` });
+            }
+            if (evalCase.assertions !== undefined) {
+                if (!Array.isArray(evalCase.assertions) || evalCase.assertions.length === 0
+                    || evalCase.assertions.some((assertion) => !isNonEmptyString(assertion))) {
+                    issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.assertions must be a non-empty string array when provided.` });
+                }
+            }
+            if (evalCase.files !== undefined) {
+                if (!Array.isArray(evalCase.files)) {
+                    issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.files must be an array when provided.` });
+                }
+                else {
+                    evalCase.files.forEach((file, fileIndex) => {
+                        issues.push(...checkEvaluationFileReference(skill, skillDir, file, `${location}.files[${fileIndex}]`));
+                    });
+                }
+            }
+        });
+    }
+    const triggerEvals = values.trigger_evals;
+    if (!Array.isArray(triggerEvals)) {
+        issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: trigger_evals must be an array.` });
+    }
+    else {
+        const ids = new Set();
+        const queries = new Set();
+        const splitCounts = new Map([
+            ['train', { total: 0, positive: 0, negative: 0 }],
+            ['validation', { total: 0, positive: 0, negative: 0 }],
+        ]);
+        triggerEvals.forEach((entry, index) => {
+            const location = `trigger_evals[${index}]`;
+            if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location} must be an object.` });
+                return;
+            }
+            const triggerCase = entry;
+            if (!isEvalId(triggerCase.id)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.id must be a non-empty string or finite number.` });
+            }
+            else {
+                const id = String(triggerCase.id);
+                if (ids.has(id)) {
+                    issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: duplicate trigger eval id '${id}'.` });
+                }
+                ids.add(id);
+            }
+            const split = triggerCase.split;
+            if (split !== 'train' && split !== 'validation') {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.split must be 'train' or 'validation'.` });
+            }
+            if (!isNonEmptyString(triggerCase.query)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.query must be a non-empty string.` });
+            }
+            else {
+                const normalizedQuery = normalizeTriggerQuery(triggerCase.query);
+                if (queries.has(normalizedQuery)) {
+                    issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: duplicate trigger query '${triggerCase.query.trim()}'.` });
+                }
+                queries.add(normalizedQuery);
+            }
+            if (typeof triggerCase.should_trigger !== 'boolean') {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.should_trigger must be a boolean.` });
+            }
+            if (!isNonEmptyString(triggerCase.reason)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.reason must explain the routing boundary.` });
+            }
+            const expectedSkills = triggerCase.expected_skills;
+            if (!Array.isArray(expectedSkills)
+                || expectedSkills.some((expectedSkill) => !isNonEmptyString(expectedSkill) || !SKILL_NAME_PATTERN.test(expectedSkill))) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.expected_skills must be an array of portable skill names.` });
+            }
+            else if (triggerCase.should_trigger === true && !expectedSkills.includes(skill)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.expected_skills must include ${skill} when should_trigger is true.` });
+            }
+            else if (triggerCase.should_trigger === false && expectedSkills.includes(skill)) {
+                issues.push({ skill, message: `${SKILL_EVALS_RELATIVE_PATH}: ${location}.expected_skills must not include ${skill} when should_trigger is false.` });
+            }
+            if ((split === 'train' || split === 'validation') && typeof triggerCase.should_trigger === 'boolean') {
+                const count = splitCounts.get(split);
+                count.total += 1;
+                if (triggerCase.should_trigger) {
+                    count.positive += 1;
+                }
+                else {
+                    count.negative += 1;
+                }
+            }
+        });
+        for (const [split, counts] of splitCounts) {
+            if (counts.total < MIN_TRIGGER_EVALS_PER_SPLIT || counts.positive === 0 || counts.negative === 0) {
+                issues.push({
+                    skill,
+                    message: `${SKILL_EVALS_RELATIVE_PATH}: ${split} trigger evals must contain at least ${MIN_TRIGGER_EVALS_PER_SPLIT} cases with both positive and near-miss negative examples.`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+function readExpectedSkillsFromEvaluations(skillDir) {
+    const manifestPath = path.join(skillDir, SKILL_EVALS_RELATIVE_PATH);
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (!Array.isArray(manifest.trigger_evals)) {
+            return [];
         }
+        return manifest.trigger_evals.flatMap((entry) => {
+            if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+                return [];
+            }
+            const expectedSkills = entry.expected_skills;
+            return Array.isArray(expectedSkills)
+                ? expectedSkills.filter(isNonEmptyString)
+                : [];
+        });
     }
-    if (!CLI_HELP_PATTERN.test(frontmatter)) {
-        issues.push({ skill, message: "Frontmatter should include 'metadata.cliHelp'." });
+    catch {
+        return [];
     }
-    if (skill === 'dino-shared' && !/^user-invocable:\s*false\s*$/m.test(frontmatter)) {
-        issues.push({ skill, message: "dino-shared must declare 'user-invocable: false'." });
+}
+function readTriggerQueriesFromEvaluations(skillDir) {
+    const manifestPath = path.join(skillDir, SKILL_EVALS_RELATIVE_PATH);
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (!Array.isArray(manifest.trigger_evals)) {
+            return [];
+        }
+        return manifest.trigger_evals.flatMap((entry) => {
+            if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+                return [];
+            }
+            const query = entry.query;
+            return isNonEmptyString(query) ? [query.trim()] : [];
+        });
     }
-    if (skill === 'dino-dinox' && !/^user-invocable:\s*false\s*$/m.test(frontmatter)) {
-        issues.push({ skill, message: "dino-dinox must declare 'user-invocable: false'." });
+    catch {
+        return [];
+    }
+}
+export function checkSkillContent(skill, content, skillDir, expectedVersion) {
+    const issues = [];
+    const parsed = parseFrontmatter(content);
+    if (!parsed) {
+        return [{ skill, message: 'SKILL.md must start with valid YAML frontmatter.' }];
     }
-    if (!EXEMPT_SHARED_REFERENCE.has(skill) && !/^argument-hint:\s*/m.test(frontmatter)) {
-        issues.push({ skill, message: "User-invocable skills should declare 'argument-hint'." });
+    const { frontmatter, body } = parsed;
+    const document = parseDocument(frontmatter, {
+        prettyErrors: false,
+        uniqueKeys: true,
+    });
+    const yamlProblems = [...document.errors, ...document.warnings];
+    if (yamlProblems.length > 0) {
+        const detail = yamlProblems.map((error) => error.message).join('; ');
+        issues.push({ skill, message: `Frontmatter is not valid YAML: ${detail}` });
+    }
+    else if (!isMap(document.contents)) {
+        issues.push({ skill, message: 'Frontmatter must be a YAML mapping.' });
     }
-    if (!EXEMPT_SHARED_REFERENCE.has(skill) && !/^allowed-tools:\s*$/m.test(frontmatter)) {
-        issues.push({ skill, message: "User-invocable skills should declare 'allowed-tools'." });
+    else {
+        let values = null;
+        try {
+            const parsedValues = document.toJS({ maxAliasCount: 100 });
+            if (typeof parsedValues === 'object' && parsedValues !== null && !Array.isArray(parsedValues)) {
+                values = parsedValues;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            issues.push({ skill, message: `Frontmatter could not be decoded: ${message}` });
+        }
+        for (const pair of document.contents.items) {
+            if (!isScalar(pair.key) || typeof pair.key.value !== 'string') {
+                issues.push({ skill, message: 'Frontmatter field names must be strings.' });
+            }
+        }
+        if (values) {
+            for (const field of Object.keys(values)) {
+                if (!PORTABLE_FRONTMATTER_FIELDS.has(field)) {
+                    issues.push({
+                        skill,
+                        message: `Unsupported portable frontmatter field '${field}'. Move vendor-specific settings to an agent adapter.`,
+                    });
+                }
+            }
+            const name = values.name;
+            if (typeof name !== 'string' || name.trim() === '') {
+                issues.push({ skill, message: "Frontmatter is missing a non-empty string 'name'." });
+            }
+            else {
+                if (characterCount(name) > 64 || !SKILL_NAME_PATTERN.test(name)) {
+                    issues.push({
+                        skill,
+                        message: "Frontmatter 'name' must be 1-64 lowercase letters, numbers, or single hyphens, without leading or trailing hyphens.",
+                    });
+                }
+                if (name !== skill) {
+                    issues.push({ skill, message: `Frontmatter name must match directory name (${skill}).` });
+                }
+            }
+            const description = values.description;
+            if (typeof description !== 'string' || description.trim() === '') {
+                issues.push({ skill, message: "Frontmatter is missing a non-empty string 'description'." });
+            }
+            else if (characterCount(description.trim()) > 1024) {
+                issues.push({ skill, message: "Frontmatter 'description' must not exceed 1024 characters." });
+            }
+            else {
+                const normalizedDescription = description.trim();
+                if (characterCount(normalizedDescription) > SKILL_DESCRIPTION_CATALOG_MAX_CHARS) {
+                    issues.push({
+                        skill,
+                        message: `Frontmatter 'description' must stay within the ${SKILL_DESCRIPTION_CATALOG_MAX_CHARS}-character portable catalog budget.`,
+                    });
+                }
+                if (!normalizedDescription.startsWith('Use this skill')) {
+                    issues.push({
+                        skill,
+                        message: "Frontmatter 'description' must start with imperative 'Use this skill' routing guidance.",
+                    });
+                }
+                const firstSentence = normalizedDescription.match(/^.*?[.!?。！？](?:\s|$)/u)?.[0].trim();
+                if (!firstSentence
+                    || characterCount(firstSentence) > SKILL_DESCRIPTION_FIRST_SENTENCE_MAX_CHARS) {
+                    issues.push({
+                        skill,
+                        message: `Frontmatter 'description' must start with a complete routing sentence of at most ${SKILL_DESCRIPTION_FIRST_SENTENCE_MAX_CHARS} characters for truncated catalogs.`,
+                    });
+                }
+            }
+            if (values.license !== undefined && (typeof values.license !== 'string' || values.license.trim() === '')) {
+                issues.push({ skill, message: "Frontmatter 'license' must be a non-empty string when provided." });
+            }
+            if (values.compatibility !== undefined) {
+                if (typeof values.compatibility !== 'string' || values.compatibility.trim() === '') {
+                    issues.push({ skill, message: "Frontmatter 'compatibility' must be a non-empty string when provided." });
+                }
+                else if (characterCount(values.compatibility.trim()) > 500) {
+                    issues.push({ skill, message: "Frontmatter 'compatibility' must not exceed 500 characters." });
+                }
+            }
+            if (values['allowed-tools'] !== undefined
+                && (typeof values['allowed-tools'] !== 'string' || values['allowed-tools'].trim() === '')) {
+                issues.push({ skill, message: "Frontmatter 'allowed-tools' must be a space-separated string when provided." });
+            }
+            const metadataPair = document.contents.items.find((pair) => isScalar(pair.key) && pair.key.value === 'metadata');
+            const metadata = values.metadata;
+            if (metadata !== undefined) {
+                if (!metadataPair || !isMap(metadataPair.value)) {
+                    issues.push({ skill, message: "Frontmatter 'metadata' must be a string-to-string mapping when provided." });
+                }
+                else {
+                    for (const pair of metadataPair.value.items) {
+                        if (!isScalar(pair.key) || typeof pair.key.value !== 'string') {
+                            issues.push({ skill, message: "Frontmatter 'metadata' keys must be strings." });
+                        }
+                        if (!isScalar(pair.value) || typeof pair.value.value !== 'string') {
+                            const key = isScalar(pair.key) ? String(pair.key.value) : '<unknown>';
+                            issues.push({ skill, message: `Frontmatter metadata.${key} must be a string.` });
+                        }
+                    }
+                }
+            }
+            const metadataRecord = typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata)
+                ? metadata
+                : undefined;
+            const version = metadataRecord?.version;
+            if (version !== undefined && (typeof version !== 'string' || !SEMVER_PATTERN.test(version))) {
+                issues.push({ skill, message: 'Frontmatter metadata.version must be a semver string.' });
+            }
+            if (expectedVersion) {
+                if (version === undefined) {
+                    issues.push({ skill, message: 'Frontmatter metadata.version is required for versioned Dinox skill collections.' });
+                }
+                else if (version !== expectedVersion) {
+                    issues.push({ skill, message: `Frontmatter metadata.version must match skills/VERSION (${expectedVersion}).` });
+                }
+            }
+        }
     }
-    if (!EXEMPT_SHARED_REFERENCE.has(skill) && !SHARED_REFERENCE_PATTERN.test(body)) {
-        issues.push({ skill, message: 'User-invocable skills must tell the agent to read ../dino-shared/SKILL.md first.' });
+    if (body.trim() === '') {
+        issues.push({ skill, message: 'SKILL.md must include Markdown instructions after the frontmatter.' });
     }
-    if (!EXEMPT_SHARED_REFERENCE.has(skill) && !/^## Safety & Boundaries/m.test(body)) {
-        issues.push({ skill, message: "User-invocable skills should include a '## Safety & Boundaries' section." });
+    if (countLines(content) > SKILL_MAX_LINES) {
+        issues.push({ skill, message: `SKILL.md must stay at or below ${SKILL_MAX_LINES} lines; move details into references/.` });
     }
-    if (!EXEMPT_SHARED_REFERENCE.has(skill) && body.includes('dino ') && !body.includes('--format json')) {
+    if (body.includes('dino ') && !body.includes('--format json')) {
         issues.push({ skill, message: 'Skills that invoke dino commands must recommend --format json.' });
     }
-    if (skill !== 'dino-dinox' && body.includes('--json')) {
+    if (body.includes('--json')) {
         issues.push({ skill, message: 'Skills should not recommend the legacy --json flag.' });
     }
     if (skillDir) {
@@ -256,24 +689,59 @@ export function checkSkillsDirectory(skillsDir) {
         }
     }
     const entries = fs.readdirSync(skillsDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
         .map((entry) => entry.name)
         .sort();
+    const publishedSkills = new Set(entries);
+    const triggerQueryOwners = new Map();
     for (const skill of entries) {
-        const skillFile = path.join(skillsDir, skill, 'SKILL.md');
-        if (!fs.existsSync(skillFile)) {
-            issues.push({ skill, message: 'Missing SKILL.md.' });
-            continue;
+        const skillDir = path.join(skillsDir, skill);
+        if (!fs.existsSync(path.join(skillDir, SKILL_EVALS_RELATIVE_PATH))) {
+            issues.push({ skill, message: `Missing ${SKILL_EVALS_RELATIVE_PATH}; every published skill requires eval coverage.` });
         }
-        const content = fs.readFileSync(skillFile, 'utf8');
-        issues.push(...checkSkillContent(skill, content, path.dirname(skillFile), expectedVersion));
-        const markdownFiles = walkMarkdownFiles(path.dirname(skillFile))
-            .filter((file) => file !== skillFile);
-        for (const markdownFile of markdownFiles) {
-            const relativePath = path.relative(path.dirname(skillFile), markdownFile);
-            const markdownContent = fs.readFileSync(markdownFile, 'utf8');
-            issues.push(...checkMarkdownDocument(skill, markdownContent, relativePath, path.dirname(skillFile)));
+        issues.push(...checkSkillDirectory(skillDir, expectedVersion));
+        for (const expectedSkill of readExpectedSkillsFromEvaluations(skillDir)) {
+            if (!publishedSkills.has(expectedSkill)) {
+                issues.push({
+                    skill,
+                    message: `${SKILL_EVALS_RELATIVE_PATH}: expected skill '${expectedSkill}' is not published in this collection.`,
+                });
+            }
+        }
+        for (const query of readTriggerQueriesFromEvaluations(skillDir)) {
+            const normalizedQuery = normalizeTriggerQuery(query);
+            const existing = triggerQueryOwners.get(normalizedQuery);
+            if (existing) {
+                issues.push({
+                    skill,
+                    message: `${SKILL_EVALS_RELATIVE_PATH}: trigger query '${query}' duplicates ${existing.skill}.`,
+                });
+            }
+            else {
+                triggerQueryOwners.set(normalizedQuery, { skill, query });
+            }
         }
     }
     return issues;
 }
+export function checkSkillDirectory(skillDir, expectedVersion) {
+    const skill = path.basename(path.resolve(skillDir));
+    const skillFile = path.join(skillDir, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) {
+        return [{ skill, message: 'Missing SKILL.md.' }];
+    }
+    const content = fs.readFileSync(skillFile, 'utf8');
+    const issues = checkSkillContent(skill, content, skillDir, expectedVersion);
+    const markdownFiles = walkMarkdownFiles(skillDir).filter((file) => file !== skillFile);
+    for (const markdownFile of markdownFiles) {
+        const relativePath = path.relative(skillDir, markdownFile);
+        const markdownContent = fs.readFileSync(markdownFile, 'utf8');
+        issues.push(...checkMarkdownDocument(skill, markdownContent, relativePath, skillDir));
+    }
+    const openAiAdapterPath = path.join(skillDir, 'agents', 'openai.yaml');
+    if (fs.existsSync(openAiAdapterPath)) {
+        issues.push(...checkOpenAiAdapter(skill, openAiAdapterPath));
+    }
+    issues.push(...checkSkillEvaluations(skill, skillDir));
+    return issues;
+}