happyskills 0.7.3 → 0.9.0

package/src/validation/skill_json_rules.test.js

@@ -0,0 +1,239 @@
+'use strict'
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+const { validate_skill_json } = require('./skill_json_rules')
+
+const make_tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'hs-validate-json-'))
+
+const write_json = (dir, data) => {
+	fs.writeFileSync(path.join(dir, 'skill.json'), JSON.stringify(data, null, '\t'))
+}
+
+let tmp
+beforeEach(() => { tmp = make_tmp() })
+afterEach(() => { fs.rmSync(tmp, { recursive: true, force: true }) })
+
+describe('validate_skill_json — existence', () => {
+	it('errors when skill.json is missing', async () => {
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'exists')
+		assert.strictEqual(check.severity, 'error')
+		assert.strictEqual(data.manifest, null)
+	})
+
+	it('errors for invalid JSON', async () => {
+		fs.writeFileSync(path.join(tmp, 'skill.json'), '{ bad json }')
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'valid_json')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('passes for valid JSON', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		assert.strictEqual(data.results.find(r => r.rule === 'exists').severity, 'pass')
+		assert.strictEqual(data.results.find(r => r.rule === 'valid_json').severity, 'pass')
+	})
+})
+
+describe('validate_skill_json — name', () => {
+	it('errors when name is missing', async () => {
+		write_json(tmp, { version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'name' && r.rule === 'present')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('errors for invalid name format', async () => {
+		write_json(tmp, { name: 'MySkill', version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'name' && r.rule === 'format')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('passes for valid name', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const checks = data.results.filter(r => r.field === 'name')
+		assert.ok(checks.every(r => r.severity === 'pass'))
+	})
+})
+
+describe('validate_skill_json — version', () => {
+	it('errors when version is missing', async () => {
+		write_json(tmp, { name: 'my-skill' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'version' && r.rule === 'present')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('errors for invalid semver', async () => {
+		write_json(tmp, { name: 'my-skill', version: 'abc' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'valid_semver')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('passes for valid semver', async () => {
+		write_json(tmp, { name: 'my-skill', version: '2.1.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'valid_semver')
+		assert.strictEqual(check.severity, 'pass')
+	})
+})
+
+describe('validate_skill_json — description', () => {
+	it('warns when description is missing', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'description' && r.rule === 'recommended_field')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('warns when description exceeds 200 chars', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', description: 'a'.repeat(201) })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'description' && r.rule === 'max_length')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('passes for valid description', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', description: 'A great skill' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'description' && r.rule === 'recommended_field')
+		assert.strictEqual(check.severity, 'pass')
+	})
+})
+
+describe('validate_skill_json — keywords', () => {
+	it('warns when keywords are missing', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'keywords' && r.rule === 'recommended_field')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('warns when no canonical slug is present', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', keywords: ['custom'] })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'canonical_slug')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('passes when a canonical slug is present', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', keywords: ['deployment', 'custom'] })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'canonical_slug')
+		assert.strictEqual(check.severity, 'pass')
+	})
+})
+
+describe('validate_skill_json — dependencies', () => {
+	it('errors when dependencies is an array', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', dependencies: ['acme/deploy'] })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'dependencies' && r.rule === 'type')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('errors when dependency key has no slash', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', dependencies: { 'deploy': '^1.0.0' } })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'key_format')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('errors when dependency value is not a string', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', dependencies: { 'acme/deploy': 123 } })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'value_type')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('passes for valid dependencies', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', dependencies: { 'acme/deploy': '^1.0.0' } })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		assert.ok(!data.results.some(r => r.field === 'dependencies' && r.severity === 'error'))
+	})
+
+	it('skips checks when dependencies is omitted', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0' })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		assert.ok(!data.results.some(r => r.field === 'dependencies'))
+	})
+})
+
+describe('validate_skill_json — systemDependencies', () => {
+	it('errors when systemDependencies is an array', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', systemDependencies: [] })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'systemDependencies' && r.rule === 'type')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('warns when entry is missing required fields', async () => {
+		write_json(tmp, { name: 'my-skill', version: '1.0.0', systemDependencies: { docker: { description: 'Docker' } } })
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'entry_structure')
+		assert.strictEqual(check.severity, 'warning')
+		assert.ok(check.message.includes('check'))
+		assert.ok(check.message.includes('install'))
+	})
+
+	it('warns when install is missing platforms', async () => {
+		write_json(tmp, {
+			name: 'my-skill', version: '1.0.0',
+			systemDependencies: {
+				docker: { description: 'Docker', check: 'docker --version', install: { darwin: 'brew install docker' } }
+			}
+		})
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'platform_coverage')
+		assert.strictEqual(check.severity, 'warning')
+		assert.ok(check.message.includes('linux'))
+		assert.ok(check.message.includes('win32'))
+	})
+
+	it('passes when all platforms are covered', async () => {
+		write_json(tmp, {
+			name: 'my-skill', version: '1.0.0',
+			systemDependencies: {
+				docker: {
+					description: 'Docker', check: 'docker --version',
+					install: { darwin: 'brew install docker', linux: 'apt install docker', win32: 'choco install docker' }
+				}
+			}
+		})
+		const [err, data] = await validate_skill_json(tmp)
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'platform_coverage')
+		assert.strictEqual(check.severity, 'pass')
+	})
+})

