@skill-graph/cli 0.5.6

package/scripts/__tests__/test-marketplace-export.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * Regression tests for marketplace export generation and gates.
+ *
+ * These tests require the canonical skills library (a sibling repo at
+ * ../skills/skills or configured via .skill-graph/config.json). In CI
+ * environments where only the skill-graph tooling repo is checked out,
+ * the tests skip gracefully rather than failing.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { workspaceRoot, loadWorkspaceConfig, resolveSkillRoots } = require('../lib/roots');
+const {
+  EXPORT_DESCRIPTION_OVERRIDES,
+  MARKETPLACE_DESCRIPTION_LIMIT,
+  SKILL_GRAPH_PROTOCOL,
+  buildMarketplaceSkillText,
+  collectCanonicalSkills,
+  exportDescriptionForSkill,
+  rewriteLocalMarkdownLinksToCanonicalRepo,
+  scanPrivacyText,
+} = require('../export-marketplace-skills');
+const { parseFrontmatter } = require('../lib/parse-frontmatter');
+const { validateExportedFrontmatter } = require('../verify-skill-md-export');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+function fail(msg) {
+  process.stderr.write(`FAIL test-marketplace-export: ${msg}\n`);
+  process.exit(1);
+}
+
+function assert(condition, msg) {
+  if (!condition) fail(msg);
+}
+
+// Skip gracefully when the canonical skills library is not present (e.g. CI
+// environments that only check out the skill-graph tooling repo).
+const _root = workspaceRoot();
+const _skillRoots = resolveSkillRoots(_root, loadWorkspaceConfig(_root));
+const _sourceDir = _skillRoots[0] && _skillRoots[0].absPath;
+if (!_sourceDir || !fs.existsSync(_sourceDir)) {
+  process.stdout.write(
+    `SKIP test-marketplace-export: canonical skills library not found at ${_sourceDir || '(no path resolved)'} — skipping\n`
+  );
+  process.exit(0);
+}
+
+const skills = collectCanonicalSkills();
+assert(skills.length > 0, 'canonical skills should be discovered');
+
+const longDescriptions = [];
+for (const skill of skills) {
+  const sourceLength = String(skill.fm.description || '').length;
+  const exportDescription = exportDescriptionForSkill(skill);
+  assert(
+    exportDescription.description.length <= MARKETPLACE_DESCRIPTION_LIMIT,
+    `${skill.fm.name} export description exceeds marketplace limit`
+  );
+  if (sourceLength > MARKETPLACE_DESCRIPTION_LIMIT) {
+    longDescriptions.push(skill.fm.name);
+    assert(
+      EXPORT_DESCRIPTION_OVERRIDES[skill.fm.name],
+      `${skill.fm.name} needs an explicit export description override`
+    );
+  }
+}
+
+const overrideNames = Object.keys(EXPORT_DESCRIPTION_OVERRIDES).sort();
+assert(
+  JSON.stringify(overrideNames) === JSON.stringify(longDescriptions.sort()),
+  'description overrides should exist only for over-limit canonical descriptions'
+);
+
+const a11y = skills.find(skill => skill.fm.name === 'a11y');
+assert(a11y, 'a11y fixture skill should exist');
+const exportedA11y = buildMarketplaceSkillText(a11y);
+const exportedA11yFm = parseFrontmatter(exportedA11y);
+assert(exportedA11yFm, 'marketplace export should have frontmatter');
+const shape = validateExportedFrontmatter(exportedA11yFm);
+assert(shape.errors.length === 0, `marketplace export should be plain SKILL.md shape: ${shape.errors.join('; ')}`);
+assert(
+  exportedA11yFm.metadata.skill_graph_canonical_skill === 'skills/a11y/SKILL.md',
+  'marketplace export should preserve canonical source path'
+);
+assert(
+  exportedA11yFm.metadata.skill_graph_protocol === SKILL_GRAPH_PROTOCOL &&
+    SKILL_GRAPH_PROTOCOL === 'Skill Metadata Protocol v4',
+  'marketplace export should preserve current Skill Metadata Protocol provenance'
+);
+assert(
+  exportedA11y.includes('https://github.com/jacob-balslev/skill-graph/blob/main/examples/evals/a11y.json'),
+  'marketplace export should rewrite repo-local links to canonical GitHub URLs'
+);
+
+const rewritten = rewriteLocalMarkdownLinksToCanonicalRepo(
+  'See [eval](../../examples/evals/a11y.json) and [external](https://example.com).',
+  'skills/a11y/SKILL.md'
+);
+assert(
+  rewritten.includes('https://github.com/jacob-balslev/skill-graph/blob/main/examples/evals/a11y.json'),
+  'relative links should be rewritten to canonical GitHub URLs'
+);
+assert(rewritten.includes('[external](https://example.com)'), 'external links should be preserved');
+
+const fakeSecret = 'sk-' + 'A'.repeat(24);
+const fakeLeak = `C:\\Users\\Example\\secret.txt\nperson@example.com\n${fakeSecret}`;
+const findings = scanPrivacyText(fakeLeak, path.join(REPO_ROOT, 'marketplace', 'skills', 'fake', 'SKILL.md'));
+assert(findings.length >= 3, 'privacy scan should detect paths, email addresses, and token-like values');
+
+process.stdout.write('PASS test-marketplace-export: marketplace export gates covered\n');

