@ericrisco/rsc 1.0.22 → 1.0.23

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.22",
+  "version": "1.0.23",
   "counts": {
     "skills": 264
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {

package/scripts/install-apply.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { rmSync, existsSync, cpSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { planInstall } from './install-plan.js';
 import { targetPaths, writeSkill, wireHook, unwireHook, baseDir, TARGET_IDS } from '../targets/index.js';
-import { targetHasAgents, writeDeveloperAgent, removeDeveloperAgent, developerAgentPath } from '../targets/agents.js';
+import { targetHasAgents, writeAgents, removeAgents, agentPath, agentNames } from '../targets/agents.js';
 import { readState, writeState } from './lib/state.js';
 import { createBackup } from './lib/backups.js';
 
@@ -70,7 +70,7 @@ function managedPathsForInstall({ skillIds, target, home, cwd }) {
   const paths = targetPaths(target, home, cwd);
   const plan = planInstall({ skillIds, target, home, cwd });
   const out = [paths.stateFile, versionFile(cwd), baseVersionsFile(cwd)];
-  if (targetHasAgents(target)) out.push(developerAgentPath(target, cwd), join(cwd, '.rsc', 'developer.json'));
+  if (targetHasAgents(target)) out.push(...agentNames().map((n) => agentPath(target, cwd, n)), join(cwd, '.rsc', 'developer.json'));
   for (const step of plan) {
     if (step.kind === 'skill') {
       out.push(step.to, baseDir(step.id, cwd));
@@ -103,11 +103,18 @@ export async function applyInstall({ skillIds, target, home, cwd = process.cwd()
     }
   }
   writeBaseVersions(cwd, baseVersions);
-  // Install the `developer` subagent for targets that support file-based agents (Claude
-  // Code, Cursor, OpenCode, Gemini, Copilot, Junie, Kiro, Codex). It runs at the balanced
-  // tier by default (never light/Haiku); the tier lives in .rsc/developer.json, set by
-  // `init` at onboarding and honored on every (re)install/sync.
-  if (targetHasAgents(target)) state.agents = writeDeveloperAgent(target, cwd).length ? ['developer'] : [];
+  // Install the catalog's subagents for targets that support file-based agents (Claude
+  // Code, Cursor, OpenCode, Gemini, Copilot, Junie, Kiro, Codex): `developer` plus the three
+  // adversarial refuter lenses `review` dispatches at tier 2. They run at the balanced tier
+  // by default (never light/Haiku); the tier lives in .rsc/developer.json, set by `init` at
+  // onboarding and honored on every (re)install/sync.
+  //
+  // The recorded names come from what was WRITTEN, not from a hardcoded list: a state entry
+  // naming an agent whose file never landed answers "you have it" for something absent.
+  if (targetHasAgents(target)) {
+    const written = writeAgents(target, cwd);
+    state.agents = written.map((f) => basename(f).split('.')[0]);
+  }
   state.version = CLI_VERSION;
   writeState(paths.stateFile, state);
   mkdirSync(dirname(versionFile(cwd)), { recursive: true });
@@ -214,9 +221,12 @@ export async function purge({ home, cwd = process.cwd(), withDocs = false, dryRu
     }
     // unwireHook mutates files, so only run it for real (dry runs skip it).
     if (!dryRun) removed.push(...unwireHook(target, paths));
-    // Remove the installed developer subagent (agent-capable targets only).
-    const agentFile = developerAgentPath(target, cwd);
-    if (agentFile) drop(agentFile);
+    // Remove the subagents this catalog installed — and only those. An uninstaller that takes
+    // an agent the user wrote by hand is worse than one that leaves residue.
+    for (const n of agentNames()) {
+      const agentFile = agentPath(target, cwd, n);
+      if (agentFile) drop(agentFile);
+    }
   }
   drop(join(cwd, '.rsc'), true);
   if (withDocs) drop(join(cwd, '02-DOCS'), true);

package/targets/agents.js

@@ -1,5 +1,10 @@
-// rsc developer agent — installed with the harness for every target that supports
-// file-based subagents with a per-agent model. The agent runs at the `balanced` tier
+// rsc agent registry — the agents installed with the harness for every target that supports
+// file-based subagents with a per-agent model.
+//
+// This file shipped ONE agent with its name, description and body as module constants. Adding a
+// second was therefore not "copy a block": it was turning the file into a registry without breaking
+// the `developer` installs already deployed to users. The registry is the work; the refuters are its
+// first client. See 02-DOCS/wiki/sdd/specs/refuter-agent.md. The agent runs at the `balanced` tier
 // (never `light`/Haiku): Sonnet for Anthropic-backed tools, the provider's mid model
 // elsewhere. The chosen tier (balanced default, or heavy) lives in `.rsc/developer.json`,
 // written by `init` at onboarding and read here so re-syncs honor it.
@@ -33,9 +38,31 @@ const AGENT_TARGETS = {
 export const AGENT_TARGET_IDS = Object.keys(AGENT_TARGETS);
 export function targetHasAgents(target) { return Boolean(AGENT_TARGETS[target]); }
 
-const NAME = 'developer';
-const DESC = 'Implementation worker: turns an approved spec+plan into working, tested code under strict TDD (red->green->refactor), one task at a time. The rsc SDD fan-out/implementation hand.';
-const BODY = `You are the **developer** subagent for this project — the hands of the rsc SDD chain. You execute a planned, approved task into working, tested code. You do NOT design features.
+// The contract every refuter shares, in ONE place. Three lens files each carry the lens inside them
+// (decided in clarify 2026-08-18: a lens passed as a parameter reintroduces the
+// does-anyone-remember dependency this whole spec exists to remove) — but P5 says length is a cost,
+// so the contract they share is composed, not written three times.
+const REFUTER_CONTRACT = `Your mandate is to **refute readiness**, not confirm it. A reviewer looking for confirmation finds confirmation; the asymmetry is the point.
+
+**You get exactly four inputs, and nothing else:**
+1. The task contract — the original request **plus every scope change a human explicitly approved since**. Without the approved changes, a legitimate scope revision reads as a spec gap and you will report a confident false positive.
+2. The approved spec.
+3. The exact source state (commit SHA, or a tree hash when git is absent). A verdict attaches to the state you saw, not to the project.
+4. The entry point — the one command that reruns the checks.
+
+**You do NOT get** the builder's conversation, reasoning, defences, or draft verdict. If a claim needs the builder's justification to stand, it is not proven.
+
+**Blind first, compare second.** Record what you attacked and what you found BEFORE you are shown the builder's conclusions. Only then may you compare and add findings; the blind record is append-only after that, never rewritten. Skip this and your fresh context is spent confirming their framing, which is the one thing it was bought to avoid.
+
+**The attack list is the deliverable, not just the findings.** "Nothing found" without saying where you looked is indistinguishable from not having looked.
+
+**A finding blocks only if it is caused by this change, is severe, and carries evidence** — a repro or a concrete failure scenario. A suspicion without one is a question, and questions do not block. You fix nothing: findings return through the normal loop, and a SPEC gap goes to the human, never to the builder to self-amend.`;
+
+const AGENTS = [
+  {
+    name: 'developer',
+    desc: 'Implementation worker: turns an approved spec+plan into working, tested code under strict TDD (red->green->refactor), one task at a time. The rsc SDD fan-out/implementation hand.',
+    body: `You are the **developer** subagent for this project — the hands of the rsc SDD chain. You execute a planned, approved task into working, tested code. You do NOT design features.
 
 - Work **test-first**: smallest failing test (RED), least code to pass it (GREEN), then refactor on green. A test that never failed proves nothing.
 - One task at a time; keep the diff to that task's scope — no "while I'm here".
@@ -43,7 +70,54 @@ const BODY = `You are the **developer** subagent for this project — the hands
 - If there is no approved spec + plan for non-trivial feature work, STOP and route to \`specify\` — do not write feature code.
 - Log non-obvious decisions to \`02-DOCS/wiki/sdd/decisions.md\`. Report your diff + test output at the end.
 
-Full discipline lives in the \`implement\` skill.`;
+Full discipline lives in the \`implement\` skill.`,
+  },
+  {
+    name: 'refuter-correctness',
+    desc: 'Adversarial reviewer, correctness lens: attacks a green diff for boundary and error-path defects, and demands that any home-grown gate prove it can both fail and pass. Fresh context, mandate to refute.',
+    body: `You are the **correctness** refuter for this project — one of three adversarial lenses ${'`review`'} dispatches at tier 2. What matters is not the number of lenses but their **diversity**: the worst defect this panel ever found was found by the privacy lens, which was not looking for it.
+
+${REFUTER_CONTRACT}
+
+**Your lens — correctness on the boundaries, not the happy path:** off-by-one, null/empty/zero, error paths swallowed, races, the wrong operator, a value that is correct in one function and unchecked in its twin.
+
+**And the lens this panel was missing:** when the change adds or touches a **gate, checker or guard**, ask it in BOTH directions.
+- Can it fail? Feed it a known-bad input and watch it fail. A gate nobody has seen fail is not a gate.
+- **Can it pass?** Feed it a known-good input and watch it pass. Over-blocking is not the safe side — a gate that fires on correct work gets muted, worked around, or wedges the pipeline that depends on it, and it is *harder* to notice because it arrives dressed as diligence.
+- Watch for a check that matches **text** where it should match **structure**: "the path appears in the string" is not "the write targets that location". That exact mistake shipped twice in one day here.`,
+  },
+  {
+    name: 'refuter-security',
+    desc: 'Adversarial reviewer, security and privacy lens: hunts untrusted input reaching a sink, authz gaps, leaked secrets and data escaping where it should not. Fresh context, mandate to refute.',
+    body: `You are the **security and privacy** refuter for this project — one of three adversarial lenses ${'`review`'} dispatches at tier 2. Your value is that you are not looking where the others look: the worst defect this panel ever found was found by this lens, chasing something else entirely.
+
+${REFUTER_CONTRACT}
+
+**Your lens:** untrusted input reaching a sink (injection, SSRF, path traversal), authorization gaps (authenticated is not authorized), secrets in the diff or in config, and **data leaving where it should not** — a log line, an error message, a file written outside its zone, a payload sent to a third party.
+
+**Follow the trail rather than the checklist.** When something looks merely untidy — a file in an odd place, a path that repeats — ask who else cares about that location before dismissing it. That is how this lens found the worst one.`,
+  },
+  {
+    name: 'refuter-tests',
+    desc: 'Adversarial reviewer, tests-as-evidence lens: tries to make the suite pass wrongly, invents mutants the builder did not choose, and checks the spec-to-test mapping in both directions. Fresh context, mandate to refute.',
+    body: `You are the **tests-as-evidence** refuter for this project — one of three adversarial lenses ${'`review`'} dispatches at tier 2.
+
+${REFUTER_CONTRACT}
+
+**Your lens — try to make the suite pass wrongly:** implementation keyed to test inputs, mocks swallowing the logic under test, assertions that cannot fail, coverage that touches lines without asserting anything.
+
+**Invent mutants the builder did not choose.** Their mutant list encodes their blind spots. Watch for tests that pin less than they claim — a boundary pinned in one function and not in its twin, a magnitude left free while its boundary is fixed, an assertion satisfied by a caller that never arrived. **Before reporting a surviving mutant, prove it diverges:** construct a concrete input where mutant and original disagree. A survivor you cannot make disagree is an equivalent mutant, and reporting it sends someone to write a test that asserts non-behaviour.
+
+**Check the mapping both ways:** every acceptance criterion needs a falsification procedure that can be made to fail, and every test should trace to something someone asked for.`,
+  },
+];
+
+// Back-compat: the tier file and its reader are named for `developer` because that is what they
+// configure. The refuters run at the same tier — a deliberate, reversible default: nobody has measured
+// whether a heavier model finds more here, and silently tripling tier-2 cost on an unmeasured hunch is
+// the wrong way to find out.
+const byName = (name) => AGENTS.find((a) => a.name === name);
+export const agentNames = () => AGENTS.map((a) => a.name);
 
 // `.rsc/developer.json` — the chosen tier (balanced default; never light). `init` writes
 // it on the onboarding answer; the installer reads it so every (re)install/sync matches.
@@ -60,39 +134,57 @@ export function writeDeveloperTier(cwd, tier) {
   return t;
 }
 
-function renderMd(spec, model) {
-  const fm = ['---', `name: ${NAME}`, `description: "${DESC}"`, `model: ${model}`];
+function renderMd(spec, model, agent) {
+  const fm = ['---', `name: ${agent.name}`, `description: "${agent.desc}"`, `model: ${model}`];
   if (spec.mode) fm.push(`mode: ${spec.mode}`);
   fm.push('---', '');
-  return `${fm.join('\n')}${BODY}\n`;
+  return `${fm.join('\n')}${agent.body}\n`;
 }
-const renderJson = (model) => `${JSON.stringify({ name: NAME, description: DESC, model, prompt: BODY }, null, 2)}\n`;
-function renderToml(model) {
+const renderJson = (model, agent) => `${JSON.stringify({ name: agent.name, description: agent.desc, model, prompt: agent.body }, null, 2)}\n`;
+function renderToml(model, agent) {
   const esc = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
   // body as a TOML multiline LITERAL string ('''…''') — no escape processing.
-  return `name = "${NAME}"\ndescription = "${esc(DESC)}"\nmodel = "${model}"\ndeveloper_instructions = '''\n${BODY}\n'''\n`;
+  return `name = "${agent.name}"\ndescription = "${esc(agent.desc)}"\nmodel = "${model}"\ndeveloper_instructions = '''\n${agent.body}\n'''\n`;
 }
 
-export function developerAgentPath(target, cwd) {
+export function agentPath(target, cwd, name = 'developer') {
   const spec = AGENT_TARGETS[target];
-  return spec ? join(cwd, ...spec.dir.split('/'), `${NAME}${spec.ext}`) : null;
+  return spec ? join(cwd, ...spec.dir.split('/'), `${name}${spec.ext}`) : null;
 }
 
-export function writeDeveloperAgent(target, cwd, tier = readDeveloperTier(cwd)) {
+export function writeAgents(target, cwd, tier = readDeveloperTier(cwd)) {
   const spec = AGENT_TARGETS[target];
   if (!spec) return [];
   const model = spec.model(tier);
-  const content = spec.format === 'json' ? renderJson(model)
-    : spec.format === 'toml' ? renderToml(model)
-      : renderMd(spec, model);
-  const path = developerAgentPath(target, cwd);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content);
-  return [path];
+  const written = [];
+  for (const agent of AGENTS) {
+    const content = spec.format === 'json' ? renderJson(model, agent)
+      : spec.format === 'toml' ? renderToml(model, agent)
+        : renderMd(spec, model, agent);
+    const path = agentPath(target, cwd, agent.name);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+    written.push(path);
+  }
+  return written;
 }
 
-export function removeDeveloperAgent(target, cwd) {
-  const path = developerAgentPath(target, cwd);
-  if (path && existsSync(path)) { rmSync(path, { force: true }); return [path]; }
-  return [];
+/**
+ * Remove only the agents this catalog ships. An uninstaller that takes an agent the user wrote by hand
+ * is worse than one that leaves residue.
+ */
+export function removeAgents(target, cwd) {
+  const removed = [];
+  for (const agent of AGENTS) {
+    const path = agentPath(target, cwd, agent.name);
+    if (path && existsSync(path)) { rmSync(path, { force: true }); removed.push(path); }
+  }
+  return removed;
 }
+
+// ── back-compat aliases. Kept because `developer` is already installed in user repos and in
+// capabilities.js's spec derivation; renaming their imports is not worth breaking a deployed install.
+export const developerAgentPath = (target, cwd) => agentPath(target, cwd, 'developer');
+export const writeDeveloperAgent = (target, cwd, tier = readDeveloperTier(cwd)) => writeAgents(target, cwd, tier);
+export const removeDeveloperAgent = (target, cwd) => removeAgents(target, cwd);
+export { byName as agentByName };