@ericrisco/rsc 0.1.5

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/domains.js

@@ -0,0 +1,30 @@
+// domains.js — the catalog grouped by what the user is trying to do.
+// Single source for the CLI's manual picker. Every skill id in the manifest
+// MUST appear in exactly one domain (enforced by tests/domains.test.js) so the
+// catalog grows deliberately, never silently.
+
+export const DOMAINS = [
+  { title: 'Core & control plane', ids: ['init', 'harness', 'orient', 'suggest', 'author-skill', 'sdd-init'] },
+  { title: 'Spec-Driven Development', ids: ['sdd', 'constitution', 'specify', 'clarify', 'plan', 'tasks', 'analyze', 'implement', 'verify', 'review', 'ship', 'debug', 'worktrees', 'parallel'] },
+  { title: 'Run a business', ids: ['finance-ops', 'invoicing', 'bookkeeping', 'pricing', 'sales-pipeline', 'lead-gen', 'cold-outreach', 'proposals', 'contracts', 'customer-support', 'client-onboarding', 'retention', 'hiring', 'people-ops', 'inventory', 'logistics-ops', 'procurement', 'meeting-notes', 'sop-builder', 'project-ops'] },
+  { title: 'Raise & model money', ids: ['pitch-deck', 'investor-materials', 'financial-model', 'fundraising', 'unit-economics', 'grants'] },
+  { title: 'Legal, privacy & compliance', ids: ['gdpr-privacy', 'terms-conditions', 'compliance', 'data-policy', 'ip-trademark'] },
+  { title: 'Market & brand', ids: ['marketing', 'seo-geo', 'content-engine', 'social-publisher', 'brand-voice', 'brand-identity', 'newsletter', 'landing-copy', 'ads', 'article-writing', 'case-studies', 'video-shorts', 'podcast', 'market-research', 'competitor-watch', 'press-kit', 'community', 'webinar', 'review-management'] },
+  { title: 'Grow a channel (YouTube / TikTok / Reels / LinkedIn / Medium)', ids: ['youtube-api', 'youtube-strategy', 'youtube-ideation', 'youtube-thumbnails', 'youtube-packaging', 'remotion-video', 'tiktok-api', 'instagram-api', 'shortform-strategy', 'shortform-ideation', 'shortform-packaging', 'shortform-editing', 'linkedin-api', 'linkedin-strategy', 'linkedin-content', 'linkedin-carousels', 'linkedin-outreach', 'medium-writing', 'medium-publishing', 'medium-strategy'] },
+  { title: 'Connect & automate', ids: ['stripe', 'email-connector', 'google-workspace', 'notion-connector', 'whatsapp-telegram', 'automation-flows', 'api-connector-builder', 'webhooks', 'data-scraper', 'spreadsheet-ops', 'calendar-scheduling', 'document-processing', 'e-signature'] },
+  { title: 'Data & analytics', ids: ['analytics', 'dashboard', 'kpi-framework', 'reporting', 'ab-testing', 'forecasting', 'data-cleaning', 'business-intelligence'] },
+  { title: 'AI — build it in', ids: ['building-agents', 'rag', 'embeddings-search', 'prompt-engineering', 'llm-pipeline', 'agent-eval', 'chatbot', 'ai-media', 'replicate-images', 'structured-extraction', 'agent-safety', 'cost-tracking'] },
+  { title: 'AI — run it on', ids: ['replicate', 'runpod', 'modal', 'huggingface', 'ollama', 'together-fireworks', 'fal'] },
+  { title: 'Languages', ids: ['typescript', 'python', 'java', 'csharp-dotnet', 'php', 'ruby', 'cpp', 'elixir', 'bash-scripting', 'sql', 'go'] },
+  { title: 'Frameworks & app stacks', ids: ['fastapi', 'nextjs', 'react', 'react-native', 'vue-nuxt', 'angular', 'svelte', 'astro', 'solid-js', 'htmx', 'nodejs', 'nestjs', 'django', 'laravel', 'rails', 'spring-boot', 'phoenix', 'flutter', 'swift-ios', 'kotlin-android', 'compose-multiplatform', 'expo', 'tauri', 'electron', 'rust', 'wordpress', 'shopify', 'no-code-app', 'chrome-extension', 'api-design'] },
+  { title: 'Databases & data layer', ids: ['postgresdb', 'mysql', 'mongodb', 'redis', 'supabase', 'neon', 'planetscale', 'sqlite-turso', 'prisma-orm', 'drizzle-orm', 'firebase', 'dynamodb', 'vector-db', 'clickhouse-analytics', 'duckdb', 'db-migrations', 'backups'] },
+  { title: 'Ship & operate — platforms', ids: ['vercel', 'netlify', 'cloudflare', 'railway', 'render', 'fly-io', 'coolify', 'hetzner', 'digitalocean', 'aws-essentials', 'gcp-essentials'] },
+  { title: 'Ship & operate — devops', ids: ['docker', 'github-actions', 'git-workflow', 'domains-dns', 'monitoring', 'email-deliverability', 'scaling', 'deployment'] },
+  { title: 'Ship & operate — quality & security', ids: ['code-review', 'security-scan', 'secure-coding', 'testing-py', 'testing-web', 'testing-go', 'e2e-testing', 'accessibility', 'performance', 'error-handling', 'observability'] },
+  { title: 'Design & content craft', ids: ['design', 'presentations', 'course-storytelling', 'course-builder', 'technical-writing', 'translation-l10n'] },
+  { title: 'Knowledge & meta', ids: ['knowledge-ops', 'codebase-onboarding', 'research-ops', 'decision-records', 'continuous-learning', 'skill-scout', 'context-budget'] },
+];
+
+export function allDomainIds() {
+  return DOMAINS.flatMap((d) => d.ids);
+}

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: 'An assistant that proposes what you need as you go',
+  harness: 'A tidy workspace: connect and document your company',
+  init: 'Guided project bootstrap',
+  nextjs: 'Your website (fast, ready for Google)',
+  flutter: 'Your mobile app',
+  fastapi: 'Your API / Python backend',
+  go: 'Your Go backend service',
+  postgresdb: 'Store your data reliably',
+  design: 'Make it look good and convert',
+  marketing: 'Copy that sells',
+  presentations: 'On-brand presentations',
+  'course-storytelling': 'Teach so it actually lands',
+  'building-agents': 'Your own AI agent',
+  'secure-coding': 'Make it secure',
+  deployment: 'Put it 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,159 @@
+import { createInterface, emitKeypressEvents } from 'node:readline';
+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|sure|yeah)/i.test(s.trim());
+}
+
+// ---------------------------------------------------------------------------
+// Interactive arrow-key / space TUI (zero dependencies).
+// Falls back to a typed-number prompt when there is no interactive TTY
+// (CI, pipes, dumb terminals) so scripts and tests never hang.
+// ---------------------------------------------------------------------------
+
+function interactive() {
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+
+const C = {
+  dim: (s) => `\x1b[2m${s}\x1b[22m`,
+  bold: (s) => `\x1b[1m${s}\x1b[22m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[39m`,
+  green: (s) => `\x1b[32m${s}\x1b[39m`,
+};
+
+// ASCII wordmark shown at the top of the wizard.
+export function banner() {
+  const tty = Boolean(stdout.isTTY);
+  const art = [
+    '',
+    ' ██████╗ ███████╗ ██████╗',
+    ' ██╔══██╗██╔════╝██╔════╝',
+    ' ██████╔╝███████╗██║     ',
+    ' ██╔══██╗╚════██║██║     ',
+    ' ██║  ██║███████║╚██████╗',
+    ' ╚═╝  ╚═╝╚══════╝ ╚═════╝',
+  ];
+  for (const l of art) say(tty ? C.cyan(l) : l);
+  say((tty ? C.dim('  231 skills · one CLI · zero bloat') : '  231 skills · one CLI · zero bloat'));
+}
+
+// Repaint a fixed block of lines in place (cursor ends just below the block).
+function makePainter() {
+  let height = 0;
+  return (lines) => {
+    if (height) stdout.write(`\x1b[${height}A`);
+    stdout.write(lines.map((l) => `\x1b[2K${l}`).join('\n') + '\n');
+    height = lines.length;
+  };
+}
+
+function captureKeys(onKey) {
+  emitKeypressEvents(stdin);
+  if (stdin.isTTY) stdin.setRawMode(true);
+  stdin.resume();
+  const handler = (str, key) => onKey(str, key || {});
+  stdin.on('keypress', handler);
+  return () => {
+    stdin.off('keypress', handler);
+    if (stdin.isTTY) stdin.setRawMode(false);
+    stdin.pause();
+  };
+}
+
+// Single choice: ↑↓ to move, Enter to pick. options: [{ key, label }].
+function tuiSelect(question, options) {
+  return new Promise((resolve) => {
+    let i = 0;
+    const paint = makePainter();
+    const render = () => paint([
+      C.bold(question),
+      C.dim('  ↑↓ move · enter select'),
+      ...options.map((o, idx) =>
+        idx === i ? `${C.cyan('❯')} ${C.cyan(o.label)}` : `  ${o.label}`),
+    ]);
+    render();
+    const stop = captureKeys((str, key) => {
+      if (key.name === 'up' || key.name === 'k') { i = (i - 1 + options.length) % options.length; render(); }
+      else if (key.name === 'down' || key.name === 'j') { i = (i + 1) % options.length; render(); }
+      else if (key.name === 'return') { stop(); resolve(options[i].key); }
+      else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) { stop(); stdout.write('\n'); process.exit(130); }
+    });
+  });
+}
+
+// Multi-select: ↑↓ move, space toggle, a = all, enter confirm. Viewport scrolls.
+function tuiChecklist(title, items) {
+  return new Promise((resolve) => {
+    const VISIBLE = Math.min(items.length, 12);
+    const sel = new Set();
+    let cur = 0; let top = 0;
+    const paint = makePainter();
+    const render = () => {
+      if (cur < top) top = cur;
+      if (cur >= top + VISIBLE) top = cur - VISIBLE + 1;
+      const rows = [];
+      for (let r = top; r < top + VISIBLE; r++) {
+        const it = items[r];
+        const box = sel.has(r) ? C.green('◉') : '◯';
+        const line = `${box} ${it.label}`;
+        rows.push(r === cur ? `${C.cyan('❯')} ${C.cyan(line)}` : `  ${line}`);
+      }
+      const more = items.length > VISIBLE ? C.dim(`  (${cur + 1}/${items.length})`) : '';
+      paint([
+        C.bold(title),
+        C.dim('  ↑↓ move · space toggle · a all · enter confirm') + more,
+        ...rows,
+      ]);
+    };
+    render();
+    const stop = captureKeys((str, key) => {
+      if (key.name === 'up' || key.name === 'k') { cur = (cur - 1 + items.length) % items.length; render(); }
+      else if (key.name === 'down' || key.name === 'j') { cur = (cur + 1) % items.length; render(); }
+      else if (key.name === 'space') { sel.has(cur) ? sel.delete(cur) : sel.add(cur); render(); }
+      else if (str === 'a') { if (sel.size === items.length) sel.clear(); else items.forEach((_, idx) => sel.add(idx)); render(); }
+      else if (key.name === 'return') { stop(); resolve([...sel].sort((x, y) => x - y).map((idx) => items[idx].id)); }
+      else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) { stop(); stdout.write('\n'); process.exit(130); }
+    });
+  });
+}
+
+// Public: single-choice menu. options: [{ key, label }]. Returns the chosen key.
+export async function select(question, options) {
+  if (interactive()) return tuiSelect(question, options);
+  // Fallback: typed number.
+  say(question);
+  options.forEach((o, i) => say(`  ${i + 1}) ${o.label}`));
+  const a = (await ask('> ')).toLowerCase();
+  const n = parseInt(a, 10);
+  if (n >= 1 && n <= options.length) return options[n - 1].key;
+  const byKey = options.find((o) => o.key.toLowerCase() === a);
+  return byKey ? byKey.key : null;
+}
+
+// Public: multi-select. items: array of strings or { id, label }. Returns ids.
+export async function pickFrom(title, items) {
+  const norm = items.map((it) => (typeof it === 'string' ? { id: it, label: it } : it));
+  if (interactive()) return tuiChecklist(title, norm);
+  // Fallback: comma-separated numbers.
+  say(`\n${title}`);
+  norm.forEach((it, i) => say(`  ${String(i + 1).padStart(2)}) ${it.label}`));
+  say('   Comma-separated numbers (e.g. 1,3,4), "all", or Enter for none.');
+  const a = (await ask('> ')).trim();
+  if (!a) return [];
+  if (/^(all|todo|todas)$/i.test(a)) return norm.map((it) => it.id);
+  return [...new Set(
+    a.split(',').map((s) => parseInt(s.trim(), 10)).filter((x) => x >= 1 && x <= norm.length).map((x) => norm[x - 1].id),
+  )];
+}

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."