package/scripts/__tests__/test-router-paths.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * Test: activation.paths include/exclude semantics.
+ *
+ * Guards the reference router against treating `!pattern` negations as positive
+ * path matches. Negations only subtract from earlier positive includes.
+ */
+
+'use strict';
+
+const { routeSkills, matchesGlob, matchPathList } = require('../skill-graph-route');
+
+function fail(msg) {
+  process.stderr.write(`FAIL test-router-paths: ${msg}\n`);
+  process.exit(1);
+}
+
+function pass(msg) {
+  process.stdout.write(`PASS test-router-paths: ${msg}\n`);
+}
+
+function assert(condition, msg) {
+  if (!condition) fail(msg);
+}
+
+const a11ySkill = {
+  id: 'a11y',
+  name: 'a11y',
+  path: 'skills/a11y/SKILL.md',
+  type: 'capability',
+  scope: 'portable',
+  health: { eval_state: 'passing' },
+  activation: {
+    keywords: [],
+    triggers: [],
+    paths: [
+      '**/*.{html,tsx,jsx,vue,svelte}',
+      '**/*.css',
+      '!**/*.test.{ts,tsx,js,jsx}',
+      '!**/dist/**',
+      '!**/node_modules/**',
+    ],
+  },
+};
+
+function route(pathArg) {
+  return routeSkills({
+    skills: [a11ySkill],
+  }, {
+    query: 'unrelated prompt',
+    project: null,
+    maxResults: 5,
+    minEvalState: 'unverified',
+    pathArg,
+    todayISO: '2026-05-13',
+  });
+}
+
+assert(matchesGlob('src/components/Button.tsx', '**/*.{html,tsx,jsx,vue,svelte}'), 'brace glob should match .tsx paths');
+assert(matchesGlob('src/components/Button.test.tsx', '!**/*.test.{ts,tsx,js,jsx}'), 'matchesGlob should test the underlying negated glob');
+
+const included = matchPathList('src/components/Button.tsx', a11ySkill.activation.paths);
+assert(included.matched, 'positive .tsx path should match');
+assert(included.pattern === '**/*.{html,tsx,jsx,vue,svelte}', 'path reason should be the positive include pattern');
+
+const excluded = matchPathList('src/components/Button.test.tsx', a11ySkill.activation.paths);
+assert(!excluded.matched, 'test path should be excluded by negation');
+assert(excluded.excludedBy === '!**/*.test.{ts,tsx,js,jsx}', 'excludedBy should identify the subtractive pattern');
+
+const negationOnly = matchPathList('src/components/Button.tsx', ['!**/*.test.{ts,tsx,js,jsx}']);
+assert(!negationOnly.matched, 'a negation-only list must not create a positive match');
+
+const includedRoute = route('src/components/Button.tsx');
+assert(includedRoute.selected.length === 1, 'router should select a11y for included .tsx path');
+assert(includedRoute.selected[0].reasons.includes('path:**/*.{html,tsx,jsx,vue,svelte}'), 'router should cite the positive path include');
+assert(!includedRoute.selected[0].reasons.some(r => r.startsWith('path:!')), 'router must not cite negation as a positive path reason');
+
+const excludedRoute = route('src/components/Button.test.tsx');
+assert(excludedRoute.selected.length === 0, 'router should not select a11y for excluded test path');
+
+pass('activation.paths negations subtract only from prior positive includes');
+process.exit(0);

