@ericrisco/rsc 1.1.4 → 1.1.6

package/skills/variant-explorer/evals/cases.yaml

@@ -0,0 +1,38 @@
+skill: variant-explorer
+
+should_trigger:
+  - prompt: "Show me a few versions of this onboarding and I'll pick one."
+    why: "The canonical phrasing: options to choose from, not an answer."
+  - prompt: "Give me three directions for how this could work before we commit."
+    why: "Explicit divergence ahead of an expensive decision."
+  - prompt: "Enséñame varias opciones de cómo montar el checkout, que ya elijo yo."
+    why: "Same request in Spanish; the trigger is the ask for options."
+  - prompt: "I can't decide between a wizard and a single page. Can I see both?"
+    why: "Two named approaches where seeing them is what settles it."
+  - prompt: "What are some different ways we could structure this dashboard?"
+    why: "Open-ended exploration of structural decisions, which is exactly divergence."
+  - prompt: "Before we build it, I want to compare a couple of approaches side by side."
+    why: "Comparability is the property this skill guarantees."
+
+should_not_trigger:
+  - prompt: "Review this checkout screen and grade it."
+    route_to: "design-loop"
+    why: "Judging one finished thing is critique, the opposite of divergence."
+  - prompt: "We need to agree what this feature is for before anyone builds it."
+    route_to: "specify"
+    why: "A missing WHAT/WHY is a spec problem; options would be premature."
+  - prompt: "Build the pricing page we agreed on last week."
+    route_to: "design"
+    why: "The decision is already made; manufacturing options would waste the time this skill is meant to save."
+  - prompt: "Which colour should the primary button be?"
+    route_to: "design"
+    why: "Cheap and reversible, and a detail rather than a decision — the explicit non-case here."
+  - prompt: "Run an A/B test to see which headline converts better."
+    route_to: "ab-testing"
+    why: "Measuring a winner with users is experimentation, not showing a human candidates to choose from."
+
+capability:
+  - prompt: "Give me three options for this signup flow. Make sure they are actually different, not the same thing restyled."
+    why: "Goes straight at the failure mode this skill exists to prevent, and demands the decision behind each be nameable."
+  - prompt: "Here are three variants I made. Are these real alternatives or the same idea three times?"
+    why: "Applies the one rule as a test on someone else's set, which is where it is hardest and most useful."

package/targets/_md-block.js

@@ -9,6 +9,9 @@ import { linkOrCopy } from './index.js';
 // multiple assistants sharing one file never duplicate it.
 const MARK_START = '<!-- rsc-suggest:start -->';
 const MARK_END = '<!-- rsc-suggest:end -->';
