@lifeaitools/rdc-skills 0.24.27 → 0.24.28

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.24.27",
+  "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/git-sha.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.24.27",
+  "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/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/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');