package/scripts/__tests__/test-stability-promotion.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Test: stability promotion lint gate (check 14).
+ *
+ * Six test cases:
+ *   1. All-pass: stability=stable + all 5 criteria met  → 0 warnings
+ *   2. Criterion 1 fail: eval_state=unverified           → exactly 1 warning
+ *   3. Criterion 2 fail: eval_score below threshold      → exactly 1 warning
+ *   4. Criterion 3 fail: routing_eval absent             → exactly 1 warning
+ *   5. Criterion 4 fail: drift_check.last_verified stale → exactly 1 warning
+ *   6. Criterion 5 fail: no grounding.truth_sources      → exactly 1 warning
+ *
+ * All failures must be WARN level (errors array must remain empty).
+ * Experimental / absent stability must produce 0 warnings (not gated).
+ *
+ * Exit 0 on all pass, 1 on first failure.
+ */
+
+'use strict';
+
+const {
+  checkStabilityPromotion,
+  STABLE_EVAL_SCORE_THRESHOLD,
+  STABLE_DRIFT_MAX_DAYS,
+} = require('../lint/check-stability-promotion');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function fail(msg) {
+  process.stderr.write(`FAIL test-stability-promotion: ${msg}\n`);
+  process.exit(1);
+}
+
+function pass(msg) {
+  process.stdout.write(`PASS test-stability-promotion: ${msg}\n`);
+}
+
+function assert(condition, msg) {
+  if (!condition) fail(msg);
+}
+
+/**
+ * Build a minimal SKILL.md source text containing a `stability:` key in the
+ * frontmatter block. Used to give the locateKey helper something to parse.
+ */
+function buildSourceText(overrides = {}) {
+  const fm = Object.assign(
+    {
+      stability: 'stable',
+      eval_state: 'passing',
+      eval_score: STABLE_EVAL_SCORE_THRESHOLD,
+      routing_eval: 'present',
+      scope: 'codebase',
+    },
+    overrides
+  );
+
+  // Minimal YAML frontmatter (values are not full-YAML-parsed here; only the
+  // key locator is exercised by the test, not real parse-frontmatter).
+  const lines = ['---'];
+  for (const [k, v] of Object.entries(fm)) {
+    if (v !== undefined && v !== null) {
+      lines.push(`${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`);
+    }
+  }
+  lines.push('---', '# Test skill body');
+  return lines.join('\n');
+}
+
+/**
+ * Run checkStabilityPromotion with a pre-built frontmatter object.
+ * Uses a fixed reference date so drift tests are deterministic.
+ */
+function run(fm, today) {
+  const sourceText = buildSourceText({ stability: fm.stability || 'stable' });
+  return checkStabilityPromotion({ filePath: 'test/SKILL.md', sourceText, fm, today });
+}
+
+// Fixed reference date for deterministic drift tests.
+const TODAY = new Date('2026-05-18T00:00:00Z');
+
+// ISO date that is within the allowed window (45 days ago from TODAY).
+const RECENT_DATE = '2026-04-03';
+// ISO date that is outside the allowed window (100 days ago from TODAY).
+const STALE_DATE = '2026-01-28';
+
+// ── Shared base frontmatter (all criteria satisfied) ─────────────────────────
+
+const BASE_FM = {
+  stability: 'stable',
+  eval_state: 'passing',
+  eval_score: STABLE_EVAL_SCORE_THRESHOLD,
+  routing_eval: 'present',
+  drift_check: { last_verified: RECENT_DATE },
+  scope: 'codebase',
+  grounding: {
+    domain_object: 'test',
+    truth_sources: ['schemas/skill.schema.json'],
+  },
+};
+
+// ── Test 1: All criteria met — 0 warnings ────────────────────────────────────
+
+(function testAllPass() {
+  const result = run(BASE_FM, TODAY);
+  assert(result.errors.length === 0, 'test1: must have no errors');
+  assert(result.warnings.length === 0, `test1: all-pass should emit 0 warnings, got ${result.warnings.length}: ${result.warnings.map(w => w.message).join('; ')}`);
+  pass('test1 (all criteria met) → 0 warnings');
+})();
+
+// ── Test 2: Criterion 1 fail — eval_state=unverified ─────────────────────────
+
+(function testCriterion1Fail() {
+  const fm = Object.assign({}, BASE_FM, { eval_state: 'unverified' });
+  const result = run(fm, TODAY);
+  assert(result.errors.length === 0, 'test2: must have no errors (WARN only)');
+  assert(
+    result.warnings.length === 1,
+    `test2: criterion-1 fail should emit exactly 1 warning, got ${result.warnings.length}: ${result.warnings.map(w => w.message).join('; ')}`
+  );
+  assert(
+    result.warnings[0].message.includes('criterion 1'),
+    `test2: warning must reference criterion 1, got: ${result.warnings[0].message}`
+  );
+  assert(
+    result.warnings[0].message.includes('unverified'),
+    `test2: warning must mention "unverified", got: ${result.warnings[0].message}`
+  );
+  pass('test2 (eval_state=unverified) → 1 warning on criterion 1');
+})();
+
+// ── Test 3: Criterion 2 fail — eval_score below threshold ────────────────────
+
+(function testCriterion2Fail() {
+  const fm = Object.assign({}, BASE_FM, { eval_score: 3.5 });
+  const result = run(fm, TODAY);
+  assert(result.errors.length === 0, 'test3: must have no errors (WARN only)');
+  assert(
+    result.warnings.length === 1,
+    `test3: criterion-2 fail should emit exactly 1 warning, got ${result.warnings.length}: ${result.warnings.map(w => w.message).join('; ')}`
+  );
+  assert(
+    result.warnings[0].message.includes('criterion 2'),
+    `test3: warning must reference criterion 2, got: ${result.warnings[0].message}`
+  );
+  assert(
+    result.warnings[0].message.includes('3.5'),
+    `test3: warning must mention the failing score, got: ${result.warnings[0].message}`
+  );
+  pass('test3 (eval_score=3.5 < 4.0) → 1 warning on criterion 2');
+})();
+
+// ── Test 4: Criterion 3 fail — routing_eval absent ───────────────────────────
+
+(function testCriterion3Fail() {
+  const fm = Object.assign({}, BASE_FM, { routing_eval: 'absent' });
+  const result = run(fm, TODAY);
+  assert(result.errors.length === 0, 'test4: must have no errors (WARN only)');
+  assert(
+    result.warnings.length === 1,
+    `test4: criterion-3 fail should emit exactly 1 warning, got ${result.warnings.length}: ${result.warnings.map(w => w.message).join('; ')}`
+  );
+  assert(
+    result.warnings[0].message.includes('criterion 3'),
+    `test4: warning must reference criterion 3, got: ${result.warnings[0].message}`
+  );
+  assert(
+    result.warnings[0].message.includes('routing_eval'),
+    `test4: warning must mention routing_eval, got: ${result.warnings[0].message}`
+  );
+  pass('test4 (routing_eval=absent) → 1 warning on criterion 3');
+})();
+
+// ── Test 5: Criterion 4 fail — drift_check.last_verified stale ───────────────
+
+(function testCriterion4Fail() {
+  const fm = Object.assign({}, BASE_FM, { drift_check: { last_verified: STALE_DATE } });
+  const result = run(fm, TODAY);
+  assert(result.errors.length === 0, 'test5: must have no errors (WARN only)');
+  assert(
+    result.warnings.length === 1,
+    `test5: criterion-4 fail should emit exactly 1 warning, got ${result.warnings.length}: ${result.warnings.map(w => w.message).join('; ')}`
+  );
+  assert(
+    result.warnings[0].message.includes('criterion 4'),
+    `test5: warning must reference criterion 4, got: ${result.warnings[0].message}`
+  );
+  assert(
+    result.warnings[0].message.includes('days ago'),
+    `test5: warning must mention days-ago age, got: ${result.warnings[0].message}`
+  );
+  pass('test5 (drift_check.last_verified=stale) → 1 warning on criterion 4');
+})();
+
+// ── Test 6: Criterion 5 fail — no grounding.truth_sources (codebase scope) ───
+
+(function testCriterion5Fail() {
+  const fm = Object.assign({}, BASE_FM, {
+    scope: 'codebase',
+    grounding: { domain_object: 'test', truth_sources: [] },
+  });
+  const result = run(fm, TODAY);
+  assert(result.errors.length === 0, 'test6: must have no errors (WARN only)');
+  assert(
+    result.warnings.length === 1,
+    `test6: criterion-5 fail should emit exactly 1 warning, got ${result.warnings.length}: ${result.warnings.map(w => w.message).join('; ')}`
+  );
+  assert(
+    result.warnings[0].message.includes('criterion 5'),
+    `test6: warning must reference criterion 5, got: ${result.warnings[0].message}`
+  );
+  assert(
+    result.warnings[0].message.includes('truth_sources'),
+    `test6: warning must mention truth_sources, got: ${result.warnings[0].message}`
+  );
+  pass('test6 (grounding.truth_sources empty, scope=codebase) → 1 warning on criterion 5');
+})();
+
+// ── Bonus: experimental stability must produce 0 warnings ─────────────────────
+
+(function testExperimentalSkipped() {
+  const fm = Object.assign({}, BASE_FM, { stability: 'experimental' });
+  const result = run(fm, TODAY);
+  assert(result.errors.length === 0, 'bonus: must have no errors');
+  assert(result.warnings.length === 0, `bonus: experimental stability must not trigger the gate, got ${result.warnings.length} warnings`);
+  pass('bonus (stability=experimental) → gate skipped, 0 warnings');
+})();
+
+// ── Bonus: portable scope is exempt from criterion 5 ─────────────────────────
+
+(function testPortableScopeExempt() {
+  const fm = Object.assign({}, BASE_FM, {
+    scope: 'portable',
+    grounding: undefined, // no grounding at all — still exempt
+  });
+  const result = run(fm, TODAY);
+  // Portable has no grounding required, so criterion 5 should NOT fire.
+  // Other criteria still apply; count only criterion-5 warnings.
+  const criterion5Warnings = result.warnings.filter(w => w.message.includes('criterion 5'));
+  assert(criterion5Warnings.length === 0, `bonus portable: portable scope must be exempt from criterion 5, got: ${criterion5Warnings.map(w => w.message).join('; ')}`);
+  pass('bonus (scope=portable) → criterion 5 skipped');
+})();
+
+process.stdout.write('All stability-promotion tests passed.\n');