+// The exact separator wireHook writes before an appended block, so unwireHook can take
+// back precisely what it gave and leave the rest of the file untouched.
+const SEAM = '\n\n';
 
 export function writeSkill(id, fromDir, toPath) {
   return linkOrCopy(fromDir, toPath);
@@ -21,7 +24,9 @@ export function wireHook(paths, sourceMd) {
   if (doc.includes(MARK_START)) {
     doc = doc.replace(new RegExp(`${MARK_START}[\\s\\S]*?${MARK_END}`), block);
   } else {
-    doc += `\n\n${block}\n`;
+    // Append with a fixed seam, and record nothing else. unwireHook removes exactly this
+    // seam and this block, which is what lets the file come back byte-identical.
+    doc += `${SEAM}${block}\n`;
   }
   mkdirSync(dirname(paths.hookTarget), { recursive: true });
   writeFileSync(paths.hookTarget, doc);
@@ -34,9 +39,17 @@ export function unwireHook(paths) {
   if (!existsSync(paths.hookTarget)) return [];
   const doc = readFileSync(paths.hookTarget, 'utf8');
   if (!doc.includes(MARK_START)) return [];
-  const cleaned = doc
-    .replace(new RegExp(`\\n*${MARK_START}[\\s\\S]*?${MARK_END}\\n*`), '\n')
-    .replace(/\n{3,}/g, '\n\n');
+  // Remove the block and the seam that introduced it — nothing more.
+  //
+  // This used to end with a document-wide `\n{3,}` -> `\n\n` pass, which tidied blank
+  // lines the author had put hundreds of lines away from anything of ours. In #249 that
+  // file was the project's hand-written constitution: it had already received 95 lines it
+  // never asked for, and giving it back reformatted is the second half of the same damage.
+  // A slightly larger gap is cosmetic; rewriting someone's document is not.
+  const cleaned = doc.replace(
+    new RegExp(`${SEAM.replace(/\n/g, '\\n')}?${MARK_START}[\\s\\S]*?${MARK_END}\\n?`),
+    '',
+  );
   writeFileSync(paths.hookTarget, cleaned);
   return [paths.hookTarget];
 }

package/targets/claude.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, rmSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { linkOrCopy } from './index.js';
 
@@ -70,6 +70,15 @@ export function unwireHook(paths) {
 // entry (the old `cat …/suggest/SKILL.md` form, or a previous `.sh`/`.mjs` script
 // form) is dropped before we add the current one — idempotent, migrating legacy and
 // bash-era hooks in place. Other (non-rsc) SessionStart hooks are preserved.
+// Commands name the project through ${CLAUDE_PROJECT_DIR}, never through the absolute
+// path of the folder it happened to be installed in. Baking that path in is what made a
+// harness unshareable: a committed settings.json was broken in every other checkout, and
+// even renaming your own folder broke it. The variable is resolved by the client at run
+// time, so the same bytes work on every machine — which is the precondition for the
+// manifest being worth committing at all.
+const P = '${CLAUDE_PROJECT_DIR}';
+const at = (...seg) => `${P}/${seg.join('/')}`;
+
 export function wireHook(paths) {
   const scriptDest = join(paths.projectRoot, '.rsc', 'session-start.mjs');
   mkdirSync(dirname(scriptDest), { recursive: true });
@@ -79,7 +88,8 @@ export function wireHook(paths) {
   copyFileSync(join(HERE, 'session-start.mjs'), scriptDest);
 
   const suggestMd = `${paths.skillDir('suggest')}/SKILL.md`;
-  const cmd = `node "${scriptDest}" "${suggestMd}" "${paths.projectRoot}"`;
+  const suggestRel = at(relative(paths.projectRoot, paths.skillDir('suggest')).split(sep).join('/'), 'SKILL.md');
+  const cmd = `node "${at('.rsc', 'session-start.mjs')}" "${suggestRel}" "${P}"`;
 
   const file = paths.hookTarget;
   const settings = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
@@ -99,7 +109,7 @@ export function wireHook(paths) {
   // any prior rsc worklog-checkpoint entry (.sh or .mjs) dropped first.
   const wlDest = join(paths.projectRoot, '.rsc', 'worklog-checkpoint.mjs');
   copyFileSync(join(HERE, 'worklog-checkpoint.mjs'), wlDest);
-  const wlCmd = `node "${wlDest}" "${paths.projectRoot}"`;
+  const wlCmd = `node "${at('.rsc', 'worklog-checkpoint.mjs')}" "${P}"`;
   for (const event of ['PreCompact', 'SessionEnd']) {
     settings.hooks[event] ||= [];
     settings.hooks[event] = settings.hooks[event].filter(
@@ -118,7 +128,7 @@ export function wireHook(paths) {
   // sello.mjs is ship-guard's sibling import (hooks are materialized file-by-file,
   // so the deterministic sello core must land next to the guard that loads it).
   copyFileSync(join(HERE, 'sello.mjs'), join(paths.projectRoot, '.rsc', 'sello.mjs'));
-  const sgCmd = `node "${sgDest}" "${paths.projectRoot}"`;
+  const sgCmd = `node "${at('.rsc', 'ship-guard.mjs')}" "${P}"`;
   settings.hooks.PreToolUse ||= [];
   settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
     (e) => !hookWiringOf(e).includes('.rsc/ship-guard.'),
@@ -132,7 +142,7 @@ export function wireHook(paths) {
   // node-run (Windows-safe), idempotent, fail-open, opt-out via .rsc/.no-danger-guard.
   const dgDest = join(paths.projectRoot, '.rsc', 'danger-guard.mjs');
   copyFileSync(join(HERE, 'danger-guard.mjs'), dgDest);
-  const dgCmd = `node "${dgDest}" "${paths.projectRoot}"`;
+  const dgCmd = `node "${at('.rsc', 'danger-guard.mjs')}" "${P}"`;
   settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
     (e) => !hookWiringOf(e).includes('.rsc/danger-guard.'),
   );
@@ -147,7 +157,7 @@ export function wireHook(paths) {
   // .rsc/.no-gitmoji.
   const gmDest = join(paths.projectRoot, '.rsc', 'gitmoji-guard.mjs');
   copyFileSync(join(HERE, 'gitmoji-guard.mjs'), gmDest);
-  const gmCmd = `node "${gmDest}" "${paths.projectRoot}"`;
+  const gmCmd = `node "${at('.rsc', 'gitmoji-guard.mjs')}" "${P}"`;
   settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
     (e) => !hookWiringOf(e).includes('.rsc/gitmoji-guard.'),
   );
@@ -163,7 +173,7 @@ export function wireHook(paths) {
   // (non-rsc) UserPromptSubmit hooks are preserved.
   const fgDest = join(paths.projectRoot, '.rsc', 'userprompt-gate.mjs');
   copyFileSync(join(HERE, 'userprompt-gate.mjs'), fgDest);
-  const fgCmd = `node "${fgDest}" "${paths.projectRoot}"`;
+  const fgCmd = `node "${at('.rsc', 'userprompt-gate.mjs')}" "${P}"`;
   settings.hooks.UserPromptSubmit ||= [];
   settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
     (e) => !hookWiringOf(e).includes('.rsc/userprompt-gate.'),

package/targets/index.js

@@ -1,9 +1,10 @@
-import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, cpSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, cpSync, readFileSync } from 'node:fs';
 import { join, dirname, relative } from 'node:path';
 import { homedir } from 'node:os';
 import * as claudeAdapter from './claude.js';
 import * as cursorAdapter from './cursor.js';
 import * as mdAdapter from './_md-block.js';
+import { readManifest } from '../scripts/lib/manifest-file.js';
 
 // Project-local single source of truth. Real skill files live here exactly once;
 // every assistant gets a lightweight pointer (symlink) back to it — no duplication.
@@ -83,28 +84,74 @@ export const TARGETS = [
   { id: 'aider', label: 'Aider', hint: 'CONVENTIONS.md' },
 ];
 
-// Best-effort default for the wizard's pre-mark. Unique config dirs win; the
-// shared AGENTS.md / GEMINI.md fall through to codex / gemini.
+// Which assistants are actually installed here, read from the state file each one
+// writes. This is evidence: only an install of ours writes it. Everything below
+// (detectTarget) is inference from files a human — or our own `harness` skill —
+// may have written for unrelated reasons. Order follows SPEC so the ambiguity
+// message is deterministic. A missing, empty or unreadable state means "not
+// installed", never an error: a half-written file must not break resolution.
+export function installedTargets(cwd = process.cwd()) {
+  return TARGET_IDS.filter((id) => {
+    try {
+      const state = JSON.parse(readFileSync(targetPaths(id, undefined, cwd).stateFile, 'utf8'));
+      return Object.keys(state.skills || {}).length > 0;
+    } catch { return false; }
+  });
+}
+
+// Inference, used only when there is no evidence. Unique config dirs win.
+//
+// Two rules here are scar tissue from issue #249. Claude Code had NO signal at
+// all — it was merely the final fallthrough — so any repo with a root AGENTS.md
+// resolved to codex even with .claude/ full of skills. And AGENTS.md is the
+// weakest signal on purpose: our own `harness` skill writes one into every repo
+// it equips, so treating it as a strong hint made the harness poison its own
+// detection the moment it ran once.
 export function detectTarget(cwd = process.cwd()) {
-  const dir = (d) => existsSync(join(cwd, d));
-  if (dir('.cursor')) return 'cursor';
-  if (dir('.windsurf')) return 'windsurf';
-  if (dir('.clinerules')) return 'cline';
-  if (dir('.roo')) return 'roo';
-  if (dir('.continue')) return 'continue';
-  if (dir('.junie')) return 'junie';
-  if (dir('.kiro')) return 'kiro';
-  if (dir('.zed')) return 'zed';
-  if (dir('.opencode')) return 'opencode';
-  if (dir('.amp')) return 'amp';
-  if (dir('.jules')) return 'jules';
-  if (dir('.antigravity')) return 'antigravity';
-  if (existsSync(join(cwd, '.github', 'copilot-instructions.md'))) return 'copilot';
-  if (dir('.codex') || dir('AGENTS.md')) return 'codex';
-  if (dir('.gemini') || dir('GEMINI.md')) return 'gemini';
+  const has = (p) => existsSync(join(cwd, p));
+  if (has('.cursor')) return 'cursor';
+  if (has('.windsurf')) return 'windsurf';
+  if (has('.clinerules')) return 'cline';
+  if (has('.roo')) return 'roo';
+  if (has('.continue')) return 'continue';
+  if (has('.junie')) return 'junie';
+  if (has('.kiro')) return 'kiro';
+  if (has('.zed')) return 'zed';
+  if (has('.opencode')) return 'opencode';
+  if (has('.amp')) return 'amp';
+  if (has('.jules')) return 'jules';
+  if (has('.antigravity')) return 'antigravity';
+  if (has(join('.github', 'copilot-instructions.md'))) return 'copilot';
+  if (has('.claude') || has('CLAUDE.md')) return 'claude';
+  if (has('.codex')) return 'codex';
+  if (has('.gemini') || has('GEMINI.md')) return 'gemini';
+  if (has('AGENTS.md')) return 'codex';       // weakest: our own harness writes this
   return 'claude';
 }
 
+// The single point of truth for "which assistant are we acting on". Every command
+// goes through here — including doctor, which used to resolve on its own and so
+// could report a different target than the one just installed into.
+//
+// Ambiguity is a distinct outcome, not a value the caller might mistake for an id:
+// returning a sentinel string would let a forgetful caller pass it to targetPaths()
+// and die with `unknown target`. `ids` empty + `ambiguous` set cannot be used by
+// accident.
+export function resolveTargets({ cwd = process.cwd(), flagValue } = {}) {
+  if (typeof flagValue === 'string' && flagValue.trim()) {
+    const ids = flagValue.split(',').map((s) => s.trim()).filter(Boolean);
+    return { ids, ambiguous: null, source: 'flag' };
+  }
+  // The committed manifest is what the team decided, so it outranks what happens to be
+  // on this machine. Two targets here is not ambiguity — it is the team saying "both".
+  const declared = readManifest(cwd)?.targets || [];
+  if (declared.length) return { ids: declared, ambiguous: null, source: 'manifest' };
+  const found = installedTargets(cwd);
+  if (found.length === 1) return { ids: found, ambiguous: null, source: 'evidence' };
+  if (found.length > 1) return { ids: [], ambiguous: found, source: 'evidence' };
+  return { ids: [detectTarget(cwd)], ambiguous: null, source: 'heuristic' };
+}
+
 export function targetPaths(target, home = homedir(), cwd = process.cwd()) {
   const s = SPEC[target];
   if (!s) throw new Error(`unknown target ${target}`);