rsc-universal 0.1.1

package/scripts/lib/behavior-score.js

@@ -0,0 +1,103 @@
+// behavior-score.js — pure scoring math for the behavioral skill gate.
+// No I/O, no LLM, no randomness: every function is deterministic and unit-tested.
+// The Workflow engine returns raw grader signals; this lib turns them into the /10.
+
+export const ABS_MIN = 8.5;
+export const LIFT_MIN = 1.0;
+export const COVERAGE_WEIGHT = 0.6;
+export const QUALITY_WEIGHT = 0.4;
+
+export function round1(x) {
+  return Math.round(x * 10) / 10;
+}
+
+// Compose one output's 0-10 from grader signals.
+// signals: { mustInclude: [{satisfied:boolean}], quality: {completeness,actionability,correctness,grounding} }
+export function composeOutputScore(signals) {
+  const mi = Array.isArray(signals && signals.mustInclude) ? signals.mustInclude : [];
+  const total = mi.length;
+  const satisfied = mi.filter((m) => m && m.satisfied).length;
+  const q = (signals && signals.quality) || {};
+  const qVals = [q.completeness, q.actionability, q.correctness, q.grounding]
+    .map((v) => (typeof v === 'number' ? v : 0));
+  const quality = qVals.reduce((a, b) => a + b, 0) / qVals.length; // 0-10
+  if (total === 0) return round1(quality); // no checklist -> quality only
+  const coverage = (satisfied / total) * 10; // 0-10
+  return round1(COVERAGE_WEIGHT * coverage + QUALITY_WEIGHT * quality);
+}
+
+// treatmentScore/baselineScore are composed 0-10 numbers.
+export function deriveScenario(treatmentScore, baselineScore) {
+  return { absolute: round1(treatmentScore), delta: round1(treatmentScore - baselineScore) };
+}
+
+// scenarios: array of {absolute, delta} | null
+export function aggregate(scenarios) {
+  const valid = scenarios.filter((s) => s && typeof s.absolute === 'number');
+  const dropped = scenarios.length - valid.length;
+  if (valid.length === 0) return { absoluteScore: null, lift: null, n: 0, dropped };
+  const absoluteScore = round1(valid.reduce((a, s) => a + s.absolute, 0) / valid.length);
+  const lift = round1(valid.reduce((a, s) => a + s.delta, 0) / valid.length);
+  return { absoluteScore, lift, n: valid.length, dropped };
+}
+
+export function behavioralGate(agg) {
+  const reasons = [];
+  const mustFix = [];
+  if (!agg || agg.n === 0) {
+    reasons.push('No gradeable capability scenarios (none present or all dropped).');
+    mustFix.push('Add at least one capability scenario with a must_include rubric, then re-run.');
+    return { pass: false, reasons, mustFix };
+  }
+  let pass = true;
+  if (agg.absoluteScore < ABS_MIN) {
+    pass = false;
+    reasons.push(`absolute_score ${agg.absoluteScore} < ${ABS_MIN}`);
+    mustFix.push(`Raise produced-output quality: absolute ${agg.absoluteScore}, needs >= ${ABS_MIN}.`);
+  }
+  if (agg.lift < LIFT_MIN) {
+    pass = false;
+    reasons.push(`lift ${agg.lift} < ${LIFT_MIN}`);
+    mustFix.push(`Skill barely beats no-skill (lift ${agg.lift}). Make the body add value a bare agent lacks.`);
+  }
+  return { pass, reasons, mustFix };
+}
+
+// raw: { skillId, scenarios: [{index, xIsTreatment, gradeX, gradeY, error?}] }
+export function scoreFromRaw(raw) {
+  const scenarios = (raw && Array.isArray(raw.scenarios) ? raw.scenarios : []).map((s) => {
+    if (!s || s.error || !s.gradeX || !s.gradeY) {
+      return { index: s ? s.index : null, error: (s && s.error) || 'missing-grade', absolute: null, delta: null };
+    }
+    const treatment = s.xIsTreatment ? s.gradeX : s.gradeY;
+    const baseline = s.xIsTreatment ? s.gradeY : s.gradeX;
+    const t = composeOutputScore(treatment);
+    const b = composeOutputScore(baseline);
+    const d = deriveScenario(t, b);
+    return { index: s.index, treatment: t, baseline: b, absolute: d.absolute, delta: d.delta };
+  });
+  const agg = aggregate(scenarios);
+  const gate = behavioralGate(agg);
+  return { skillId: (raw && raw.skillId) || null, scenarios, aggregate: agg, gate };
+}
+
+export function formatScorecard(scored) {
+  const { skillId, scenarios, aggregate: agg, gate } = scored;
+  const lines = [];
+  lines.push(`# Behavioral scorecard — ${skillId || '(unknown skill)'}`);
+  lines.push('');
+  lines.push(`**Verdict:** ${gate.pass ? 'PASS ✅' : 'FAIL ❌'}  ·  absolute ${agg.absoluteScore == null ? 'n/a' : agg.absoluteScore}/10 (gate >= ${ABS_MIN})  ·  lift ${agg.lift == null ? 'n/a' : agg.lift} (gate >= ${LIFT_MIN})  ·  n=${agg.n}${agg.dropped ? ` (${agg.dropped} dropped)` : ''}`);
+  lines.push('');
+  lines.push('| Scenario | Treatment | Baseline | Delta |');
+  lines.push('|---|---|---|---|');
+  for (const s of scenarios) {
+    if (s.error) { lines.push(`| ${s.index} | — | — | dropped (${s.error}) |`); continue; }
+    lines.push(`| ${s.index} | ${s.treatment} | ${s.baseline} | ${s.delta >= 0 ? '+' : ''}${s.delta} |`);
+  }
+  if (!gate.pass) {
+    lines.push('');
+    lines.push('**Must fix:**');
+    for (const f of gate.mustFix) lines.push(`- ${f}`);
+  }
+  return lines.join('\n');
+}