package/scripts/__tests__/test-v3-1-alias-contract.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Test: v3.1 preferred field aliases round-trip and mismatch gates.
+ */
+
+'use strict';
+
+const path = require('path');
+const { buildSkillEntry } = require('../generate-manifest');
+const { checkAliasParity } = require('../lib/alias-contract');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const FIXTURE_PATH = path.join(REPO_ROOT, 'examples', 'tests', 'v3-1-alias-fixture.md');
+
+function fail(msg) {
+  process.stderr.write(`FAIL test-v3-1-alias-contract: ${msg}\n`);
+  process.exit(1);
+}
+
+function pass(msg) {
+  process.stdout.write(`PASS test-v3-1-alias-contract: ${msg}\n`);
+}
+
+function assert(condition, msg) {
+  if (!condition) fail(msg);
+}
+
+const fm = {
+  schema_version: 4,
+  name: 'alias-fixture',
+  urn: 'urn:skill:skill-graph:alias-fixture',
+  description: 'Fixture skill used to verify v3.1 alias pass-through and parity checks.',
+  version: '1.0.0',
+  type: 'capability',
+  archetype: 'capability',
+  category: 'testing',
+  domain: 'skill-system/testing',
+  scope: 'portable',
+  owner: 'skill-graph-maintainer',
+  freshness: '2026-05-13',
+  reviewed_at: '2026-05-13',
+  drift_check: {
+    last_verified: '2026-05-13',
+    verified_at: '2026-05-13',
+  },
+  eval_artifacts: 'none',
+  eval_state: 'unverified',
+  routing_eval: 'absent',
+  comprehension_state: 'absent',
+  eval: {
+    artifacts: 'none',
+    content_state: 'unverified',
+    routing_coverage: 'absent',
+    comprehension_state: 'absent',
+  },
+  'allowed-tools': 'Read Grep',
+  allowed_tools: 'Read Grep',
+  compatibility: {
+    runtimes: ['claude-code>=2.0'],
+    agent_runtimes: ['claude-code>=2.0'],
+    node: '>=20',
+    node_version: '>=20',
+  },
+  grounding: {
+    domain_object: 'Alias contract',
+    subject: 'Alias contract',
+    grounding_mode: 'repo_specific',
+    claim_scope: 'repo_specific',
+    truth_sources: ['schemas/skill.schema.json'],
+    failure_modes: ['silent_alias_drop'],
+    evidence_priority: 'repo_code_first',
+  },
+  portability: {
+    readiness: 'scripted',
+    targets: ['skill-md'],
+    export_targets: ['skill-md'],
+  },
+};
+
+const parityErrors = checkAliasParity(fm);
+assert(parityErrors.length === 0, `fixture should satisfy alias parity, got: ${parityErrors.join('; ')}`);
+
+const entry = buildSkillEntry(fm, FIXTURE_PATH, 'alias-fixture', null);
+assert(entry.urn === fm.urn, 'urn should pass through');
+assert(entry.archetype === fm.archetype, 'archetype alias should pass through');
+assert(entry.domain === fm.domain, 'domain should pass through');
+assert(entry.allowed_tools === fm.allowed_tools, 'allowed_tools alias should pass through');
+assert(entry.health.reviewed_at === fm.reviewed_at, 'reviewed_at alias should project to health.reviewed_at');
+assert(entry.health.eval && entry.health.eval.content_state === 'unverified', 'nested eval alias should project to health.eval');
+assert(entry.compatibility.agent_runtimes[0] === 'claude-code>=2.0', 'compatibility.agent_runtimes should pass through');
+assert(entry.compatibility.node_version === '>=20', 'compatibility.node_version should pass through');
+assert(entry.grounding.subject === 'Alias contract', 'grounding.subject should pass through');
+assert(entry.grounding.claim_scope === 'repo_specific', 'grounding.claim_scope should pass through');
+assert(entry.portability.export_targets[0] === 'skill-md', 'portability.export_targets should pass through');
+
+const mismatch = { ...fm, archetype: 'workflow' };
+const mismatchErrors = checkAliasParity(mismatch);
+assert(mismatchErrors.some(e => e.includes('archetype')), 'alias mismatch should be reported by lint helper');
+
+let threw = false;
+try {
+  buildSkillEntry(mismatch, FIXTURE_PATH, 'alias-fixture', null);
+} catch (e) {
+  threw = /alias contract violation/.test(e.message);
+}
+assert(threw, 'manifest generator should refuse mismatched aliases');
+
+pass('v3.1 aliases pass through and mismatches fail');
+process.exit(0);

