@lifeaitools/rdc-skills 0.24.10 → 0.24.11

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.24.10",
+  "version": "0.24.11",
   "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": "059f644001fd458a08a98fbe92deec0d50db135b"
+  "sha": "34ba2dc6ccb7c153deff5ebfbf6039e6fab077c8"
 }

package/hooks/foreground-process-gate.js

@@ -46,6 +46,24 @@ function hasHiddenIntent(command) {
     /\bCI\s*=\s*(1|true)\b/i.test(command);
 }
 
+function hasExplicitWindowOverride(command) {
+  return /\bRDC_ALLOW_WINDOW_FOCUS\s*=\s*(1|true)\b/i.test(command) ||
+    /\bRDC_INTERACTIVE_WINDOW\s*=\s*(1|true)\b/i.test(command);
+}
+
+function checkWindowFocusApi(command) {
+  if (hasExplicitWindowOverride(command)) return;
+  const focusApi = /\b(SetForegroundWindow|SwitchToThisWindow|AppActivate|SetWindowPos|ShowWindowAsync?|BringWindowToTop)\b/i;
+  const broadWindowApi = /\b(EnumWindows|Get-Process\s+\|\s*Where-Object|GetWindow|FindWindow)\b/i;
+  const windowMutation = /\b(minimi[sz]e|restore|foreground|focus|activate|collapse)\b/i;
+  if (focusApi.test(command) || (broadWindowApi.test(command) && windowMutation.test(command))) {
+    block(
+      'Window focus/restore/minimize/collapse operations are not allowed in agent-launched commands. Spawn helpers hidden/no-window instead; set RDC_ALLOW_WINDOW_FOCUS=1 only for an explicitly requested interactive recovery action.',
+      { kind: 'window-focus-api' },
+    );
+  }
+}
+
 function checkPlaywright(command) {
   if (!/\b(playwright|@playwright\/test)\b/i.test(command)) return;
 
@@ -68,16 +86,16 @@ function checkPowerShell(command) {
   if (!/\bStart-Process\b/i.test(command)) return;
   if (hasHiddenIntent(command)) return;
   block(
-    '`Start-Process` must include `-WindowStyle Hidden` or `-WindowStyle Minimized` for agent-launched node/cmd/ps1/test processes.',
+    '`Start-Process` must include `-WindowStyle Hidden` or `-WindowStyle Minimized` for agent-launched node/cmd/ps1/test processes. Focus/restore/collapse APIs remain blocked unless explicitly requested.',
     { kind: 'start-process' },
   );
 }
 
 function checkCmdStart(command) {
   if (!/\bcmd(?:\.exe)?\s+\/c\s+start\b/i.test(command)) return;
-  if (/\bcmd(?:\.exe)?\s+\/c\s+start\s+(""|''|`"")?\s*\/(?:min|b)\b/i.test(command)) return;
+  if (/\bcmd(?:\.exe)?\s+\/c\s+start\s+(""|''|`"")?\s*\/b\b/i.test(command)) return;
   block(
-    '`cmd /c start` must use `/min` for visible tools or `/b`/a hidden wrapper for background tools.',
+    '`cmd /c start` must use `/min` or `/b` for background tools. Focus/restore/collapse APIs remain blocked unless explicitly requested.',
     { kind: 'cmd-start' },
   );
 }
@@ -98,6 +116,7 @@ async function main() {
   const command = toolText(raw);
   if (!command) pass({ reason: 'no-command' });
 
+  checkWindowFocusApi(command);
   checkPlaywright(command);
   checkPowerShell(command);
   checkCmdStart(command);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.24.10",
+  "version": "0.24.11",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -35,6 +35,8 @@
     "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",
+    "acceptance": "node scripts/acceptance.mjs --changed",
     "test:mcp": "node tests/mcp.test.mjs",
     "test:mcp:remote": "node tests/mcp.test.mjs --remote",
     "test:channel-formatter": "node tests/channel-formatter.contract.test.mjs",

package/scripts/acceptance.mjs

@@ -0,0 +1,471 @@
+#!/usr/bin/env node
+/**
+ * Build acceptance runner for touched rdc:* skills.
+ *
+ * Runs one sandboxed agent fixture per selected skill, records all observable
+ * engine events/tool calls to JSONL, verifies manifest assertions, and writes a
+ * Markdown report with lessons learned / next build optimizations.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { loadAllManifests } from './lib/manifest-schema.mjs';
+import { runManifest } from './lib/runner.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const REPORTS_DIR = join(REPO_ROOT, '.rdc', 'reports');
+
+const args = process.argv.slice(2);
+const arg = (name, fallback = null) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] || fallback : fallback;
+};
+const has = (name) => args.includes(name);
+
+const ENGINE = arg('--engine', process.env.RDC_ACCEPTANCE_ENGINE || 'claude').toLowerCase();
+const BASE = arg('--base', process.env.RDC_ACCEPTANCE_BASE || 'HEAD~1');
+const PROJECT_CWD = resolve(arg('--project-root', process.env.REGEN_ROOT || process.cwd()));
+const RUN_ID = arg('--run-id', `acceptance-${new Date().toISOString().replace(/[:.]/g, '-')}`);
+const PARALLEL = Math.max(1, parseInt(arg('--parallel', '1'), 10) || 1);
+const CHANGED = has('--changed');
+const STRICT_RECORDING = has('--strict-recording');
+const ONLY_SKILLS = args
+  .flatMap((v, i) => (v === '--skill' && args[i + 1] ? [args[i + 1]] : []))
+  .map(normalizeSkillName);
+
+function normalizeSkillName(name) {
+  if (!name) return name;
+  return name.startsWith('rdc:') ? name : `rdc:${name.replace(/^rdc-/, '')}`;
+}
+
+function sh(cmd, cmdArgs, cwd = REPO_ROOT) {
+  return execFileSync(cmd, cmdArgs, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+
+function changedFiles(base) {
+  try {
+    const mergeBase = sh('git', ['merge-base', base, 'HEAD']);
+    const out = sh('git', ['diff', '--name-only', `${mergeBase}..HEAD`]);
+    return out ? out.split(/\r?\n/).filter(Boolean) : [];
+  } catch {
+    const out = sh('git', ['diff', '--name-only', base]);
+    return out ? out.split(/\r?\n/).filter(Boolean) : [];
+  }
+}
+
+function skillFromPath(file) {
+  const p = file.replace(/\\/g, '/');
+  const m = p.match(/^skills\/([^/]+)\//);
+  if (!m || m[1] === 'tests') return null;
+  return `rdc:${m[1]}`;
+}
+
+function touchedSkillsFromGit(base) {
+  const skills = new Set();
+  for (const file of changedFiles(base)) {
+    const skill = skillFromPath(file);
+    if (skill) skills.add(skill);
+    const test = file.replace(/\\/g, '/').match(/^skills\/tests\/rdc-(.+)\.test\.json$/);
+    if (test) skills.add(`rdc:${test[1]}`);
+  }
+  return [...skills].sort();
+}
+
+function parseJsonLines(text) {
+  const events = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith('{')) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+      // Non-JSON output is still captured in stdout/stderr previews.
+    }
+  }
+  return events;
+}
+
+function findToolName(value) {
+  if (!value || typeof value !== 'object') return null;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.tool_name === 'string') return value.tool_name;
+  if (typeof value.tool === 'string') return value.tool;
+  if (typeof value.server_name === 'string' && typeof value.tool_name === 'string') {
+    return `${value.server_name}.${value.tool_name}`;
+  }
+  return null;
+}
+
+function claudeToolCalls(stdout) {
+  const calls = [];
+  for (const event of parseJsonLines(stdout)) {
+    const type = event.type || event.event || event.kind || '';
+    const msg = event.message || event;
+    const content = Array.isArray(msg.content) ? msg.content : Array.isArray(event.content) ? event.content : [];
+    for (const item of content) {
+      if (item?.type === 'tool_use') {
+        calls.push({
+          engine: 'claude',
+          id: item.id || null,
+          name: item.name || null,
+          input: item.input || null,
+          raw_type: type || 'tool_use',
+        });
+      }
+    }
+    if (/tool/i.test(type)) {
+      const name = findToolName(event);
+      calls.push({
+        engine: 'claude',
+        id: event.id || event.tool_use_id || null,
+        name,
+        input: event.input || event.arguments || event.params || null,
+        raw_type: type,
+      });
+    }
+  }
+  return dedupeCalls(calls);
+}
+
+function assistantText(engine, stdout) {
+  if (engine !== 'claude') return String(stdout || '').trim();
+  const resultEvents = parseJsonLines(stdout).filter((event) => event.type === 'result' && typeof event.result === 'string');
+  if (resultEvents.length > 0) return resultEvents.at(-1).result.trim();
+  const chunks = [];
+  for (const event of parseJsonLines(stdout)) {
+    const msg = event.message || event;
+    const content = Array.isArray(msg.content) ? msg.content : Array.isArray(event.content) ? event.content : [];
+    for (const item of content) {
+      if (item?.type === 'text' && typeof item.text === 'string') chunks.push(item.text);
+    }
+    if (event.type === 'result' && typeof event.result === 'string') chunks.push(event.result);
+  }
+  return chunks.join('\n\n').trim();
+}
+
+function outputAssertionFailures(spec, rendered) {
+  const failures = [];
+  if (!spec || typeof spec !== 'object') return failures;
+  if (Array.isArray(spec.output_contains)) {
+    const missing = spec.output_contains.filter((s) => !rendered.includes(s));
+    if (missing.length > 0) {
+      failures.push({
+        predicate: 'acceptance.output_contains',
+        message: `missing output substrings: ${missing.map((s) => JSON.stringify(s)).join(', ')}`,
+      });
+    }
+  }
+  if (Array.isArray(spec.output_not_contains)) {
+    const present = spec.output_not_contains.filter((s) => rendered.includes(s));
+    if (present.length > 0) {
+      failures.push({
+        predicate: 'acceptance.output_not_contains',
+        message: `forbidden output substrings present: ${present.map((s) => JSON.stringify(s)).join(', ')}`,
+      });
+    }
+  }
+  return failures;
+}
+
+function toolCallAssertionFailures(spec, toolCalls) {
+  const failures = [];
+  if (!spec || typeof spec !== 'object') return failures;
+  const names = toolCalls.map((call) => call.name).filter(Boolean);
+  if (Array.isArray(spec.tool_calls_include_any) && spec.tool_calls_include_any.length > 0) {
+    const hit = spec.tool_calls_include_any.some((expected) => names.includes(expected));
+    if (!hit) {
+      failures.push({
+        predicate: 'acceptance.tool_calls_include_any',
+        message: `expected at least one tool call from: ${spec.tool_calls_include_any.join(', ')}; saw: ${names.join(', ') || '(none)'}`,
+      });
+    }
+  }
+  if (Array.isArray(spec.tool_calls_include_all) && spec.tool_calls_include_all.length > 0) {
+    const missing = spec.tool_calls_include_all.filter((expected) => !names.includes(expected));
+    if (missing.length > 0) {
+      failures.push({
+        predicate: 'acceptance.tool_calls_include_all',
+        message: `missing required tool calls: ${missing.join(', ')}; saw: ${names.join(', ') || '(none)'}`,
+      });
+    }
+  }
+  if (Array.isArray(spec.tool_calls_argument_matches) && spec.tool_calls_argument_matches.length > 0) {
+    for (const matcher of spec.tool_calls_argument_matches) {
+      const tools = Array.isArray(matcher.tools) ? matcher.tools : [];
+      const pattern = typeof matcher.pattern === 'string' ? matcher.pattern : '';
+      if (tools.length === 0 || !pattern) continue;
+      let re = null;
+      try {
+        re = new RegExp(pattern, 'i');
+      } catch {
+        failures.push({
+          predicate: 'acceptance.tool_calls_argument_matches',
+          message: `invalid matcher regex: ${pattern}`,
+        });
+        continue;
+      }
+      const hit = toolCalls.some((call) => tools.includes(call.name) && re.test(JSON.stringify(call.input || {})));
+      if (!hit) {
+        failures.push({
+          predicate: 'acceptance.tool_calls_argument_matches',
+          message: `expected one of ${tools.join(', ')} with arguments matching /${pattern}/`,
+        });
+      }
+    }
+  }
+  return failures;
+}
+
+function codexToolCalls(stdout) {
+  const calls = [];
+  for (const event of parseJsonLines(stdout)) {
+    const type = event.type || event.event || event.kind || '';
+    const name = findToolName(event) || findToolName(event.call) || findToolName(event.item);
+    if (/tool|function/i.test(type) || name) {
+      calls.push({
+        engine: 'codex',
+        id: event.id || event.call_id || event.item_id || null,
+        name,
+        input: event.input || event.arguments || event.params || event.call?.arguments || null,
+        raw_type: type || null,
+      });
+    }
+  }
+  return dedupeCalls(calls);
+}
+
+function dedupeCalls(calls) {
+  const seen = new Set();
+  const out = [];
+  for (const call of calls) {
+    const key = JSON.stringify([call.engine, call.id, call.name, call.raw_type, call.input]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(call);
+  }
+  return out;
+}
+
+function extractToolCalls(engine, observed) {
+  if (engine === 'claude') return claudeToolCalls(observed?.stdout || '');
+  if (engine === 'codex') return codexToolCalls(`${observed?.stdout || ''}\n${observed?.stderr || ''}`);
+  throw new Error(`unsupported engine: ${engine}`);
+}
+
+function writeJsonl(file, event) {
+  appendFileSync(file, `${JSON.stringify({ ts: new Date().toISOString(), ...event })}\n`);
+}
+
+function markdownReport({ runId, engine, selected, results, jsonlPath, artifactDir, startedAt, durationMs }) {
+  const passed = results.filter((r) => r.pass).length;
+  const failed = results.length - passed;
+  const lines = [
+    '---',
+    'type: rdc-skill-acceptance-report',
+    `run_id: ${runId}`,
+    `engine: ${engine}`,
+    `created_at: ${new Date().toISOString()}`,
+    '---',
+    '',
+    `# RDC Skill Acceptance - ${runId}`,
+    '',
+    `Started: ${startedAt}`,
+    `Duration: ${durationMs} ms`,
+    `Evidence JSONL: ${jsonlPath}`,
+    `Artifacts: ${artifactDir}`,
+    '',
+    `Summary: ${passed} passed, ${failed} failed, ${results.length} total.`,
+    '',
+    '## Skills',
+    '',
+  ];
+  for (const r of results) {
+    const status = r.pass ? 'PASS' : 'FAIL';
+    lines.push(`- ${r.skill}: ${status}; tool calls=${r.tool_calls.length}; duration=${r.duration_ms || 0} ms`);
+    if (r.artifacts?.assistant_text) lines.push(`  - output: ${r.artifacts.assistant_text}`);
+    if (r.artifacts?.stdout) lines.push(`  - raw stream: ${r.artifacts.stdout}`);
+    if (r.failures?.length) {
+      for (const failure of r.failures) {
+        lines.push(`  - ${failure.predicate || 'failure'}: ${failure.message || JSON.stringify(failure)}`);
+      }
+    }
+  }
+  lines.push('', '## Lessons Learned', '');
+  const noToolCalls = results.filter((r) => r.pass && r.tool_calls.length === 0);
+  if (noToolCalls.length > 0) {
+    lines.push(`- ${noToolCalls.map((r) => r.skill).join(', ')} passed without observable tool calls. That may be valid for pure formatting/read-only skills, but build acceptance should decide whether those skills need a stricter artifact assertion.`);
+  }
+  if (failed > 0) {
+    lines.push('- Failed skill runs should generate a focused fixture or assertion update before the next build wave is accepted.');
+  }
+  if (results.every((r) => r.tool_calls.length > 0)) {
+    lines.push('- All selected skills emitted observable tool calls in the engine stream.');
+  }
+  lines.push('', '## Next Build Optimizations', '');
+  lines.push('- Keep one fast manifest per rdc:* skill touched by a PR or build wave.');
+  lines.push('- Add engine-specific parsers as new event formats appear instead of weakening the acceptance gate.');
+  lines.push('- Promote recurring failure patterns into manifest assertions rather than relying on transcript review.');
+  lines.push('', '## Selected Skills', '');
+  for (const skill of selected) lines.push(`- ${skill}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+async function runPool(items, parallel, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function lane() {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await worker(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(parallel, items.length) }, lane));
+  return results;
+}
+
+async function main() {
+  if (!['claude', 'codex'].includes(ENGINE)) {
+    console.error(`unsupported --engine ${ENGINE}; expected claude or codex`);
+    process.exit(2);
+  }
+  if (ENGINE === 'codex') {
+    console.error('codex acceptance adapter can parse Codex JSONL, but live Codex agent spawning is not wired in this repo yet.');
+    process.exit(2);
+  }
+
+  mkdirSync(REPORTS_DIR, { recursive: true });
+  const startedAt = new Date().toISOString();
+  const started = Date.now();
+  const jsonlPath = join(REPORTS_DIR, `${RUN_ID}.jsonl`);
+  const mdPath = join(REPORTS_DIR, `${RUN_ID}.md`);
+  const artifactDir = join(REPORTS_DIR, RUN_ID);
+  mkdirSync(artifactDir, { recursive: true });
+
+  const selected = new Set(ONLY_SKILLS);
+  if (CHANGED) for (const skill of touchedSkillsFromGit(BASE)) selected.add(skill);
+  if (selected.size === 0) {
+    console.error('no skills selected; pass --changed and/or --skill rdc:name');
+    process.exit(2);
+  }
+
+  const manifests = loadAllManifests();
+  const bySkill = new Map(manifests.filter((m) => m.ok && m.manifest).map((m) => [m.manifest.skill, m]));
+  const missing = [...selected].filter((skill) => !bySkill.has(skill));
+  for (const skill of missing) {
+    writeJsonl(jsonlPath, { kind: 'missing_manifest', run_id: RUN_ID, skill });
+  }
+  if (missing.length > 0) {
+    console.error(`missing acceptance manifest(s): ${missing.join(', ')}`);
+    console.error(`evidence: ${jsonlPath}`);
+    process.exit(1);
+  }
+
+  const selectedManifests = [...selected].sort().map((skill) => bySkill.get(skill).manifest);
+  writeJsonl(jsonlPath, {
+    kind: 'start',
+    run_id: RUN_ID,
+    engine: ENGINE,
+    selected: selectedManifests.map((m) => m.skill),
+    project_cwd: PROJECT_CWD,
+  });
+
+  const results = await runPool(selectedManifests, PARALLEL, async (manifest) => {
+    writeJsonl(jsonlPath, { kind: 'skill_start', run_id: RUN_ID, skill: manifest.skill, prompt: manifest.fixture?.prompt });
+    const result = await runManifest(manifest, {
+      runId: RUN_ID,
+      projectCwd: PROJECT_CWD,
+    });
+    const toolCalls = result.observed ? extractToolCalls(ENGINE, result.observed) : [];
+    const safeSkill = manifest.skill.replace(/[^a-z0-9-]+/gi, '-').replace(/^-+|-+$/g, '');
+    const stdoutPath = join(artifactDir, `${safeSkill}.stdout.jsonl`);
+    const stderrPath = join(artifactDir, `${safeSkill}.stderr.txt`);
+    const assistantPath = join(artifactDir, `${safeSkill}.assistant.md`);
+    const rendered = assistantText(ENGINE, result.observed?.stdout || '');
+    writeFileSync(stdoutPath, result.observed?.stdout || '');
+    writeFileSync(stderrPath, result.observed?.stderr || '');
+    writeFileSync(assistantPath, rendered || '');
+    const failures = [
+      ...(result.failures || []),
+      ...outputAssertionFailures(manifest.acceptance, rendered),
+      ...toolCallAssertionFailures(manifest.acceptance, toolCalls),
+    ];
+    const pass = failures.length === 0 && Boolean(result.pass) && (!STRICT_RECORDING || toolCalls.length > 0);
+    if (result.pass && STRICT_RECORDING && toolCalls.length === 0) {
+      failures.push({ predicate: 'tool_calls', message: 'strict recording requires at least one observable tool call' });
+    }
+    writeJsonl(jsonlPath, {
+      kind: 'skill_result',
+      run_id: RUN_ID,
+      skill: manifest.skill,
+      pass,
+      duration_ms: result.duration_ms,
+      tool_calls: toolCalls,
+      failures,
+      artifacts: {
+        stdout: stdoutPath,
+        stderr: stderrPath,
+        assistant_text: assistantPath,
+      },
+      assistant_preview: rendered.slice(0, 2000),
+      worktree: result.worktree || null,
+      observed: {
+        exit_code: result.observed?.exit_code,
+        timed_out: result.observed?.timed_out,
+        files_modified: result.observed?.files_modified || [],
+        commits: result.observed?.commits || [],
+        stdout_chars: result.observed?.stdout?.length || 0,
+        stderr_chars: result.observed?.stderr?.length || 0,
+      },
+    });
+    return {
+      ...result,
+      pass,
+      failures,
+      tool_calls: toolCalls,
+      artifacts: {
+        stdout: stdoutPath,
+        stderr: stderrPath,
+        assistant_text: assistantPath,
+      },
+      assistant_preview: rendered.slice(0, 2000),
+    };
+  });
+
+  const durationMs = Date.now() - started;
+  writeJsonl(jsonlPath, {
+    kind: 'end',
+    run_id: RUN_ID,
+    duration_ms: durationMs,
+    pass: results.filter((r) => r.pass).length,
+    fail: results.filter((r) => !r.pass).length,
+  });
+  writeFileSync(mdPath, markdownReport({
+    runId: RUN_ID,
+    engine: ENGINE,
+    selected: selectedManifests.map((m) => m.skill),
+    results,
+    jsonlPath,
+    artifactDir,
+    startedAt,
+    durationMs,
+  }));
+
+  const failed = results.filter((r) => !r.pass);
+  console.log(`rdc skill acceptance: ${results.length - failed.length} passed, ${failed.length} failed`);
+  console.log(`evidence: ${jsonlPath}`);
+  console.log(`report: ${mdPath}`);
+  if (failed.length > 0) {
+    for (const r of failed) console.log(`FAIL ${r.skill}: ${r.failures?.map((f) => f.message).join('; ') || r.error || 'unknown'}`);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/lib/assertions.mjs

@@ -128,6 +128,20 @@ export function checkStdoutContains(expected, observed) {
   };
 }
 
+export function checkStdoutNotContains(expected, observed) {
+  if (expected === undefined) return { pass: true };
+  if (!Array.isArray(expected)) {
+    return { pass: false, message: "stdout_not_contains assertion is not an array" };
+  }
+  const stdout = observed.stdout || "";
+  const present = expected.filter((s) => stdout.includes(s));
+  if (present.length === 0) return { pass: true };
+  return {
+    pass: false,
+    message: `stdout_not_contains: forbidden substrings present: ${present.map((s) => JSON.stringify(s)).join(", ")}`,
+  };
+}
+
 // ─── evaluator ──────────────────────────────────────────────────────────────
 
 const PREDICATES = [
@@ -137,6 +151,7 @@ const PREDICATES = [
   ["commits_made", checkCommitsMade],
   ["stderr_empty", checkStderrEmpty],
   ["stdout_contains", checkStdoutContains],
+  ["stdout_not_contains", checkStdoutNotContains],
 ];
 
 export function evaluateAssertions(assertions, observed) {
@@ -185,6 +200,7 @@ if (__isMain) {
         commits_made: { min: 1, message_matches: "fix.*README" },
         stderr_empty: true,
         stdout_contains: ["✓", "Verdict:"],
+        stdout_not_contains: ["NOTPRESENT"],
       },
       observed: baseObserved,
       expect: (r) => r.pass && r.failures.length === 0,
@@ -226,20 +242,27 @@ if (__isMain) {
     },
     {
       n: 7,
+      desc: "stdout_not_contains catches forbidden substring",
+      assertions: { stdout_not_contains: ["Verdict:"] },
+      observed: baseObserved,
+      expect: (r) => !r.pass && r.failures.some((f) => f.predicate === "stdout_not_contains"),
+    },
+    {
+      n: 8,
       desc: "work_items_created label filter rejects",
       assertions: { work_items_created: { min: 1, labels_include: ["nonexistent"] } },
       observed: baseObserved,
       expect: (r) => !r.pass && r.failures.some((f) => f.predicate === "work_items_created"),
     },
     {
-      n: 8,
+      n: 9,
       desc: "work_items_created max exceeded",
       assertions: { work_items_created: { max: 0 } },
       observed: baseObserved,
       expect: (r) => !r.pass && r.failures.some((f) => f.predicate === "work_items_created"),
     },
     {
-      n: 9,
+      n: 10,
       desc: "empty assertions → pass",
       assertions: {},
       observed: baseObserved,

package/scripts/lib/manifest-schema.mjs

@@ -36,6 +36,7 @@ const TOP_LEVEL_FIELDS = new Set([
   "description",
   "fixture",
   "assertions",
+  "acceptance",
   "teardown",
 ]);
 
@@ -48,6 +49,7 @@ const ASSERTION_FIELDS = new Set([
   "commits_made",
   "stderr_empty",
   "stdout_contains",
+  "stdout_not_contains",
 ]);
 
 const WIC_FIELDS = new Set(["min", "max", "status", "labels_include"]);
@@ -337,6 +339,17 @@ function validateAssertions(a, errors, warnings) {
       });
     }
   }
+  if (a.stdout_not_contains !== undefined) {
+    if (!Array.isArray(a.stdout_not_contains)) {
+      err(errors, "assertions.stdout_not_contains", "type", "stdout_not_contains must be an array");
+    } else {
+      a.stdout_not_contains.forEach((s, i) => {
+        if (typeof s !== "string") {
+          err(errors, `assertions.stdout_not_contains[${i}]`, "type", "entry must be a string");
+        }
+      });
+    }
+  }
   for (const k of Object.keys(a)) {
     if (!ASSERTION_FIELDS.has(k)) {
       warn(warnings, `assertions.${k}`, "unknown-field", `unknown assertion "${k}"`);

package/scripts/self-test.mjs

@@ -92,10 +92,12 @@ const KNOWN_CLAUTH_KEYS = new Set([
   "coolify-api",
   "cloudflare",
   "npm",
-  "supabase",
-  "supabase-anon",
-  "supabase-db",
-  "r2-access-key-id",
+  "supabase",
+  "supabase-anon",
+  "supabase-db",
+  "supabase-service",
+  "supabase-service-role",
+  "r2-access-key-id",
   "r2-secret-key",
   "anthropic",
   "openai",

package/scripts/test-guide-validator.mjs

@@ -64,6 +64,8 @@ const KNOWN_CLAUTH_KEYS = new Set([
   "supabase",
   "supabase-anon",
   "supabase-db",
+  "supabase-service",
+  "supabase-service-role",
   "r2-access-key-id",
   "r2-secret-key",
   "anthropic",

package/skills/channel-formatter/SKILL.md

@@ -83,11 +83,33 @@ skills named in the scope boundary.
 
 1. **Detect channel or pack mode** from the request using the tables above.
 2. **Classify the source**: already-drafted copy, long article/report, transcript, notes, or brief.
-3. **For long sources**, extract thesis, audience, proof points, CTA, constraints, and factual risks before writing.
-4. **Jump to the target channel or pack section** below and apply all rules exactly — do not rely on memory.
-5. **Never mix** markdown conventions across channels.
-6. If the channel or pack is ambiguous, ask once: "Is this for [Channel A] or [Channel B]?"
-7. Produce the formatted or repurposed output directly as the deliverable.
+3. **For thin or under-specified long sources**, enrich before writing instead
+   of inventing context:
+   - If the source names a corpus path, read it.
+   - Otherwise search/read the approved corpus first when available. Resolve
+     `CORPUS_ROOT` (usually `H:/My Drive/global-corpus`) and
+     `LOCAL_CORPUS_ROOT` (usually `C:/Dev/local-corpus`) before searching the
+     repo. If environment variables are not visible, try those default paths.
+   - The corpus search must use an explicit corpus path in the tool arguments
+     (`H:/My Drive/global-corpus` or `C:/Dev/local-corpus`). A relative repo
+     search does not count as enrichment.
+   - Use `Grep`/`Glob`/`Read` or the environment's equivalent tools so the
+     transcript records what was consulted.
+   - Use web search only when the requested output needs current/public facts,
+     the user asks for external context, or corpus context is absent and network
+     search is allowed. Cite/use only what the search actually supports.
+   - Searching only the project repo is not enough for enrichment unless the
+     source itself points to a repo-local corpus file.
+   - If neither corpus nor web context is available, keep the output sparse and
+     mark missing context in assumptions; do not fill gaps creatively.
+4. **For long sources**, extract thesis, audience, proof points, CTA, constraints, and factual risks before writing.
+5. **Jump to the target channel or pack section** below and apply all rules exactly — do not rely on memory.
+6. **Never mix** markdown conventions across channels.
+7. If the channel or pack is ambiguous, ask once: "Is this for [Channel A] or [Channel B]?"
+8. Produce the formatted or repurposed output directly as the deliverable.
+9. Treat extraction notes and source-fidelity guardrails as internal scratchwork.
+   Do not print a "Long-Source Extraction Checklist", factual guardrail list, or
+   absent-topic list unless the user explicitly asks for analysis.
 
 ## Hard Rules (all channels)
 
@@ -167,7 +189,7 @@ Repurpose one source for an announcement:
 - 3 CTA variants
 
 ### Long-Source Extraction Checklist
-Before writing from a long source, identify:
+Before writing from a long source, identify internally:
 - **Thesis:** the central argument or announcement
 - **Audience:** who this is for
 - **Proof:** facts, examples, data, names, dates, or quotes explicitly present
@@ -179,13 +201,39 @@ Before writing from a long source, identify:
 ### Source-Fidelity Rules
 - Do not invent statistics, dates, quotes, citations, partnerships, revenue,
   legal claims, customer names, or outcomes.
+- Do not infer adjacent finance/reporting concepts that sound plausible but are
+  absent from the source, such as pro forma assumptions, reporting cadence,
+  offset mechanisms, governance structures, verification status, or portfolio
+  implications.
+- If corpus or web context was consulted, use it only for facts it directly
+  supports. Do not blend generic domain knowledge into the source as if it were
+  documented.
+- If the source provides a theme label without an explanation, keep the theme
+  label or paraphrase it conservatively. Do not add explanatory clauses that
+  define how it works, who governs it, how it is verified, how often it reports,
+  or what financial model it opposes unless those details are explicit.
+- Do not contrast patient capital with quarters, earnings calls, fund cycles,
+  exits, venture speed, or portfolio management unless those words or concepts
+  appear in the source or consulted corpus/web material.
 - Do not upgrade tentative language into certainty.
 - Do not turn illustrative examples into facts.
 - Preserve caveats when they affect meaning.
 - If a stronger hook needs a proof point the source does not provide, write a
   proof-neutral hook instead.
+- If the source says a topic is absent, excluded, or not mentioned, treat that
+  as an internal guardrail. Do not repeat the absent topic in public-facing
+  channel copy, assumptions, caveats, notes, headings, or summaries unless the
+  user explicitly asks for a contrast, compliance note, or risk disclosure.
+  Strip absent-topic lists from the deliverable entirely.
 - When assumptions are material, include a short "Assumptions:" line before the
   deliverable rather than burying uncertainty in polished copy.
+- Do not output your extraction checklist. The deliverable should start with the
+  requested channel/pack output, except for a brief "Assumptions:" line when a
+  material gap affects the copy.
+- If you include an "Assumptions:" line, limit it to missing useful inputs such
+  as org name, audience, location, date, CTA, or link. Never list absent,
+  excluded, or not-mentioned topics in the assumptions line. If the only
+  uncertainty is an absent-topic guardrail, omit the assumptions line.
 
 ---
 
@@ -231,6 +279,8 @@ channel-native. A pack is not a generic summary repeated in several lengths.
   email/web, concise in Slack.
 - Use channel-specific formatting rules from the sections below.
 - If source proof is weak, use curiosity and framing instead of inflated claims.
+- Do not include extraction notes, guardrail notes, or absent-topic caveats in
+  the pack. Those are reasoning aids, not channel outputs.
 
 ---
 

package/skills/lifeai-brochure-author/SKILL.md

@@ -21,6 +21,8 @@ required_validators:
 ---
 
 # LIFEAI Brochure Authoring Contract
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Return the authored JSX guidance or verification result directly; do not dump raw tool logs.
 
 This is the contract every AI engine obeys when generating brochure JSX. The contract is non-negotiable. If you cannot generate output that complies, **stop and ask for clarification rather than emit non-compliant code.**
 

package/skills/rdc-brochurify/SKILL.md

@@ -13,6 +13,8 @@ triggers:
 ---
 
 # rdc:brochurify Orchestrator
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Report brochure job state, artifacts, and blockers directly; do not dump raw tool logs.
 
 The orchestrator dispatches six waves of typed sub-agents in sequence. Each wave has a clear input contract, an output contract, and a parallelism profile.
 

package/skills/rdc-extract-verifier-rules/SKILL.md

@@ -13,6 +13,8 @@ triggers:
 ---
 
 # rdc:extract-verifier-rules
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Return candidate rules, evidence, and PR status directly; do not dump raw tool logs.
 
 The self-learning loop. The verifier corpus is the moat (per `DECISIONS-LOG.md` D-009). This skill is how the corpus grows.
 

package/skills/rpms-filemap/SKILL.cloud.md

@@ -1,4 +1,5 @@
 ---
+name: rpms-filemap
 description: "Generated RPMS file map — RULE #1, canonical homes, and Context Export pointers served from regen-root manifest."
 slash: "rdc:rpms-filemap"
 category: "tooling"
@@ -12,6 +13,9 @@ triggers:
   - "where should pm artifacts go"
 ---
 # RPMS File Map
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Return the requested file-map guidance directly; do not dump raw manifests or logs.
+
 > GENERATED FILE - DO NOT HAND-EDIT.
 > Source of truth: `docs/architecture/rpms.locations.json`
 > Regenerate: `pnpm rpms:gen-filemap`

package/skills/rpms-filemap/SKILL.md

@@ -1,4 +1,5 @@
 ---
+name: rpms-filemap
 description: "Generated RPMS file map — RULE #1, canonical homes, and Context Export pointers served from regen-root manifest."
 slash: "rdc:rpms-filemap"
 category: "tooling"
@@ -12,6 +13,9 @@ triggers:
   - "where should pm artifacts go"
 ---
 # RPMS File Map
+> **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
+> Return the requested file-map guidance directly; do not dump raw manifests or logs.
+
 > GENERATED FILE - DO NOT HAND-EDIT.
 > Source of truth: `docs/architecture/rpms.locations.json`
 > Regenerate: `pnpm rpms:gen-filemap`

package/skills/tests/README.md

@@ -23,6 +23,11 @@ is the source of truth. Top-level fields:
 4. Run `node scripts/self-test.mjs --tier2 --skill rdc:<name>` to smoke-test
 5. Commit manifest + any skill changes together
 
+For content-producing skills, include both positive and negative output checks.
+Use `stdout_contains` for expected channel-native structure and source facts;
+use `stdout_not_contains` for source-fidelity violations or explicitly forbidden
+claims.
+
 ## Adding a new skill
 
 New skills MUST ship with a manifest. Tier 2 CI will block tag push if a

package/skills/tests/rdc-channel-formatter.test.json

@@ -0,0 +1,45 @@
+{
+  "manifest_version": 1,
+  "skill": "rdc:channel-formatter",
+  "description": "Channel formatter turns a long article into a social content pack in RDC_TEST mode without fabricating source claims.",
+  "fixture": {
+    "prompt": "rdc:channel-formatter social-pack docs/source/channel-formatter-long-article.md",
+    "precondition_files": [
+      {
+        "path": "docs/source/channel-formatter-long-article.md",
+        "content": "# Wetland Finance Article\n\nA 2026 field note from the finance team says the pilot restored 42 acres of riparian habitat, reduced annual irrigation demand by 18 percent, and produced three investor update themes: patient capital, measurable ecological return, and community operating discipline.\n\nThis is intentionally thin. Before writing, consult available corpus context for regenerative finance / wetland finance language. Use an explicit corpus-path search of `C:/Dev/local-corpus` or `H:/My Drive/global-corpus`; if neither path has support, keep claims limited to the source.\n\nThe absent-topic list below is a private guardrail only. Do not repeat these terms in assumptions, notes, caveats, headings, summaries, or public-facing output.\n\nThe source does not mention carbon credits, tokenization, celebrity partners, guaranteed returns, quarterly earnings, fund cycles, verification status, portfolio management, or governance structures."
+      }
+    ],
+    "env": { "RDC_TEST": "1" }
+  },
+  "assertions": {
+    "exit_code": 0,
+    "stdout_contains": ["LinkedIn", "Twitter/X", "Slack", "42 acres", "18 percent"]
+  },
+  "acceptance": {
+    "output_contains": ["LinkedIn", "Twitter/X", "Slack", "42 acres", "18%"],
+    "output_not_contains": [
+      "carbon credits",
+      "tokenization",
+      "celebrity partners",
+      "guaranteed returns",
+      "pro forma",
+      "offsets",
+      "governance",
+      "quarterly",
+      "verified",
+      "fund cycle",
+      "fund-cycle",
+      "portfolio manager",
+      "portfolio management"
+    ],
+    "tool_calls_include_any": ["Grep", "Glob", "WebSearch"],
+    "tool_calls_argument_matches": [
+      {
+        "tools": ["Grep", "Glob", "WebSearch"],
+        "pattern": "global-corpus|local-corpus|CORPUS_ROOT|LOCAL_CORPUS_ROOT|web"
+      }
+    ]
+  },
+  "teardown": { "reset_branch": true }
+}

package/tests/acceptance.test.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const script = join(REPO_ROOT, 'scripts', 'acceptance.mjs');
+
+const syntax = spawnSync(process.execPath, ['--check', script], { encoding: 'utf8' });
+assert.equal(syntax.status, 0, syntax.stderr);
+
+const missing = spawnSync(process.execPath, [script, '--skill', 'rdc:not-a-real-skill'], {
+  cwd: REPO_ROOT,
+  encoding: 'utf8',
+});
+assert.equal(missing.status, 1);
+assert.match(missing.stderr, /missing acceptance manifest/);
+
+const codex = spawnSync(process.execPath, [script, '--engine', 'codex', '--skill', 'rdc:plan'], {
+  cwd: REPO_ROOT,
+  encoding: 'utf8',
+});
+assert.equal(codex.status, 2);
+assert.match(codex.stderr, /Codex JSONL/);
+
+const emptyProject = mkdtempSync(join(tmpdir(), 'rdc-acceptance-empty-'));
+try {
+  const none = spawnSync(process.execPath, [script, '--changed', '--base', 'HEAD', '--project-root', emptyProject], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  });
+  assert.notEqual(none.status, 0);
+} finally {
+  rmSync(emptyProject, { recursive: true, force: true });
+}
+
+console.log('acceptance tests — PASS');

package/tests/harness-gates.test.mjs

@@ -146,7 +146,37 @@ const WI = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
 }
 
 // ===========================================================================
-// 2. post-tool-batch-gate.js
+// 2. foreground-process-gate.js
+// ===========================================================================
+{
+  const focusPayload = {
+    tool_input: {
+      command: "powershell -NoProfile -Command \"Add-Type '[DllImport(\\\"user32.dll\\\")] public static extern bool SetForegroundWindow(System.IntPtr hWnd);'\"",
+    },
+  };
+  const r = runHook('foreground-process-gate.js', focusPayload, {});
+  assert('FPG blocks SetForegroundWindow focus API', r.status === 1, `status=${r.status} ${r.stdout}${r.stderr}`);
+  assert('FPG block mentions window focus operations', /Window focus\/restore\/minimize\/collapse/.test(r.stdout + r.stderr));
+
+  const hiddenPayload = {
+    tool_input: {
+      command: 'powershell.exe -NoProfile -NonInteractive -WindowStyle Hidden -File ".\\\\scripts\\\\helper.ps1"',
+    },
+  };
+  const h = runHook('foreground-process-gate.js', hiddenPayload, {});
+  assert('FPG allows hidden PowerShell helper', h.status === 0, `status=${h.status} ${h.stdout}${h.stderr}`);
+
+  const minimizedPayload = {
+    tool_input: {
+      command: 'Start-Process powershell.exe -WindowStyle Minimized -ArgumentList "-NoProfile"',
+    },
+  };
+  const m = runHook('foreground-process-gate.js', minimizedPayload, {});
+  assert('FPG allows minimized Start-Process without focus APIs', m.status === 0, `status=${m.status} ${m.stdout}${m.stderr}`);
+}
+
+// ===========================================================================
+// 3. post-tool-batch-gate.js
 // ===========================================================================
 {
   const ptb = require(join(HOOKS, 'post-tool-batch-gate.js'));
@@ -197,7 +227,7 @@ const WI = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
 }
 
 // ===========================================================================
-// 3. gate-watchdog-selfcheck.js
+// 4. gate-watchdog-selfcheck.js
 // ===========================================================================
 {
   const wd = require(join(HOOKS, 'gate-watchdog-selfcheck.js'));

package/tests/validate-skills.js

@@ -1,183 +1,27 @@
 #!/usr/bin/env node
 /**
- * Validate rdc-skills skills and guides
+ * Compatibility wrapper for the current rdc-skills validation gate.
  *
- * Checks:
- * - YAML frontmatter exists and has required fields
- * - Required sections exist (## When to Use, etc.)
- * - Markdown is well-formed
- *
- * Exit codes:
- *   0 = all valid
- *   1 = validation failed
+ * The older validator required every skill to use the same "When to Use" /
+ * "Procedure" section shape. The canonical gate is now scripts/self-test.mjs,
+ * which understands the shipped skill variants, guide checks, hook behavior,
+ * plugin metadata, and strict warning policy.
  */
 
-const fs = require('fs');
-const path = require('path');
-
-const REQUIRED_FRONTMATTER = ['name', 'description'];
-const REQUIRED_SECTIONS = [
-  '## When to Use',
-  '## Procedure' // OR '## Arguments'
-];
-
-let passed = 0;
-let failed = 0;
-const errors = [];
-
-function validateFile(filePath) {
-  try {
-    const contents = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
-    const lines = contents.split('\n');
-
-    // Check frontmatter
-    if (!lines[0].includes('---')) {
-      errors.push(`${path.basename(filePath)}: Missing YAML frontmatter start`);
-      return false;
-    }
-
-    let frontmatterEnd = -1;
-    for (let i = 1; i < lines.length; i++) {
-      if (lines[i].includes('---')) {
-        frontmatterEnd = i;
-        break;
-      }
-    }
-
-    if (frontmatterEnd === -1) {
-      errors.push(`${path.basename(filePath)}: YAML frontmatter not closed`);
-      return false;
-    }
+const { spawnSync } = require("node:child_process");
+const { join, dirname } = require("node:path");
 
-    // Parse frontmatter
-    const frontmatterLines = lines.slice(1, frontmatterEnd);
-    const frontmatter = {};
+const repoRoot = dirname(dirname(__filename));
+const selfTest = join(repoRoot, "scripts", "self-test.mjs");
 
-    for (const line of frontmatterLines) {
-      const match = line.match(/^(\w+):\s*(.+)$/);
-      if (match) {
-        frontmatter[match[1]] = match[2];
-      }
-    }
+const result = spawnSync(process.execPath, [selfTest, "--strict"], {
+  cwd: repoRoot,
+  stdio: "inherit",
+});
 
-    // Check required fields
-    for (const field of REQUIRED_FRONTMATTER) {
-      if (!frontmatter[field]) {
-        errors.push(`${path.basename(filePath)}: Missing frontmatter field '${field}'`);
-        return false;
-      }
-    }
-
-    // Check required sections
-    const bodyText = lines.slice(frontmatterEnd + 1).join('\n');
-    const hasWhenToUse = bodyText.includes('## When to Use');
-    const hasProcedure = bodyText.includes('## Procedure');
-    const hasArguments = bodyText.includes('## Arguments');
-
-    if (!hasWhenToUse) {
-      errors.push(`${path.basename(filePath)}: Missing '## When to Use' section`);
-      return false;
-    }
-
-    if (!hasProcedure && !hasArguments) {
-      errors.push(`${path.basename(filePath)}: Missing '## Procedure' or '## Arguments' section`);
-      return false;
-    }
-
-    return true;
-  } catch (err) {
-    errors.push(`${path.basename(filePath)}: ${err.message}`);
-    return false;
-  }
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(2);
 }
 
-function validateDirectory(dirPath, dirName) {
-  if (!fs.existsSync(dirPath)) {
-    console.log(`ℹ  ${dirName}/ directory not found (will be populated later)`);
-    return;
-  }
-
-  // Skills are in subdirectories: skills/<name>/SKILL.md
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  const skillFiles = [];
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const skillMd = path.join(dirPath, entry.name, 'SKILL.md');
-      if (fs.existsSync(skillMd)) {
-        skillFiles.push({ label: `${entry.name}/SKILL.md`, filePath: skillMd });
-      }
-    } else if (entry.name.endsWith('.md')) {
-      skillFiles.push({ label: entry.name, filePath: path.join(dirPath, entry.name) });
-    }
-  }
-
-  if (skillFiles.length === 0) {
-    console.log(`ℹ  ${dirName}/ (empty — will be populated later)`);
-    return;
-  }
-
-  console.log(`\nValidating ${dirName}/`);
-  console.log('─'.repeat(40));
-
-  for (const { label, filePath } of skillFiles) {
-    if (validateFile(filePath)) {
-      console.log(`  ✓ ${label}`);
-      passed++;
-    } else {
-      console.log(`  ✗ ${label}`);
-      failed++;
-    }
-  }
-}
-
-// Main
-console.log('rdc-skills Validator');
-console.log('====================\n');
-
-const repoRoot = path.dirname(path.dirname(__filename));
-const skillsDir = path.join(repoRoot, 'skills');
-const guidesDir = path.join(repoRoot, 'guides');
-
-validateDirectory(skillsDir, 'skills');
-
-// Guides are prose docs — just check they are readable markdown files
-if (fs.existsSync(guidesDir)) {
-  const guideFiles = fs.readdirSync(guidesDir).filter(f => f.endsWith('.md'));
-  if (guideFiles.length > 0) {
-    console.log('\nValidating guides/ (readability only)');
-    console.log('─'.repeat(40));
-    for (const file of guideFiles) {
-      try {
-        fs.readFileSync(path.join(guidesDir, file), 'utf8');
-        console.log(`  ✓ ${file}`);
-        passed++;
-      } catch (err) {
-        errors.push(`${file}: ${err.message}`);
-        console.log(`  ✗ ${file}`);
-        failed++;
-      }
-    }
-  }
-}
-
-console.log('\n' + '═'.repeat(40));
-if (errors.length > 0) {
-  console.log('\nErrors:');
-  for (const err of errors) {
-    console.log(`  • ${err}`);
-  }
-}
-
-console.log(`\nResults: ${passed} passed, ${failed} failed`);
-
-if (failed === 0 && passed > 0) {
-  console.log('✓ All files valid\n');
-  process.exit(0);
-} else if (failed === 0 && passed === 0) {
-  console.log('ℹ  No files to validate (plugin base not yet populated)\n');
-  process.exit(0);
-} else {
-  console.log('✗ Validation failed\n');
-  process.exit(1);
-}
+process.exit(result.status ?? 1);