package/scripts/lib/frontmatter.js

@@ -0,0 +1,47 @@
+export function parseFrontmatter(src) {
+  const m = src.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) throw new Error('no frontmatter block');
+  const out = {};
+  const lines = m[1].split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const kv = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+    if (!kv) continue;
+    const [, key, rawValue] = kv;
+    const value = rawValue.trim();
+    if (value === '') {
+      const items = [];
+      let j = i + 1;
+      for (; j < lines.length; j++) {
+        const item = lines[j].match(/^\s+-\s*(.*)$/);
+        if (!item) break;
+        items.push(unquote(item[1].trim()));
+      }
+      if (items.length) {
+        out[key] = items;
+        i = j - 1;
+      } else {
+        out[key] = '';
+      }
+      continue;
+    }
+    out[key] = parseValue(value);
+  }
+  return out;
+}
+
+function parseValue(v) {
+  if (v.startsWith('[') && v.endsWith(']')) {
+    const inner = v.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(',').map((s) => unquote(s.trim()));
+  }
+  return unquote(v);
+}
+
+function unquote(s) {
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}

package/scripts/lib/harden-policy.js

@@ -0,0 +1,41 @@
+// harden-policy.js — pure loop-control for the skill-harden fix loop. No I/O, no randomness.
+import { ABS_MIN, LIFT_MIN } from './behavior-score.js';
+
+export const MAX_ROUNDS = 2;
+
+function lastPass(history) {
+  return history.length > 0 && history[history.length - 1].pass === true;
+}
+
+// { round, history, maxRounds? } -> { action: 'fix'|'stop-pass'|'stop-giveup' }
+export function decideAction({ round, history, maxRounds = MAX_ROUNDS }) {
+  if (lastPass(history)) return { action: 'stop-pass' };
+  if (round >= maxRounds) return { action: 'stop-giveup' };
+  return { action: 'fix' };
+}
+
+// history -> { kind: 'passed'|'deprecate-or-merge'|'needs-substance'|'mixed', message }
+export function recommendationFor(history) {
+  if (lastPass(history)) {
+    return { kind: 'passed', message: 'Skill passes both gates after hardening.' };
+  }
+  const last = history[history.length - 1] || { absolute: 0, lift: 0 };
+  const absOk = last.absolute >= ABS_MIN;
+  const liftOk = last.lift >= LIFT_MIN;
+  if (absOk && !liftOk) {
+    return {
+      kind: 'deprecate-or-merge',
+      message: `Output is strong (absolute ${last.absolute}) but the skill barely beats no-skill (lift ${last.lift}). It does not justify itself — consider deprecating or merging it into a sibling.`,
+    };
+  }
+  if (!absOk && liftOk) {
+    return {
+      kind: 'needs-substance',
+      message: `The skill clearly helps (lift ${last.lift}) but the output still falls short (absolute ${last.absolute}). It needs more substance, not more triggering — deepen the body/references.`,
+    };
+  }
+  return {
+    kind: 'mixed',
+    message: `Still failing after hardening (absolute ${last.absolute}, lift ${last.lift}). Re-examine scope and the capability scenario.`,
+  };
+}