package/src/validation/skill_md_rules.js

@@ -0,0 +1,169 @@
+const path = require('path')
+const { error: { catch_errors } } = require('puffy-core')
+const { file_exists, read_file } = require('../utils/fs')
+const { parse_frontmatter } = require('../utils/skill_scanner')
+const { SKILL_MD } = require('../constants')
+
+const FORBIDDEN_CHARS = {
+	';': 'semicolon', ':': 'colon', '#': 'hash', '{': 'left brace', '}': 'right brace',
+	'[': 'left bracket', ']': 'right bracket', "'": 'single quote', '"': 'double quote',
+	'!': 'exclamation', '&': 'ampersand', '*': 'asterisk', '%': 'percent', '|': 'pipe', '>': 'greater-than'
+}
+
+const NAME_PATTERN = /^[a-z][a-z0-9-]*$/
+const PLACEHOLDER_DESC = 'Describe what this skill does and when to invoke it'
+
+const result = (field, rule, severity, message, value) => ({
+	file: SKILL_MD, field, rule, severity, message, ...(value !== undefined ? { value } : {})
+})
+
+const validate_name = (fm, dir_name) => {
+	const results = []
+	const name = fm.name
+
+	if (!name) {
+		results.push(result('name', 'present', 'error', 'Frontmatter must include a "name" field'))
+		return results
+	}
+
+	results.push(result('name', 'present', 'pass', `name: "${name}"`, name))
+
+	if (name.length > 64) {
+		results.push(result('name', 'max_length', 'error', `Name is ${name.length} chars (max 64)`, name))
+	} else {
+		results.push(result('name', 'max_length', 'pass', `name: ${name.length} chars (max 64)`, name))
+	}
+
+	if (!NAME_PATTERN.test(name)) {
+		results.push(result('name', 'format', 'error', 'Name must match /^[a-z][a-z0-9-]*$/', name))
+	} else {
+		results.push(result('name', 'format', 'pass', 'Name format valid', name))
+	}
+
+	if (name.includes('--')) {
+		results.push(result('name', 'no_consecutive_hyphens', 'error', 'Name must not contain consecutive hyphens (--)', name))
+	}
+
+	if (name.startsWith('-') || name.endsWith('-')) {
+		results.push(result('name', 'no_edge_hyphens', 'error', 'Name must not start or end with a hyphen', name))
+	}
+
+	if (dir_name && name !== dir_name) {
+		results.push(result('name', 'matches_directory', 'warning', `Name "${name}" does not match directory "${dir_name}"`, name))
+	} else if (dir_name) {
+		results.push(result('name', 'matches_directory', 'pass', `Name matches directory "${dir_name}"`, name))
+	}
+
+	return results
+}
+
+const validate_description = (fm) => {
+	const results = []
+	const desc = fm.description
+
+	if (!desc) {
+		results.push(result('description', 'present', 'error', 'Frontmatter must include a "description" field'))
+		return results
+	}
+
+	results.push(result('description', 'present', 'pass', `description present (${desc.length} chars)`))
+
+	if (!desc.trim()) {
+		results.push(result('description', 'non_empty', 'error', 'Description must not be empty or whitespace-only', desc))
+		return results
+	}
+
+	if (desc.length > 1024) {
+		results.push(result('description', 'max_length', 'error', `Description is ${desc.length} chars (max 1024)`, desc))
+	} else {
+		results.push(result('description', 'max_length', 'pass', `Description: ${desc.length} chars (max 1024)`))
+	}
+
+	if (desc === PLACEHOLDER_DESC) {
+		results.push(result('description', 'not_placeholder', 'warning', 'Description is the init placeholder — update it before publishing', desc))
+	}
+
+	for (const [char, name] of Object.entries(FORBIDDEN_CHARS)) {
+		if (desc.includes(char)) {
+			results.push(result('description', 'no_forbidden_characters', 'error', `Description contains forbidden character: ${name} (${char})`, desc))
+			return results
+		}
+	}
+
+	results.push(result('description', 'no_forbidden_characters', 'pass', 'No forbidden characters'))
+	return results
+}
+
+const validate_optional_fields = (fm) => {
+	const results = []
+
+	if (fm.compatibility !== undefined) {
+		if (fm.compatibility.length > 500) {
+			results.push(result('compatibility', 'max_length', 'error', `Compatibility is ${fm.compatibility.length} chars (max 500)`, fm.compatibility))
+		} else {
+			results.push(result('compatibility', 'max_length', 'pass', `Compatibility: ${fm.compatibility.length} chars (max 500)`))
+		}
+	}
+
+	const bool_fields = ['disable-model-invocation', 'user-invocable']
+	for (const field of bool_fields) {
+		if (fm[field] !== undefined) {
+			const val = fm[field]
+			if (val !== 'true' && val !== 'false') {
+				results.push(result(field, 'boolean_type', 'warning', `${field} should be true or false, got "${val}"`, val))
+			} else {
+				results.push(result(field, 'boolean_type', 'pass', `${field}: ${val}`))
+			}
+		}
+	}
+
+	if (fm.context !== undefined && fm.context !== 'fork') {
+		results.push(result('context', 'value', 'warning', `context should be "fork", got "${fm.context}"`, fm.context))
+	} else if (fm.context !== undefined) {
+		results.push(result('context', 'value', 'pass', 'context: fork'))
+	}
+
+	if (fm.agent !== undefined && fm.context !== 'fork') {
+		results.push(result('agent', 'requires_context', 'warning', 'agent is set but context is not "fork" — agent skills require context: fork'))
+	}
+
+	return results
+}
+
+const validate_skill_md = (skill_dir, dir_name) => catch_errors('Failed to validate SKILL.md', async () => {
+	const results = []
+	const md_path = path.join(skill_dir, SKILL_MD)
+
+	const [, exists] = await file_exists(md_path)
+	if (!exists) {
+		results.push(result(null, 'exists', 'error', 'SKILL.md not found'))
+		return { results, frontmatter: null, content: null }
+	}
+
+	results.push(result(null, 'exists', 'pass', 'SKILL.md exists'))
+
+	const [, content] = await read_file(md_path)
+	const fm = parse_frontmatter(content)
+
+	if (!fm) {
+		results.push(result(null, 'frontmatter', 'error', 'SKILL.md has no YAML frontmatter (---)'))
+		return { results, frontmatter: null, content }
+	}
+
+	results.push(result(null, 'frontmatter', 'pass', 'Frontmatter present'))
+
+	results.push(...validate_name(fm, dir_name))
+	results.push(...validate_description(fm))
+	results.push(...validate_optional_fields(fm))
+
+	const line_count = content.split('\n').length
+	if (line_count >= 500) {
+		results.push(result(null, 'line_count', 'error', `SKILL.md is ${line_count} lines (max 500)`, String(line_count)))
+	} else {
+		results.push(result(null, 'line_count', 'pass', `File size: ${line_count} lines (max 500)`, String(line_count)))
+	}
+
+	return { results, frontmatter: fm, content }
+})
+
+module.exports = { validate_skill_md }

