@lifeaitools/rdc-skills 0.24.26 → 0.24.28

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.24.26",
+  "version": "0.24.28",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/README.md

@@ -149,6 +149,16 @@ curl -s -X POST https://rdc-skills.regendevcorp.com/mcp \
   -d '{"jsonrpc":"2.0","id":5,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli"}}}'
 ```
 
+For direct API/curl clients that want metadata and rendered body in one parsed
+payload, add `format:"json"`:
+
+```bash
+curl -s -X POST https://rdc-skills.regendevcorp.com/mcp \
+  -H 'Content-Type: application/json' \
+  -H 'Accept: application/json, text/event-stream' \
+  -d '{"jsonrpc":"2.0","id":6,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli","format":"json"}}}'
+```
+
 Use `variant:"cli"` for Claude Code/Codex/local terminal instructions. Use
 `variant:"cloud"` for claude.ai web sessions where local daemon, shell, or
 filesystem steps need cloud-safe wording.

package/bin/rdc-skills-mcp.mjs

@@ -189,25 +189,48 @@ function buildMcpServer() {
     'rdc_skill_get',
     {
       description:
-        "Get a skill's SKILL.md body rendered for the caller. variant 'cli' returns the body unchanged; 'cloud' rewrites local-shell/clauth-daemon steps for the claude.ai web client. Omit variant to use auto-detection (defaults to cloud).",
+        "Get a skill's SKILL.md body rendered for the caller. variant 'cli' returns the body unchanged; 'cloud' rewrites local-shell/clauth-daemon steps for the claude.ai web client. Omit variant to use auto-detection (defaults to cloud). format 'json' returns metadata plus rendered body for direct API/curl callers.",
       inputSchema: {
         name: z.string().describe('Skill name or slash form (e.g. "deploy", "rdc:build", "rdc:brochurify", "lifeai-brochure-author"). See rdc_skill_list.'),
         variant: z.enum(['cli', 'cloud']).optional().describe('Force the rendered variant; overrides caller detection.'),
+        format: z.enum(['text', 'json']).optional().describe("Return 'text' (default) for agent-readable SKILL.md, or 'json' for metadata plus rendered body."),
       },
     },
-    async ({ name, variant }) => {
+    async ({ name, variant, format }) => {
       const resolvedName = resolveSkillName(name);
       if (!resolvedName) {
-        const valid = listSkills().map((s) => `${s.name} (${s.slash})`);
-        return textResult(
-          `Unknown skill '${name}'. Valid skills (${valid.length}): ${valid.join(', ')}`,
-        );
+        const valid = listSkills().map((s) => ({
+          name: s.name,
+          slash: s.slash,
+          aliases: s.aliases,
+          usage: s.usage,
+        }));
+        if (format === 'json') {
+          return textResult(JSON.stringify({
+            error: 'unknown_skill',
+            requested: name,
+            message: `Unknown skill '${name}'.`,
+            valid_count: valid.length,
+            valid,
+          }, null, 2));
+        }
+        return textResult(`Unknown skill '${name}'. Valid skills (${valid.length}): ${valid.map((s) => `${s.name} (${s.slash})`).join(', ')}`);
       }
       const resolved = variant || lastDetectedVariant || 'cloud';
       const rendered = renderSkill(resolvedName, resolved);
       if (!rendered) {
         return textResult(`Skill '${resolvedName}' exists in the catalog but has no SKILL.md body on disk.`);
       }
+      if (format === 'json') {
+        return textResult(JSON.stringify({
+          skill: getSkill(resolvedName),
+          requested: name,
+          resolved_name: resolvedName,
+          variant: resolved,
+          header: rendered.header,
+          body: rendered.body,
+        }, null, 2));
+      }
       return textResult(`${rendered.header}\n\n${rendered.body}`);
     },
   );

package/commands/help.md

@@ -73,6 +73,11 @@ curl -s -X POST https://rdc-skills.regendevcorp.com/mcp \
   -H 'Content-Type: application/json' \
   -H 'Accept: application/json, text/event-stream' \
   -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli"}}}'
+
+curl -s -X POST https://rdc-skills.regendevcorp.com/mcp \
+  -H 'Content-Type: application/json' \
+  -H 'Accept: application/json, text/event-stream' \
+  -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli","format":"json"}}}'
 ```
 
 ## Hard Rules