package/scripts/lib/manifest.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+export function loadManifest() {
+  return JSON.parse(readFileSync(join(ROOT, 'manifest.json'), 'utf8'));
+}
+
+export function skillById(manifest, id) {
+  return manifest.skills.find((s) => s.id === id);
+}
+
+export function skillsForProfile(manifest, profile) {
+  if (profile === 'full') return manifest.skills.map((s) => s.id);
+  return manifest.skills.filter((s) => (s.profiles || []).includes(profile)).map((s) => s.id);
+}

package/scripts/lib/recommend.js

@@ -0,0 +1,36 @@
+import { skillById } from './manifest.js';
+
+const OUTCOMES = {
+  suggest: 'Un asistente que te va proponiendo lo que necesitas',
+  harness: 'Un espacio de trabajo ordenado: conecta y documenta tu empresa',
+  init: 'Arranque guiado de tu proyecto',
+  nextjs: 'Tu web (rápida y lista para Google)',
+  flutter: 'Tu app de móvil',
+  fastapi: 'Tu API / backend en Python',
+  go: 'Tu servicio backend en Go',
+  postgresdb: 'Guardar tus datos de forma fiable',
+  design: 'Que se vea bien y convierta',
+  marketing: 'Textos que venden',
+  presentations: 'Presentaciones con tu marca',
+  'course-storytelling': 'Enseñar de forma que se entienda',
+  'building-agents': 'Un agente de IA propio',
+  'secure-coding': 'Que sea seguro',
+  deployment: 'Publicarlo online',
+};
+
+export function hasOutcome(id) {
+  return Object.prototype.hasOwnProperty.call(OUTCOMES, id);
+}
+
+export function expandRecommends(manifest, chosen) {
+  const set = new Set(chosen);
+  for (const id of chosen) {
+    const s = skillById(manifest, id);
+    for (const r of s?.recommends || []) set.add(r);
+  }
+  return [...set];
+}
+
+export function toOutcomes(ids) {
+  return ids.map((id) => ({ id, label: OUTCOMES[id] || id }));
+}

package/scripts/lib/registry.js