package/src/validation/skill_md_rules.test.js

@@ -0,0 +1,201 @@
+'use strict'
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+const { validate_skill_md } = require('./skill_md_rules')
+
+const make_tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'hs-validate-md-'))
+
+const write_skill_md = (dir, frontmatter_fields, body = '\nSome content.') => {
+	const lines = Object.entries(frontmatter_fields).map(([k, v]) => `${k}: ${v}`)
+	const content = `---\n${lines.join('\n')}\n---${body}`
+	fs.writeFileSync(path.join(dir, 'SKILL.md'), content)
+}
+
+let tmp
+beforeEach(() => { tmp = make_tmp() })
+afterEach(() => { fs.rmSync(tmp, { recursive: true, force: true }) })
+
+describe('validate_skill_md — existence', () => {
+	it('errors when SKILL.md is missing', async () => {
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const exists_check = data.results.find(r => r.rule === 'exists')
+		assert.strictEqual(exists_check.severity, 'error')
+	})
+
+	it('errors when frontmatter is missing', async () => {
+		fs.writeFileSync(path.join(tmp, 'SKILL.md'), '# No frontmatter\nJust text.')
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const fm_check = data.results.find(r => r.rule === 'frontmatter')
+		assert.strictEqual(fm_check.severity, 'error')
+	})
+
+	it('passes when SKILL.md has valid frontmatter', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		assert.strictEqual(data.results.find(r => r.rule === 'exists').severity, 'pass')
+		assert.strictEqual(data.results.find(r => r.rule === 'frontmatter').severity, 'pass')
+	})
+})
+
+describe('validate_skill_md — name', () => {
+	it('errors when name is missing', async () => {
+		write_skill_md(tmp, { description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const name_check = data.results.find(r => r.field === 'name' && r.rule === 'present')
+		assert.strictEqual(name_check.severity, 'error')
+	})
+
+	it('errors when name exceeds 64 characters', async () => {
+		const long_name = 'a' + '-b'.repeat(33)
+		write_skill_md(tmp, { name: long_name, description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'test')
+		assert.ifError(err)
+		const len_check = data.results.find(r => r.rule === 'max_length')
+		assert.strictEqual(len_check.severity, 'error')
+	})
+
+	it('errors for invalid name format (uppercase)', async () => {
+		write_skill_md(tmp, { name: 'MySkill', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'test')
+		assert.ifError(err)
+		const fmt = data.results.find(r => r.rule === 'format')
+		assert.strictEqual(fmt.severity, 'error')
+	})
+
+	it('errors for consecutive hyphens', async () => {
+		write_skill_md(tmp, { name: 'my--skill', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'test')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'no_consecutive_hyphens')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('errors for trailing hyphen', async () => {
+		write_skill_md(tmp, { name: 'my-skill-', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'test')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'no_edge_hyphens')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('warns when name does not match directory', async () => {
+		write_skill_md(tmp, { name: 'other-name', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'matches_directory')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('passes for a valid name matching directory', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const checks = data.results.filter(r => r.field === 'name')
+		assert.ok(checks.every(r => r.severity === 'pass'))
+	})
+})
+
+describe('validate_skill_md — description', () => {
+	it('errors when description is missing', async () => {
+		write_skill_md(tmp, { name: 'my-skill' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'description' && r.rule === 'present')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('errors when description exceeds 1024 characters', async () => {
+		const long_desc = 'a'.repeat(1025)
+		write_skill_md(tmp, { name: 'my-skill', description: long_desc })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'description' && r.rule === 'max_length')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('warns for placeholder description', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Describe what this skill does and when to invoke it' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'not_placeholder')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('errors for forbidden characters in description', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Deploy apps; supports ECS' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'no_forbidden_characters')
+		assert.strictEqual(check.severity, 'error')
+		assert.ok(check.message.includes('semicolon'))
+	})
+
+	it('passes for valid description', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Deploy apps to AWS using ECS' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'no_forbidden_characters')
+		assert.strictEqual(check.severity, 'pass')
+	})
+})
+
+describe('validate_skill_md — optional fields', () => {
+	it('errors when compatibility exceeds 500 chars', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things', compatibility: 'x'.repeat(501) })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'compatibility')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('warns for non-boolean disable-model-invocation', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things', 'disable-model-invocation': 'yes' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'disable-model-invocation')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('warns when context is not fork', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things', context: 'other' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'context')
+		assert.strictEqual(check.severity, 'warning')
+	})
+
+	it('warns when agent is set without context fork', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things', agent: 'my-agent' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.field === 'agent')
+		assert.strictEqual(check.severity, 'warning')
+	})
+})
+
+describe('validate_skill_md — line count', () => {
+	it('errors when file exceeds 500 lines', async () => {
+		const lines = '---\nname: my-skill\ndescription: Does things\n---\n' + 'line\n'.repeat(500)
+		fs.writeFileSync(path.join(tmp, 'SKILL.md'), lines)
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'line_count')
+		assert.strictEqual(check.severity, 'error')
+	})
+
+	it('passes when file is under 500 lines', async () => {
+		write_skill_md(tmp, { name: 'my-skill', description: 'Does things' })
+		const [err, data] = await validate_skill_md(tmp, 'my-skill')
+		assert.ifError(err)
+		const check = data.results.find(r => r.rule === 'line_count')
+		assert.strictEqual(check.severity, 'pass')
+	})
+})