package/scripts/__tests__/test-v3-1-skos-runtime.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * Test: v3.1 SKOS predicate runtime migration (R1)
+ *
+ * Verifies that the manifest generator iterates the complete v3.1 predicate set
+ * (related, broader, narrower, boundary, disjoint_with, verify_with, depends_on,
+ * adjacent) and emits all declared relations into the manifest entry.
+ *
+ * Before R1, the iteration list in `generate-manifest.js` was hardcoded to
+ * ['adjacent', 'boundary', 'verify_with', 'depends_on'] and silently dropped
+ * `related`, `broader`, `narrower`, `disjoint_with`. Authors who followed
+ * ADR 0001 v3.1 SKOS naming would see lint warnings nudging them to the new
+ * names but their relations would never reach the manifest.
+ *
+ * This test asserts the regression is closed: build a manifest entry from the
+ * fixture, confirm every declared predicate survives the round-trip.
+ *
+ * Exit 0 on pass, 1 on failure.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseFrontmatter } = require('../lib/parse-frontmatter');
+const { buildSkillEntry } = require('../generate-manifest');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const FIXTURE_PATH = path.join(REPO_ROOT, 'examples', 'tests', 'v3-1-skos-fixture', 'SKILL.md');
+
+const EXPECTED_PREDICATES = [
+  // v3.1 SKOS additions
+  'related',
+  'broader',
+  'narrower',
+  // v3.0 stable + canonical (per ADR 0006)
+  'boundary',
+  'verify_with',
+  'depends_on',
+  // v3.1 separate orthogonal relation per ADR 0006 Option B
+  'disjoint_with',
+];
+
+function fail(msg) {
+  process.stderr.write(`FAIL test-v3-1-skos-runtime: ${msg}\n`);
+  process.exit(1);
+}
+
+function pass(msg) {
+  process.stdout.write(`PASS test-v3-1-skos-runtime: ${msg}\n`);
+}
+
+function main() {
+  if (!fs.existsSync(FIXTURE_PATH)) {
+    fail(`fixture missing at ${path.relative(REPO_ROOT, FIXTURE_PATH)}`);
+  }
+
+  const text = fs.readFileSync(FIXTURE_PATH, 'utf8');
+  const fm = parseFrontmatter(text);
+  if (!fm) fail('fixture has no parseable frontmatter');
+
+  // Guard: every expected predicate is declared in the fixture frontmatter.
+  for (const kind of EXPECTED_PREDICATES) {
+    const arr = fm.relations && fm.relations[kind];
+    if (!Array.isArray(arr) || arr.length === 0) {
+      fail(`fixture frontmatter missing relations.${kind} — fixture is the test substrate, must declare every predicate under test`);
+    }
+  }
+
+  const entry = buildSkillEntry(fm, FIXTURE_PATH, 'v3-1-skos-fixture', null);
+
+  if (!entry || typeof entry !== 'object') fail('buildSkillEntry returned non-object');
+  if (!entry.relations || typeof entry.relations !== 'object') {
+    fail('manifest entry has no `relations` block — generator dropped all relations');
+  }
+
+  // Round-trip assertion: every predicate declared in the fixture must appear
+  // in the manifest entry's relations block with the same target list shape.
+  const missing = [];
+  const sizeMismatch = [];
+  for (const kind of EXPECTED_PREDICATES) {
+    if (!Array.isArray(entry.relations[kind])) {
+      missing.push(kind);
+      continue;
+    }
+    if (entry.relations[kind].length !== fm.relations[kind].length) {
+      sizeMismatch.push(`${kind}: fixture has ${fm.relations[kind].length}, manifest has ${entry.relations[kind].length}`);
+    }
+  }
+
+  if (missing.length > 0) {
+    fail(`predicates dropped from manifest entry: ${missing.join(', ')}. Generator iteration list does not include these keys.`);
+  }
+  if (sizeMismatch.length > 0) {
+    fail(`predicate target counts differ between fixture and manifest:\n  - ${sizeMismatch.join('\n  - ')}`);
+  }
+
+  // Sanity: the back-compat alias `adjacent` continues to flow through if declared.
+  // Fixture omits `adjacent` deliberately (it would draw a deprecation warning),
+  // so this test only confirms the iteration list KNOWS about adjacent. We
+  // synthesise a parallel fixture in-memory to verify.
+  const adjacentFm = {
+    ...fm,
+    relations: { adjacent: ['documentation'] },
+  };
+  const adjacentEntry = buildSkillEntry(adjacentFm, FIXTURE_PATH, 'v3-1-skos-fixture-adjacent', null);
+  if (!adjacentEntry.relations || !Array.isArray(adjacentEntry.relations.adjacent) || adjacentEntry.relations.adjacent.length !== 1) {
+    fail('back-compat regression: relations.adjacent is dropped by generator (should still flow through as an alias for related per ADR 0001)');
+  }
+
+  pass(`all ${EXPECTED_PREDICATES.length} v3.1 predicates round-trip cleanly + adjacent back-compat preserved`);
+  pass('R1 closed: ADR 0001 SKOS additions and ADR 0006 boundary/disjoint_with split are implemented in scripts/generate-manifest.js');
+  process.exit(0);
+}
+
+main();