@@ -0,0 +1,110 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { targetPaths } from '../../targets/index.js';
+import { loadManifest } from './manifest.js';
+import { readState } from './state.js';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+export function refreshRegistry({
+  cwd = process.cwd(),
+  target = 'codex',
+  home = homedir(),
+  manifest = loadManifest(),
+  catalogRoot = ROOT,
+} = {}) {
+  const dir = join(cwd, '.rsc');
+  mkdirSync(dir, { recursive: true });
+  const registry = buildRegistry({ cwd, target, home, manifest, catalogRoot });
+  writeFileSync(join(dir, 'skill-registry.json'), JSON.stringify(registry, null, 2) + '\n');
+  writeFileSync(join(dir, 'skill-registry.md'), renderRegistryMarkdown(registry));
+  return registry;
+}
+
+export function registryStatus({ cwd = process.cwd() } = {}) {
+  const path = join(cwd, '.rsc', 'skill-registry.json');
+  if (!existsSync(path)) return { exists: false, path };
+  const data = JSON.parse(readFileSync(path, 'utf8'));
+  return {
+    exists: true,
+    path,
+    version: data.version,
+    counts: data.counts || { skills: data.skills?.length || 0 },
+  };
+}
+
+export function buildRegistry({
+  cwd = process.cwd(),
+  target = 'codex',
+  home = homedir(),
+  manifest = loadManifest(),
+  catalogRoot = ROOT,
+} = {}) {
+  const installed = installedIds({ target, home, cwd });
+  const skills = manifest.skills.map((skill) => {
+    const skillPath = resolve(catalogRoot, 'skills', skill.id, 'SKILL.md');
+    const available = existsSync(skillPath);
+    return {
+      id: skill.id,
+      trigger: skill.description,
+      tags: skill.tags || [],
+      source: 'catalog',
+      path: skillPath,
+      installed: installed.has(skill.id),
+      available,
+      hash: hashSkill({ ...skill, path: skillPath, available }),
+    };
+  }).sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    version: 1,
+    target,
+    root: resolve(cwd),
+    counts: {
+      skills: skills.length,
+      installed: skills.filter((s) => s.installed).length,
+      available: skills.filter((s) => s.available).length,
+    },
+    skills,
+  };
+}
+
+export function renderRegistryMarkdown(registry) {
+  const rows = [
+    '# RSC Skill Registry',
+    '',
+    `Target: ${registry.target}`,
+    `Skills: ${registry.counts.skills} (${registry.counts.installed} installed, ${registry.counts.available} available)`,
+    '',
+    '| id | installed | available | tags | path |',
+    '| --- | --- | --- | --- | --- |',
+  ];
+  for (const skill of registry.skills) {
+    rows.push(`| ${skill.id} | ${yesNo(skill.installed)} | ${yesNo(skill.available)} | ${(skill.tags || []).join(', ')} | ${skill.path} |`);
+  }
+  return rows.join('\n') + '\n';
+}
+
+function installedIds({ target, home, cwd }) {
+  const paths = targetPaths(target, home, cwd);
+  return new Set(Object.keys(readState(paths.stateFile).skills || {}));
+}
+
+function hashSkill(skill) {
+  return createHash('sha256')
+    .update(JSON.stringify({
+      id: skill.id,
+      trigger: skill.description,
+      tags: skill.tags || [],
+      path: skill.path,
+      available: skill.available,
+    }))
+    .digest('hex')
+    .slice(0, 12);
+}
+
+function yesNo(value) {
+  return value ? 'yes' : 'no';
+}

package/scripts/lib/result-envelope.js

@@ -0,0 +1,35 @@
+const REQUIRED = [
+  'status',
+  'executive_summary',
+  'artifact',
+  'next_recommended',
+  'risk',
+  'skill_resolution',
+  'evidence',
+];
+
+export function validateResultEnvelope(envelope) {
+  const errors = [];
+  for (const key of REQUIRED) {
+    if (envelope?.[key] === undefined) errors.push(`missing ${key}`);
+  }
+  const sr = envelope?.skill_resolution;
+  if (sr !== undefined) {
+    for (const key of ['used', 'missing', 'fallback', 'compact_rules']) {
+      if (!Array.isArray(sr?.[key])) errors.push(`skill_resolution.${key} must be array`);
+    }
+  }
+  if (envelope?.evidence !== undefined && !Array.isArray(envelope.evidence)) {
+    errors.push('evidence must be array');
+  }
+  return errors;
+}
+
+export function parseResultEnvelope(text) {
+  const match = text.match(/```json\s+result-envelope\s*\n([\s\S]*?)\n```/);
+  if (!match) throw new Error('missing result-envelope json block');
+  const envelope = JSON.parse(match[1]);
+  const errors = validateResultEnvelope(envelope);
+  if (errors.length) throw new Error(`invalid result envelope: ${errors.join(', ')}`);
+  return envelope;
+}

package/scripts/lib/state.js

@@ -0,0 +1,12 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export function readState(file) {
+  if (!existsSync(file)) return { skills: {} };
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return { skills: {} }; }
+}
+
+export function writeState(file, state) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(state, null, 2) + '\n');
+}

package/scripts/lib/ui.js

@@ -0,0 +1,17 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+
+export async function ask(question) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const a = await rl.question(question);
+  rl.close();
+  return a.trim();
+}
+
+export function say(...lines) {
+  console.log(...lines);
+}
+
+export function yes(s) {
+  return /^(s|si|sí|y|yes|ok|vale|dale)/i.test(s.trim());
+}

