ma-agents 3.6.2 → 3.8.0

package/test/skill-mandatory.test.js

@@ -1,235 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for set-mandatory command and list --mandatory filter
- * Story 3.3: Mandatory Skill Designation Tooling
- *
- * Task 5.1: set-mandatory enables always_load
- * Task 5.2: set-mandatory --off disables always_load
- * Task 5.3: list --mandatory filters correctly
- * Task 5.4: MANIFEST.yaml reflects changes
- */
-'use strict';
-
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-const CLI_PATH = path.join(__dirname, '..', 'bin', 'cli.js');
-const PROJECT_ROOT = path.join(__dirname, '..');
-
-let passed = 0;
-let failed = 0;
-const errors = [];
-
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ✓ ${name}`);
-    passed++;
-  } catch (err) {
-    console.error(`  ✗ ${name}: ${err.message}`);
-    failed++;
-    errors.push({ name, error: err.message });
-  }
-}
-
-// ─── Module imports ────────────────────────────────────────────────────────────
-let setMandatory;
-try {
-  ({ setMandatory } = require('../lib/skill-authoring'));
-} catch (e) {
-  console.error('\n  FATAL: Cannot load skill-authoring module');
-  console.error(' ', e.message);
-  process.exit(1);
-}
-
-// ─── Helper: build a temporary skill with a real skill.json ──────────────────
-function makeTmpSkill(alwaysLoad = false, extraFields = {}) {
-  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-mandatory-test-'));
-  const skillName = 'test-mandatory-skill';
-  const skillDir = path.join(tmpBase, skillName);
-  fs.mkdirSync(skillDir, { recursive: true });
-
-  const json = Object.assign({
-    name: 'Test Mandatory Skill',
-    description: 'Test skill',
-    version: '1.0.0',
-    category: 'workflow',
-    author: 'ma-agents',
-    tags: ['test'],
-    always_load: alwaysLoad
-  }, extraFields);
-
-  fs.writeFileSync(path.join(skillDir, 'skill.json'), JSON.stringify(json, null, 2) + '\n', 'utf8');
-  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Test Mandatory Skill\n', 'utf8');
-
-  return { tmpBase, skillDir, skillName };
-}
-
-// ─── Unit tests: setMandatory() ───────────────────────────────────────────────
-console.log('\n setMandatory unit tests\n');
-
-// AC #1: Enable
-test('setMandatory: sets always_load=true in skill.json', () => {
-  const { tmpBase, skillName } = makeTmpSkill(false);
-  try {
-    const result = setMandatory(skillName, true, tmpBase);
-    assert.strictEqual(result.success, true, `Expected success, got: ${JSON.stringify(result)}`);
-
-    const updated = JSON.parse(fs.readFileSync(path.join(tmpBase, skillName, 'skill.json'), 'utf8'));
-    assert.strictEqual(updated.always_load, true, 'Expected always_load=true');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// AC #2: Disable
-test('setMandatory: sets always_load=false with enable=false', () => {
-  const { tmpBase, skillName } = makeTmpSkill(true);
-  try {
-    const result = setMandatory(skillName, false, tmpBase);
-    assert.strictEqual(result.success, true);
-
-    const updated = JSON.parse(fs.readFileSync(path.join(tmpBase, skillName, 'skill.json'), 'utf8'));
-    assert.strictEqual(updated.always_load, false, 'Expected always_load=false');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('setMandatory: preserves all other fields in skill.json', () => {
-  const { tmpBase, skillName } = makeTmpSkill(false, { custom_field: 'preserved' });
-  try {
-    setMandatory(skillName, true, tmpBase);
-    const updated = JSON.parse(fs.readFileSync(path.join(tmpBase, skillName, 'skill.json'), 'utf8'));
-    assert.strictEqual(updated.name, 'Test Mandatory Skill', 'Expected name preserved');
-    assert.strictEqual(updated.version, '1.0.0', 'Expected version preserved');
-    assert.deepStrictEqual(updated.tags, ['test'], 'Expected tags preserved');
-    assert.strictEqual(updated.custom_field, 'preserved', 'Expected custom_field preserved');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('setMandatory: returns error for non-existent skill', () => {
-  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-mandatory-empty-'));
-  try {
-    const result = setMandatory('no-such-skill', true, tmpBase);
-    assert.strictEqual(result.success, false);
-    assert.ok(result.error.includes('not found') || result.error.includes('no-such-skill'),
-      `Expected not-found error, got: ${result.error}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('setMandatory: error and hint are label-free data', () => {
-  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-mandatory-empty2-'));
-  try {
-    const result = setMandatory('no-such-skill', true, tmpBase);
-    assert.ok(!result.error.startsWith('Error:'), 'error field should not start with "Error:"');
-    assert.ok(!result.hint.startsWith('Hint:'), 'hint field should not start with "Hint:"');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// ─── CLI integration tests: set-mandatory ────────────────────────────────────
-console.log('\n set-mandatory CLI integration tests\n');
-
-// Use a real skill in the project's skills/ dir for CLI tests
-const TEST_SKILL = 'git-workflow-skill';
-const SKILL_JSON_PATH = path.join(PROJECT_ROOT, 'skills', TEST_SKILL, 'skill.json');
-
-// Save and restore original always_load value
-let originalAlwaysLoad;
-try {
-  const original = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
-  originalAlwaysLoad = original.always_load;
-} catch (_) {
-  originalAlwaysLoad = true;
-}
-
-// AC #1: Enable
-test('set-mandatory: sets always_load=true with exit 0', () => {
-  const result = spawnSync('node', [CLI_PATH, 'set-mandatory', TEST_SKILL], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
-  assert.ok(result.stdout.includes('mandatory') || result.stdout.includes('always_load'),
-    `Expected confirmation in output: ${result.stdout}`);
-
-  const updated = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
-  assert.strictEqual(updated.always_load, true, 'Expected always_load=true in skill.json');
-});
-
-// AC #2: Disable
-test('set-mandatory --off: sets always_load=false with exit 0', () => {
-  const result = spawnSync('node', [CLI_PATH, 'set-mandatory', TEST_SKILL, '--off'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
-
-  const updated = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
-  assert.strictEqual(updated.always_load, false, 'Expected always_load=false in skill.json');
-});
-
-// Restore original value
-try {
-  const current = JSON.parse(fs.readFileSync(SKILL_JSON_PATH, 'utf8'));
-  current.always_load = originalAlwaysLoad;
-  fs.writeFileSync(SKILL_JSON_PATH, JSON.stringify(current, null, 2) + '\n', 'utf8');
-} catch (_) {}
-
-// Missing skill name
-test('set-mandatory: no skill name exits 1', () => {
-  const result = spawnSync('node', [CLI_PATH, 'set-mandatory'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 1, 'Expected exit 1');
-});
-
-// Unknown skill
-test('set-mandatory: unknown skill exits 1 with error', () => {
-  const result = spawnSync('node', [CLI_PATH, 'set-mandatory', 'no-such-skill'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 1, 'Expected exit 1 for missing skill');
-  const output = result.stdout + result.stderr;
-  assert.ok(output.includes('Error') || output.includes('not found'), 'Expected error message');
-});
-
-// ─── CLI integration tests: list --mandatory ──────────────────────────────────
-console.log('\n list --mandatory CLI integration tests\n');
-
-// AC #3: Filter mandatory skills
-test('list --mandatory: exits 0', () => {
-  const result = spawnSync('node', [CLI_PATH, 'list', '--mandatory'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
-});
-
-test('list --mandatory: only shows skills with always_load=true', () => {
-  const result = spawnSync('node', [CLI_PATH, 'list', '--mandatory'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  // git-workflow-skill has always_load: true — should appear
-  assert.ok(result.stdout.includes('git-workflow-skill'), 'Expected git-workflow-skill in mandatory list');
-});
-
-test('list --mandatory: output differs from full list', () => {
-  const full = spawnSync('node', [CLI_PATH, 'list'], { encoding: 'utf8', cwd: PROJECT_ROOT });
-  const filtered = spawnSync('node', [CLI_PATH, 'list', '--mandatory'], { encoding: 'utf8', cwd: PROJECT_ROOT });
-  // Mandatory list should be shorter or equal (never longer)
-  assert.ok(filtered.stdout.length <= full.stdout.length, 'Mandatory list should not be longer than full list');
-});
-
-// ─── Results ──────────────────────────────────────────────────────────────────
-console.log(`\n  ${passed} passed, ${failed} failed\n`);
-if (failed > 0) {
-  errors.forEach(e => console.error(`  ✗ ${e.name}: ${e.error}`));
-  process.exit(1);
-}

package/test/skill-validation.test.js

@@ -1,378 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for validate-skill command implementation
- * Story 3.2: Skill Validation Command
- *
- * Task 6.1: Valid skill reports VALID
- * Task 6.2: Broken skill reports all errors
- * Task 6.3: Unknown agent template triggers warning
- */
-'use strict';
-
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-const CLI_PATH = path.join(__dirname, '..', 'bin', 'cli.js');
-const PROJECT_ROOT = path.join(__dirname, '..');
-
-let passed = 0;
-let failed = 0;
-const errors = [];
-
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ✓ ${name}`);
-    passed++;
-  } catch (err) {
-    console.error(`  ✗ ${name}: ${err.message}`);
-    failed++;
-    errors.push({ name, error: err.message });
-  }
-}
-
-// ─── Module imports ────────────────────────────────────────────────────────────
-let validateSkill;
-try {
-  ({ validateSkill } = require('../lib/skill-authoring'));
-} catch (e) {
-  console.error('\n  FATAL: Cannot load skill-authoring module');
-  console.error(' ', e.message);
-  process.exit(1);
-}
-
-// ─── Helper: build a temporary skill dir ─────────────────────────────────────
-function makeTmpSkill(fields = {}) {
-  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-validate-test-'));
-  const skillName = fields.skillName || 'test-skill';
-  const skillDir = path.join(tmpBase, skillName);
-  fs.mkdirSync(skillDir, { recursive: true });
-
-  if (fields.skillJson !== undefined) {
-    fs.writeFileSync(path.join(skillDir, 'skill.json'), fields.skillJson, 'utf8');
-  } else if (fields.skillJson !== null) {
-    // Default valid skill.json
-    const json = Object.assign({
-      name: 'Test Skill',
-      description: 'A test skill',
-      version: '1.0.0',
-      category: 'workflow',
-      author: 'ma-agents',
-      tags: ['test'],
-      always_load: false
-    }, fields.skillJsonOverride || {});
-    fs.writeFileSync(path.join(skillDir, 'skill.json'), JSON.stringify(json, null, 2), 'utf8');
-  }
-
-  if (fields.skillMd !== false) {
-    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# Test Skill\n', 'utf8');
-  }
-
-  if (fields.templates) {
-    const templatesDir = path.join(skillDir, 'templates');
-    fs.mkdirSync(templatesDir, { recursive: true });
-    for (const [filename, content] of Object.entries(fields.templates)) {
-      fs.writeFileSync(path.join(templatesDir, filename), content, 'utf8');
-    }
-  }
-
-  return { tmpBase, skillDir, skillName };
-}
-
-// ─── Unit tests: validateSkill() ─────────────────────────────────────────────
-console.log('\n validateSkill unit tests\n');
-
-// AC #1: Valid skill
-test('valid skill returns valid=true with metadata', () => {
-  const { tmpBase, skillName } = makeTmpSkill({});
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, true, `Expected valid=true, got: ${JSON.stringify(result)}`);
-    assert.ok(Array.isArray(result.errors), 'Expected errors array');
-    assert.strictEqual(result.errors.length, 0, `Expected no errors, got: ${JSON.stringify(result.errors)}`);
-    assert.ok(result.metadata, 'Expected metadata object');
-    assert.strictEqual(result.metadata.name, 'Test Skill');
-    assert.strictEqual(result.metadata.version, '1.0.0');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// AC #2: Missing skill.json
-test('missing skill.json produces error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJson: undefined });
-  // Remove the default skill.json by passing null-ish — need to NOT write it
-  fs.rmSync(path.join(tmpBase, skillName, 'skill.json'), { force: true });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('skill.json')), `Expected skill.json error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// AC #3: Missing SKILL.md
-test('missing SKILL.md produces error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillMd: false });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('SKILL.md')), `Expected SKILL.md error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// Skill not found
-test('non-existent skill returns error (not found)', () => {
-  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-validate-empty-'));
-  try {
-    const result = validateSkill('no-such-skill', tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.notFound, 'Expected notFound flag');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// AC #4: Invalid JSON
-test('corrupt skill.json produces error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJson: 'not valid json {{{' });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.toLowerCase().includes('json')), `Expected JSON error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// AC #4: Missing required fields
-test('missing name field produces field error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJsonOverride: { name: '' } });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('name')), `Expected name error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('missing version field produces field error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJsonOverride: { version: undefined } });
-  // Remove version from written JSON
-  const skillDir = path.join(tmpBase, skillName);
-  const json = JSON.parse(fs.readFileSync(path.join(skillDir, 'skill.json'), 'utf8'));
-  delete json.version;
-  fs.writeFileSync(path.join(skillDir, 'skill.json'), JSON.stringify(json), 'utf8');
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('version')), `Expected version error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('invalid version format produces field error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJsonOverride: { version: 'v1.0' } });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('version')), `Expected version error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('invalid category produces field error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJsonOverride: { category: 'invalid-cat' } });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('category')), `Expected category error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('non-boolean always_load produces field error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJsonOverride: { always_load: 'yes' } });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('always_load')), `Expected always_load error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('non-array tags produces field error', () => {
-  const { tmpBase, skillName } = makeTmpSkill({ skillJsonOverride: { tags: 'not-an-array' } });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('tags')), `Expected tags error, got: ${JSON.stringify(result.errors)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// AC #5: Template validation
-test('valid agent template produces no warning', () => {
-  const { tmpBase, skillName } = makeTmpSkill({
-    templates: { 'claude-code.md': '# Template' }
-  });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, true, `Expected valid, got errors: ${JSON.stringify(result.errors)}`);
-    assert.ok(!result.warnings.some(w => w.includes('claude-code')), 'Expected no warning for known agent');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('unknown agent template produces warning', () => {
-  const { tmpBase, skillName } = makeTmpSkill({
-    templates: { 'unknown-agent.md': '# Template' }
-  });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.ok(Array.isArray(result.warnings), 'Expected warnings array');
-    assert.ok(result.warnings.some(w => w.includes('unknown-agent')), `Expected unknown-agent warning, got: ${JSON.stringify(result.warnings)}`);
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-test('unknown agent template does not make skill invalid', () => {
-  const { tmpBase, skillName } = makeTmpSkill({
-    templates: { 'unknown-agent.md': '# Template' }
-  });
-  try {
-    const result = validateSkill(skillName, tmpBase);
-    assert.strictEqual(result.valid, true, 'Warnings should not make skill invalid');
-  } finally {
-    fs.rmSync(tmpBase, { recursive: true, force: true });
-  }
-});
-
-// ─── CLI integration tests ─────────────────────────────────────────────────────
-console.log('\n validate-skill CLI integration tests\n');
-
-// Task 6.1: Valid skill
-test('validate-skill: git-workflow-skill reports VALID with exit 0', () => {
-  const result = spawnSync('node', [CLI_PATH, 'validate-skill', 'git-workflow-skill'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 0, `Expected exit 0. stderr: ${result.stderr}`);
-  assert.ok(result.stdout.includes('VALID'), `Expected VALID in output: ${result.stdout}`);
-});
-
-test('validate-skill: valid skill prints metadata summary', () => {
-  const result = spawnSync('node', [CLI_PATH, 'validate-skill', 'git-workflow-skill'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.ok(result.stdout.includes('Version'), 'Expected Version in output');
-  assert.ok(result.stdout.includes('Category') || result.stdout.includes('Name'), 'Expected metadata fields');
-});
-
-// Non-existent skill
-test('validate-skill: unknown skill exits 1 with error', () => {
-  const result = spawnSync('node', [CLI_PATH, 'validate-skill', 'no-such-skill'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 1, 'Expected exit 1 for missing skill');
-  const output = result.stdout + result.stderr;
-  assert.ok(output.includes('not found') || output.includes('Error'), 'Expected not-found error');
-});
-
-// Task 6.2: Broken skill — create deliberately invalid skill, validate, cleanup
-test('validate-skill: INVALID skill exits 1', () => {
-  const brokenSkill = 'broken-test-skill';
-  const brokenDir = path.join(PROJECT_ROOT, 'skills', brokenSkill);
-  try {
-    fs.mkdirSync(brokenDir, { recursive: true });
-    // Deliberately invalid: missing SKILL.md, bad skill.json
-    fs.writeFileSync(path.join(brokenDir, 'skill.json'), JSON.stringify({
-      name: '',
-      version: 'bad-version',
-      category: 'invalid-cat'
-    }), 'utf8');
-
-    const result = spawnSync('node', [CLI_PATH, 'validate-skill', brokenSkill], {
-      encoding: 'utf8', cwd: PROJECT_ROOT
-    });
-    assert.strictEqual(result.status, 1, `Expected exit 1. stdout: ${result.stdout}`);
-    assert.ok(result.stdout.includes('INVALID'), `Expected INVALID in output: ${result.stdout}`);
-  } finally {
-    fs.rmSync(brokenDir, { recursive: true, force: true });
-  }
-});
-
-test('validate-skill: INVALID output lists individual field errors', () => {
-  const brokenSkill = 'broken-test-skill2';
-  const brokenDir = path.join(PROJECT_ROOT, 'skills', brokenSkill);
-  try {
-    fs.mkdirSync(brokenDir, { recursive: true });
-    fs.writeFileSync(path.join(brokenDir, 'skill.json'), JSON.stringify({
-      name: '',
-      version: 'bad',
-      category: 'invalid-cat'
-    }), 'utf8');
-
-    const result = spawnSync('node', [CLI_PATH, 'validate-skill', brokenSkill], {
-      encoding: 'utf8', cwd: PROJECT_ROOT
-    });
-    assert.ok(result.stdout.includes('name'), `Expected name error in output: ${result.stdout}`);
-    assert.ok(result.stdout.includes('version'), `Expected version error in output: ${result.stdout}`);
-    assert.ok(result.stdout.includes('category'), `Expected category error in output: ${result.stdout}`);
-  } finally {
-    fs.rmSync(brokenDir, { recursive: true, force: true });
-  }
-});
-
-// Task 6.3: Unknown agent template warning
-test('validate-skill: warns about unknown agent template', () => {
-  const warnSkill = 'warn-template-skill';
-  const warnDir = path.join(PROJECT_ROOT, 'skills', warnSkill);
-  try {
-    fs.mkdirSync(path.join(warnDir, 'templates'), { recursive: true });
-    fs.writeFileSync(path.join(warnDir, 'skill.json'), JSON.stringify({
-      name: 'Warn Skill', description: 'test', version: '1.0.0'
-    }), 'utf8');
-    fs.writeFileSync(path.join(warnDir, 'SKILL.md'), '# Warn Skill\n', 'utf8');
-    fs.writeFileSync(path.join(warnDir, 'templates', 'unknown-agent.md'), '# Template\n', 'utf8');
-
-    const result = spawnSync('node', [CLI_PATH, 'validate-skill', warnSkill], {
-      encoding: 'utf8', cwd: PROJECT_ROOT
-    });
-    assert.strictEqual(result.status, 0, `Expected exit 0 (warnings don't fail). stderr: ${result.stderr}`);
-    assert.ok(
-      result.stdout.includes('unknown-agent') || result.stdout.includes('Warning'),
-      `Expected warning about unknown-agent: ${result.stdout}`
-    );
-  } finally {
-    fs.rmSync(warnDir, { recursive: true, force: true });
-  }
-});
-
-// No skill name provided
-test('validate-skill: no skill name exits 1 with usage hint', () => {
-  const result = spawnSync('node', [CLI_PATH, 'validate-skill'], {
-    encoding: 'utf8', cwd: PROJECT_ROOT
-  });
-  assert.strictEqual(result.status, 1, 'Expected exit 1 for missing skill name');
-});
-
-// ─── Results ──────────────────────────────────────────────────────────────────
-console.log(`\n  ${passed} passed, ${failed} failed\n`);
-if (failed > 0) {
-  errors.forEach(e => console.error(`  ✗ ${e.name}: ${e.error}`));
-  process.exit(1);
-}