package/git-sha.json

@@ -1,3 +1,3 @@
 {
-  "sha": "5884908869da0ae91e3c004d9af344da71ae0079"
+  "sha": "5e9edbe4cc32b027c05dda21e0a9e2f07bba8e59"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.24.26",
+  "version": "0.24.28",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -35,7 +35,7 @@
     "rdc-design": "node scripts/rdc-design-cli.mjs",
     "test:hooks": "node scripts/test-rdc-hooks.mjs",
     "test:truth-gate": "node tests/run-evidence-gate.test.mjs && node tests/work-item-exit-gate-l2.test.mjs && node tests/work-item-exit-gate-l3.test.mjs && node tests/require-work-item-on-commit.test.mjs && node tests/harness-gates.test.mjs",
-    "test:acceptance": "node tests/acceptance.test.mjs && node tests/install-rdc-skills.test.mjs && node tests/help-surface.test.mjs && node tests/manifest-contract-fields.test.mjs && node tests/curl-surface.test.mjs",
+    "test:acceptance": "node tests/acceptance.test.mjs && node tests/install-rdc-skills.test.mjs && node tests/help-surface.test.mjs && node tests/manifest-contract-fields.test.mjs && node tests/skill-test-matrix.test.mjs && node tests/curl-surface.test.mjs",
     "acceptance": "node scripts/acceptance.mjs --changed",
     "test:mcp": "node tests/mcp.test.mjs",
     "test:mcp:remote": "node tests/mcp.test.mjs --remote",

package/scripts/lib/manifest-schema.mjs

@@ -2,7 +2,7 @@
 //
 // Source of truth: .rdc/plans/skill-self-test-tier-2.md decision D3.
 //
-// A manifest describes one behavioral test for an rdc:* skill. The Tier 2
+// A manifest describes one behavioral test for an installed skill. The Tier 2
 // runner loads a manifest, validates it here, then uses it to drive a headless
 // Claude invocation inside a sandbox and assert on real artifacts.
 //
@@ -55,8 +55,16 @@ const ASSERTION_FIELDS = new Set([
 const WIC_FIELDS = new Set(["min", "max", "status", "labels_include"]);
 const COMMITS_FIELDS = new Set(["min", "message_matches"]);
 const TEARDOWN_FIELDS = new Set(["reset_branch"]);
+const ACCEPTANCE_FIELDS = new Set([
+  "output_contains",
+  "output_not_contains",
+  "tool_calls_include_any",
+  "tool_calls_include_all",
+  "tool_calls_argument_matches",
+]);
+const TOOL_CALL_MATCHER_FIELDS = new Set(["tools", "pattern"]);
 
-const SKILL_RE = /^rdc:[a-z][a-z0-9-]*$/;
+const SKILL_RE = /^(rdc:)?[a-z][a-z0-9-]*$/;
 
 function isPlainObject(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
@@ -92,12 +100,12 @@ function validateFixture(fx, errors, warnings) {
   // prompt
   if (typeof fx.prompt !== "string" || fx.prompt.trim().length === 0) {
     err(errors, "fixture.prompt", "missing", "fixture.prompt must be a non-empty string");
-  } else if (!fx.prompt.startsWith("rdc:")) {
+  } else if (!SKILL_RE.test(fx.prompt.split(/\s+/, 1)[0] || "")) {
     err(
       errors,
       "fixture.prompt",
-      "prompt-not-rdc",
-      `fixture.prompt must start with "rdc:" (got "${fx.prompt.slice(0, 20)}...")`,
+      "prompt-not-skill",
+      `fixture.prompt must start with a valid skill name (got "${fx.prompt.slice(0, 20)}...")`,
     );
   }
 
@@ -372,6 +380,78 @@ function validateTeardown(t, errors, warnings) {
   }
 }
 
+function validateStringArray(value, path, errors) {
+  if (!Array.isArray(value)) {
+    err(errors, path, "type", `${path} must be an array`);
+    return;
+  }
+  value.forEach((s, i) => {
+    if (typeof s !== "string" || s.length === 0) {
+      err(errors, `${path}[${i}]`, "type", "entry must be a non-empty string");
+    }
+  });
+}
+
+function validateAcceptance(a, errors, warnings) {
+  if (!isPlainObject(a)) {
+    err(errors, "acceptance", "type", "acceptance must be an object");
+    return;
+  }
+
+  if (a.output_contains !== undefined) {
+    validateStringArray(a.output_contains, "acceptance.output_contains", errors);
+  }
+  if (a.output_not_contains !== undefined) {
+    validateStringArray(a.output_not_contains, "acceptance.output_not_contains", errors);
+  }
+  if (a.tool_calls_include_any !== undefined) {
+    validateStringArray(a.tool_calls_include_any, "acceptance.tool_calls_include_any", errors);
+  }
+  if (a.tool_calls_include_all !== undefined) {
+    validateStringArray(a.tool_calls_include_all, "acceptance.tool_calls_include_all", errors);
+  }
+
+  if (a.tool_calls_argument_matches !== undefined) {
+    if (!Array.isArray(a.tool_calls_argument_matches)) {
+      err(
+        errors,
+        "acceptance.tool_calls_argument_matches",
+        "type",
+        "tool_calls_argument_matches must be an array",
+      );
+    } else {
+      a.tool_calls_argument_matches.forEach((matcher, i) => {
+        const p = `acceptance.tool_calls_argument_matches[${i}]`;
+        if (!isPlainObject(matcher)) {
+          err(errors, p, "type", "matcher must be an object");
+          return;
+        }
+        validateStringArray(matcher.tools, `${p}.tools`, errors);
+        if (typeof matcher.pattern !== "string" || matcher.pattern.length === 0) {
+          err(errors, `${p}.pattern`, "type", "pattern must be a non-empty regex string");
+        } else {
+          try {
+            new RegExp(matcher.pattern);
+          } catch (e) {
+            err(errors, `${p}.pattern`, "invalid-regex", `invalid regex: ${e.message}`);
+          }
+        }
+        for (const k of Object.keys(matcher)) {
+          if (!TOOL_CALL_MATCHER_FIELDS.has(k)) {
+            warn(warnings, `${p}.${k}`, "unknown-field", `unknown matcher field "${k}"`);
+          }
+        }
+      });
+    }
+  }
+
+  for (const k of Object.keys(a)) {
+    if (!ACCEPTANCE_FIELDS.has(k)) {
+      warn(warnings, `acceptance.${k}`, "unknown-field", `unknown acceptance field "${k}"`);
+    }
+  }
+}
+
 export function validateManifest(raw) {
   const errors = [];
   const warnings = [];
@@ -405,7 +485,7 @@ export function validateManifest(raw) {
       errors,
       "skill",
       "skill-invalid",
-      `skill must match /^rdc:[a-z][a-z0-9-]*$/ (got ${JSON.stringify(raw.skill)})`,
+      `skill must be a slash skill like "rdc:build" or bare skill like "lifeai-brochure-author" (got ${JSON.stringify(raw.skill)})`,
     );
   }
 
@@ -430,6 +510,10 @@ export function validateManifest(raw) {
     validateAssertions(raw.assertions, errors, warnings);
   }
 
+  if (raw.acceptance !== undefined) {
+    validateAcceptance(raw.acceptance, errors, warnings);
+  }
+
   // teardown (optional)
   if (raw.teardown !== undefined) {
     validateTeardown(raw.teardown, errors, warnings);
@@ -544,6 +628,17 @@ if (__isMain) {
       expect: (r) => !r.ok && r.errors.some((e) => e.code === "rdc-test-not-set"),
       expectStr: "error code=rdc-test-not-set",
     },
+    {
+      n: 4.5,
+      desc: "valid bare installed skill",
+      input: {
+        ...validMinimal,
+        skill: "lifeai-brochure-author",
+        fixture: { ...validMinimal.fixture, prompt: "lifeai-brochure-author review fixture" },
+      },
+      expect: (r) => r.ok && r.errors.length === 0,
+      expectStr: "ok=true, 0 errors",
+    },
     {
       n: 5,
       desc: "invalid regex in commits_made.message_matches",
@@ -591,6 +686,45 @@ if (__isMain) {
       expect: (r) => !r.ok && r.errors.some((e) => e.code === "path-not-relative"),
       expectStr: "error code=path-not-relative",
     },
+    {
+      n: 9,
+      desc: "valid acceptance tool matcher",
+      input: {
+        ...validMinimal,
+        acceptance: {
+          output_contains: ["PASS"],
+          output_not_contains: ["fabricated"],
+          tool_calls_include_any: ["Grep", "Glob"],
+          tool_calls_argument_matches: [{ tools: ["Grep"], pattern: "global-corpus|web-search" }],
+        },
+      },
+      expect: (r) => r.ok && r.errors.length === 0,
+      expectStr: "ok=true, 0 errors",
+    },
+    {
+      n: 10,
+      desc: "invalid acceptance matcher regex",
+      input: {
+        ...validMinimal,
+        acceptance: {
+          tool_calls_argument_matches: [{ tools: ["Grep"], pattern: "[unclosed" }],
+        },
+      },
+      expect: (r) => !r.ok && r.errors.some((e) => e.path.endsWith(".pattern") && e.code === "invalid-regex"),
+      expectStr: "error code=invalid-regex",
+    },
+    {
+      n: 11,
+      desc: "unknown acceptance field",
+      input: {
+        ...validMinimal,
+        acceptance: { made_up: true },
+      },
+      expect: (r) =>
+        r.ok &&
+        r.warnings.some((w) => w.path === "acceptance.made_up" && w.code === "unknown-field"),
+      expectStr: "ok=true, warning code=unknown-field",
+    },
   ];
 
   const pad = (s, n) => String(s) + " ".repeat(Math.max(0, n - String(s).length));

package/skills/help/SKILL.md

@@ -122,6 +122,12 @@ RDC SKILLS — manifest: .claude-plugin/plugin.json @ v{version}
     -H 'Accept: application/json, text/event-stream' \
     -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli"}}}'
 
+  Fetch a structured skill payload:
+  curl -s -X POST https://rdc-skills.regendevcorp.com/mcp \
+    -H 'Content-Type: application/json' \
+    -H 'Accept: application/json, text/event-stream' \
+    -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli","format":"json"}}}'
+
 ## Hard rules
 
 - `cf: yes` skills MUST consult CodeFlow before acting. Hooks fail-closed on unreachable CodeFlow for these.

package/skills/tests/MATRIX.md

@@ -4,7 +4,7 @@ Current coverage: 29 manifests for 29 skill directories.
 
 The manifest layer verifies each skill can be started from a realistic caller prompt in an isolated `RDC_TEST=1` sandbox. The acceptance harness records the engine stream, extracted tool calls, stdout/stderr artifacts, rendered assistant output, failures, lessons learned, and next build optimizations under `.rdc/reports/`.
 
-`rdc:channel-formatter` currently has the strongest content acceptance fixture: it asserts source-grounded social-pack output, forbidden-claim absence, and observable corpus or web-search tool routing. `rdc:watch` adds a focus-safety negative check. The remaining manifests are basic behavioral smoke tests and should gain deeper acceptance assertions as each skill is touched.
+`rdc:channel-formatter` currently has the strongest content acceptance fixture: it asserts source-grounded social-pack output, forbidden-claim absence, and observable corpus or web-search tool routing. `rdc:help` asserts the public MCP/curl caller surface and structured `format:"json"` discovery path. `rdc:watch` adds a focus-safety negative check. The remaining manifests are basic behavioral smoke tests and should gain deeper acceptance assertions as each skill is touched.
 
 | Skill | Manifest | Fixture prompt class | Assertions | Acceptance depth |
 |---|---|---|---|---|
@@ -19,7 +19,7 @@ The manifest layer verifies each skill can be started from a realistic caller pr
 | `rdc:fixit` | `rdc-fixit.test.json` | Tiny sandbox typo fix | `commits_made`, `exit_code`, `stdout_contains` | Basic manifest |
 | `rdc:fs-mcp` | `rdc-fs-mcp.test.json` | File-system bridge read fixture | `commits_made`, `exit_code`, `stdout_contains` | Basic manifest |
 | `rdc:handoff` | `rdc-handoff.test.json` | Stub work handoff | `exit_code`, `stdout_contains` | Basic manifest |
-| `rdc:help` | `rdc-help.test.json` | Help menu rendering | `commits_made`, `exit_code`, `stdout_contains` | Basic manifest |
+| `rdc:help` | `rdc-help.test.json` | Help menu rendering | `commits_made`, `exit_code`, `stdout_contains` | MCP/curl output, structured JSON fetch, dev-endpoint negative checks |
 | `rdc:housekeeping` | `rdc-housekeeping.test.json` | Read-only housekeeping audit | `commits_made`, `exit_code`, `stdout_contains` | Basic manifest |
 | `lifeai-brochure-author` | `rdc-lifeai-brochure-author.test.json` | JSX compliance review fixture | `exit_code`, `stdout_contains` | Basic manifest |
 | `rdc:overnight` | `rdc-overnight.test.json` | Label-based overnight queue drain | `exit_code`, `stdout_contains` | Basic manifest |

package/skills/tests/rdc-help.test.json

@@ -11,5 +11,19 @@
     "commits_made": { "min": 0 },
     "stdout_contains": ["rdc:help", "Decision tree"]
   },
+  "acceptance": {
+    "output_contains": [
+      "Direct MCP / curl Access",
+      "https://rdc-skills.regendevcorp.com/mcp",
+      "rdc_skill_list",
+      "rdc_skill_search",
+      "rdc_skill_get",
+      "\"format\":\"json\""
+    ],
+    "output_not_contains": [
+      "https://rdc-skills.dev.regendevcorp.com/mcp",
+      "All user-invocable skills become available as slash commands"
+    ]
+  },
   "teardown": { "reset_branch": true }
 }

package/tests/curl-surface.test.mjs

@@ -211,6 +211,21 @@ async function main() {
     check('rdc_skill_get returns tool text path', getText.length > 500, `length ${getText.length}`);
     check('rdc_skill_get accepts visible rdc:build alias', /rdc:build/i.test(getText));
 
+    const getJson = postMcp({
+      jsonrpc: '2.0',
+      id: 5,
+      method: 'tools/call',
+      params: {
+        name: 'rdc_skill_get',
+        arguments: { name: 'rdc:build', variant: 'cli', format: 'json' },
+      },
+    }, 'rdc_skill_get_json');
+    check('rdc_skill_get format=json curl exits 0', getJson.status === 0, getJson.stderr);
+    const getJsonBody = JSON.parse(resultText(latestEnvelope(getJson.stdout)));
+    check('rdc_skill_get format=json returns resolved name', getJsonBody.resolved_name === 'build');
+    check('rdc_skill_get format=json returns skill metadata', getJsonBody.skill?.slash === 'rdc:build' && getJsonBody.skill?.codeflow_required === true);
+    check('rdc_skill_get format=json returns rendered body', /rdc:build/i.test(getJsonBody.body || ''));
+
     const getMcp = curlWithStatus([
       '-s',
       `${TARGET}/mcp`,

package/tests/help-surface.test.mjs

@@ -29,6 +29,7 @@ for (const [name, text] of Object.entries(docs)) {
   assert.match(text, /output_contract/, `${name} must describe rdc_skill_list metadata fields`);
   assert.match(text, /codeflow_required/, `${name} must describe CodeFlow metadata`);
   assert.match(text, /variants/, `${name} must describe supported skill variants`);
+  assert.match(text, /"format":"json"/, `${name} must show structured rdc_skill_get format=json`);
   assert.match(text, /turn this article into social posts/, `${name} must include a natural-language search example`);
   assert.match(text, /"name":"rdc:build"/, `${name} must show rdc_skill_get accepts visible slash names`);
   assert.doesNotMatch(text, /https:\/\/rdc-skills\.dev\.regendevcorp\.com\/mcp/, `${name} must not point callers at dev MCP`);

package/tests/mcp.test.mjs

@@ -201,6 +201,12 @@ async function sweep(url, label, { compareSource }) {
   const aliasBody = strip(callText(aliasGet.json));
   check(`${label}: rdc_skill_get accepts slash aliases`, /rdc:brochurify Orchestrator/.test(aliasBody));
 
+  const jsonGet = await mcp(url, { jsonrpc: '2.0', id: 23, method: 'tools/call', params: { name: 'rdc_skill_get', arguments: { name: 'rdc:build', variant: 'cli', format: 'json' } } });
+  let jsonBody; try { jsonBody = JSON.parse(callText(jsonGet.json)); } catch { jsonBody = {}; }
+  check(`${label}: rdc_skill_get format=json returns resolved name`, jsonBody.resolved_name === 'build');
+  check(`${label}: rdc_skill_get format=json returns metadata`, jsonBody.skill?.slash === 'rdc:build' && jsonBody.skill?.codeflow_required === true);
+  check(`${label}: rdc_skill_get format=json returns rendered body`, typeof jsonBody.body === 'string' && jsonBody.body.includes('rdc:build'));
+
   // search
   const se = await mcp(url, { jsonrpc: '2.0', id: 21, method: 'tools/call', params: { name: 'rdc_skill_search', arguments: { query: 'deploy' } } });
   let sr; try { sr = JSON.parse(callText(se.json)); } catch { sr = { results: [] }; }

package/tests/skill-test-matrix.test.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+import { loadAllManifests } from '../scripts/lib/manifest-schema.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, '..');
+const testsDir = join(root, 'skills', 'tests');
+const matrixPath = join(testsDir, 'MATRIX.md');
+const readmePath = join(testsDir, 'README.md');
+
+const manifestFiles = readdirSync(testsDir).filter((name) => name.endsWith('.test.json')).sort();
+const manifests = loadAllManifests(testsDir);
+const valid = manifests.filter((entry) => entry.ok && entry.manifest);
+const matrix = readFileSync(matrixPath, 'utf8');
+const readme = readFileSync(readmePath, 'utf8');
+
+assert.equal(valid.length, manifestFiles.length, 'all manifest files must validate');
+assert.match(matrix, new RegExp(`Current coverage: ${manifestFiles.length} manifests for ${manifestFiles.length} skill directories`));
+assert.match(readme, new RegExp(`There are currently ${manifestFiles.length} manifests for ${manifestFiles.length} skill directories`));
+
+const rows = new Map();
+for (const line of matrix.split(/\r?\n/)) {
+  const m = line.match(/^\| `([^`]+)` \| `([^`]+)` \| ([^|]+) \| ([^|]+) \| ([^|]+) \|$/);
+  if (!m) continue;
+  rows.set(m[1], {
+    manifest: m[2],
+    promptClass: m[3].trim(),
+    assertions: m[4].replace(/`/g, '').trim(),
+    acceptanceDepth: m[5].trim(),
+  });
+}
+
+assert.equal(rows.size, manifestFiles.length, 'MATRIX.md must list every manifest exactly once');
+
+for (const entry of valid) {
+  const manifest = entry.manifest;
+  const filename = entry.file.replace(/^skills\/tests\//, '');
+  const row = rows.get(manifest.skill);
+  assert.ok(row, `${manifest.skill} missing from MATRIX.md`);
+  assert.equal(row.manifest, filename, `${manifest.skill} matrix filename mismatch`);
+
+  for (const key of Object.keys(manifest.assertions || {}).sort()) {
+    assert.match(row.assertions, new RegExp(`(^|, )${key}(,|$)`), `${manifest.skill} matrix must mention assertion ${key}`);
+  }
+
+  const hasAcceptance = manifest.acceptance && Object.keys(manifest.acceptance).length > 0;
+  if (hasAcceptance) {
+    assert.notEqual(row.acceptanceDepth, 'Basic manifest', `${manifest.skill} has acceptance checks but matrix says Basic manifest`);
+  } else {
+    assert.equal(row.acceptanceDepth, 'Basic manifest', `${manifest.skill} has no acceptance block and should be documented as Basic manifest`);
+  }
+}
+
+console.log('skill test matrix tests — PASS');