package/scripts/reviewer-guard.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# reviewer-guard.sh — assert every rsc-review reviewer agent still carries the
+# confidence-filtering doctrine. A reviewer that loses these sections starts
+# inventing low-confidence findings and inflating severity, so this guard fails
+# the build if any required section goes missing.
+#
+# bash 3.2-safe: no mapfile, no associative arrays, no process substitution.
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+REPO_ROOT=$(cd "$SCRIPT_DIR/.." && pwd)
+AGENTS_DIR="$REPO_ROOT/plugins/rsc-review/agents"
+
+# One required heading per line (literal substrings, matched with grep -F).
+REQUIRED='### Pre-report gate
+### High and critical require proof
+### Returning zero findings is acceptable
+### Common false positives to skip
+### No severity inflation
+## Prompt defense'
+
+if [ ! -d "$AGENTS_DIR" ]; then
+  echo "reviewer-guard: agents dir not found: $AGENTS_DIR" >&2
+  exit 1
+fi
+
+agent_count=0
+fail_count=0
+
+for agent in "$AGENTS_DIR"/*.md; do
+  [ -e "$agent" ] || continue
+  agent_count=$((agent_count + 1))
+  name=$(basename "$agent")
+  missing=""
+
+  # Read the required list line by line (set -u / 3.2 safe).
+  while IFS= read -r section; do
+    [ -n "$section" ] || continue
+    if ! grep -qF "$section" "$agent"; then
+      missing="$missing
+    - missing: $section"
+    fi
+  done <<EOF
+$REQUIRED
+EOF
+
+  if [ -n "$missing" ]; then
+    echo "FAIL $name$missing"
+    fail_count=$((fail_count + 1))
+  else
+    echo "PASS $name"
+  fi
+done
+
+echo
+if [ "$agent_count" -eq 0 ]; then
+  echo "reviewer-guard: no agent files found in $AGENTS_DIR" >&2
+  exit 1
+fi
+
+if [ "$fail_count" -ne 0 ]; then
+  echo "reviewer-guard: $fail_count/$agent_count agent(s) FAILED." >&2
+  exit 1
+fi
+
+echo "reviewer-guard: all $agent_count reviewer agent(s) PASS."

package/scripts/rsc.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { loadManifest, skillsForProfile } from './lib/manifest.js';
+import { detectTarget } from '../targets/index.js';
+import { detectRepo } from './detect-repo.js';
+import { rank } from './consult.js';
+import { expandRecommends, toOutcomes, hasOutcome } from './lib/recommend.js';
+import { applyInstall, listInstalled, uninstall } from './install-apply.js';
+import { doctor } from './doctor.js';
+import { ask, say, yes } from './lib/ui.js';
+import { refreshRegistry, registryStatus } from './lib/registry.js';
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+
+function flag(name) {
+  const i = argv.indexOf(`--${name}`);
+  return i >= 0 ? (argv[i + 1] || true) : undefined;
+}
+
+async function recommendIds(query, { labeledOnly = false } = {}) {
+  const m = loadManifest();
+  const repo = detectRepo();
+  const ranked = query ? (await rank(m, query)).map((r) => r.id) : [];
+  let base = [...new Set(query ? [...ranked, ...repo] : repo)].filter((id) => id !== 'suggest');
+  if (labeledOnly) base = base.filter(hasOutcome);
+  base = base.slice(0, 4);
+  let out = expandRecommends(m, base).filter((id) => id !== 'suggest');
+  if (labeledOnly) out = out.filter(hasOutcome);
+  return out.slice(0, 6);
+}
+
+async function wizard() {
+  say('Hola 👋 ¿Qué quieres hacer?');
+  const goal = await ask('> ');
+  const ids = await recommendIds(goal, { labeledOnly: true });
+  if (!ids.length) {
+    say('No estoy seguro de qué necesitas. Prueba a describir tu proyecto con más detalle.');
+    return;
+  }
+  say('\nHe preparado esto para ti:');
+  for (const o of toOutcomes(ids)) say(`   • ${o.label}`);
+  const ok = yes(await ask('\n¿Lo monto? (sí / no) > '));
+  if (!ok) {
+    say('Sin problema. Cuando quieras: npx rsc');
+    return;
+  }
+  const target = detectTarget();
+  await applyInstall({ skillIds: [...new Set(['suggest', ...ids])], target });
+  say('\n✅ Listo. Abre tu editor y empieza a pedir cosas en tu idioma.');
+  say('   💡 Para añadir más cuando lo necesites, vuelve a escribir: npx rsc');
+}
+
+async function main() {
+  const target = flag('target') || detectTarget();
+  switch (cmd) {
+    case undefined:
+      return wizard();
+    case 'add':
+      await applyInstall({ skillIds: [...new Set(['suggest', ...argv.slice(1)])], target });
+      return void say(`✅ Instalado: ${argv.slice(1).join(', ')}`);
+    case 'install': {
+      const profile = flag('profile') || 'minimal';
+      const without = argv.filter((a, i) => argv[i - 1] === '--without');
+      let ids = skillsForProfile(loadManifest(), profile);
+      ids = [...new Set(['suggest', ...ids])].filter((id) => !without.includes(id));
+      await applyInstall({ skillIds: ids, target });
+      return void say(`✅ Perfil '${profile}' instalado en ${target} (${ids.length} skills)`);
+    }
+    case 'consult': {
+      const ids = await recommendIds(argv.slice(1).join(' '));
+      if (!ids.length) return void say('(sin recomendaciones)');
+      for (const o of toOutcomes(ids)) say(`${o.id}\t${o.label}`);
+      return;
+    }
+    case 'list':
+      return void say(listInstalled({ target }).join('\n') || '(nada instalado)');
+    case 'doctor':
+      return void say(JSON.stringify(doctor({ target }), null, 2));
+    case 'registry': {
+      const sub = argv[1];
+      if (sub === 'refresh') {
+        const registry = refreshRegistry({ target });
+        say(`✅ Registry actualizado: .rsc/skill-registry.md (${registry.counts.skills} skills)`);
+        return;
+      }
+      if (sub === 'status') {
+        say(JSON.stringify(registryStatus(), null, 2));
+        return;
+      }
+      say('Usa: npx rsc registry refresh | registry status');
+      return;
+    }
+    case 'uninstall': {
+      const dry = argv.includes('--dry-run');
+      const ids = argv.slice(1).filter((a) => !a.startsWith('--'));
+      const removed = await uninstall({ skillIds: ids, target, dryRun: dry });
+      return void say((dry ? 'Se borraría:\n' : 'Borrado:\n') + (removed.join('\n') || '(nada)'));
+    }
+    default:
+      say(`rsc: comando desconocido '${cmd}'.`);
+      say('Usa: npx rsc | add <id...> | install --profile <p> | consult "<texto>" | list | registry refresh | doctor | uninstall <id>');
+  }
+}
+
+main().catch((e) => {
+  console.error('rsc error:', e.message);
+  process.exit(1);
+});

package/scripts/skill-behavior-eval.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// skill-behavior-eval.js — turn the behavior workflow's raw JSON into a scorecard.
+// Usage:
+//   node scripts/skill-behavior-eval.js --score <raw.json>   (or pipe raw JSON on stdin with -)
+// Exits 0 if the behavioral gate passes, 1 if it fails, 2 on usage/parse error.
+
+import { readFileSync } from 'node:fs';
+import { scoreFromRaw, formatScorecard } from './lib/behavior-score.js';
+
+function readInput(argPath) {
+  if (argPath && argPath !== '-') return readFileSync(argPath, 'utf8');
+  return readFileSync(0, 'utf8'); // stdin
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args[0] !== '--score') {
+    process.stderr.write('usage: skill-behavior-eval.js --score <raw.json|->\n');
+    process.exit(2);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readInput(args[1]));
+  } catch (e) {
+    process.stderr.write(`parse error: ${e.message}\n`);
+    process.exit(2);
+  }
+  const scored = scoreFromRaw(raw);
+  process.stdout.write(formatScorecard(scored) + '\n');
+  process.exit(scored.gate.pass ? 0 : 1);
+}
+
+main();