@ericrisco/rsc 1.1.0 → 1.1.2

package/README.md

@@ -142,7 +142,7 @@ $ rsc
   264 skills · one CLI · zero bloat
 
 What do you want to do?          ↑↓ move · enter select
-❯ Base install — the essentials (orient + suggest + bro + harness + init)
+❯ Base install — the essentials (8 skills)
   Base + Spec-Driven Development — specify → plan → implement → ship
   Pick skills by hand, by area
 ```
@@ -185,7 +185,7 @@ rsc                                  # plain-language wizard (recommended) — p
 rsc add fastapi postgresdb           # install specific skills, by name
 rsc add youtube-api remotion-video   # …grow a channel, edit with Remotion
 rsc add fastapi --target claude,codex   # install into several assistants at once
-rsc install --profile minimal        # the floor: orient + suggest + bro + harness + init
+rsc install --profile minimal        # the base: orient + suggest + bro + unslop + show-me + eli5 + harness + init
 rsc install --profile core           # floor + the full SDD workflow
 rsc install --profile full           # everything (all 264)
 rsc install --profile full --without go
@@ -259,7 +259,7 @@ just asks in plain language.
 ### 🧭 Core & control plane
 The front door and the workspace brain.
 
-[init](skills/init/) · [harness](skills/harness/) · [orient](skills/orient/) · [suggest](skills/suggest/) · [bro](skills/bro/) · [author-skill](skills/author-skill/) · [sdd-init](skills/sdd-init/)
+[init](skills/init/) · [harness](skills/harness/) · [orient](skills/orient/) · [suggest](skills/suggest/) · [bro](skills/bro/) · [unslop](skills/unslop/) · [author-skill](skills/author-skill/) · [sdd-init](skills/sdd-init/)
 
 > **harness** is the Karpathy *chaos→knowledge* engine — a `01-TOOLS/` layer (one
 > folder per provider, each with a working `test_connection`) and a `02-DOCS/`
@@ -382,7 +382,7 @@ Three engines + engine-agnostic disciplines. Every engine skill pins the current
 
 ### 🧠 Knowledge & meta
 
-[knowledge-ops](skills/knowledge-ops/) · [codebase-onboarding](skills/codebase-onboarding/) · [research-ops](skills/research-ops/) · [decision-records](skills/decision-records/) · [continuous-learning](skills/continuous-learning/) · [skill-scout](skills/skill-scout/) · [context-budget](skills/context-budget/) · [roast-me](skills/roast-me/) · [fable-operator](skills/fable-operator/)
+[knowledge-ops](skills/knowledge-ops/) · [codebase-onboarding](skills/codebase-onboarding/) · [research-ops](skills/research-ops/) · [decision-records](skills/decision-records/) · [continuous-learning](skills/continuous-learning/) · [skill-scout](skills/skill-scout/) · [context-budget](skills/context-budget/) · [roast-me](skills/roast-me/) · [show-me](skills/show-me/) · [eli5](skills/eli5/) · [fable-operator](skills/fable-operator/)
 
 ---
 

package/manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "1.1.0",
+  "version": "1.1.2",
   "counts": {
-    "skills": 278
+    "skills": 281
   },
   "skills": [
     {
@@ -565,6 +565,7 @@
         "no-jargon"
       ],
       "recommends": [
+        "unslop",
         "brand-voice",
         "technical-writing",
         "translation-l10n"
@@ -1711,6 +1712,29 @@
       ],
       "profiles": []
     },
+    {
+      "id": "eli5",
+      "description": "Use when a topic must be explained from zero to someone who knows nothing about it: one page, big pictures, very few words, everyday analogies, no jargon and nothing assumed. NOT the smallest in-conversation visual for someone already following (that is `show-me`), NOT a course with exercises (that is `course-builder`).",
+      "tags": [
+        "eli5",
+        "explain",
+        "beginner",
+        "simple",
+        "analogy",
+        "no-jargon",
+        "explicame"
+      ],
+      "recommends": [
+        "show-me",
+        "technical-writing",
+        "course-builder"
+      ],
+      "profiles": [
+        "minimal",
+        "core",
+        "full"
+      ]
+    },
     {
       "id": "elixir",
       "description": "Use when writing or refactoring Elixir/OTP on the BEAM — GenServers, supervision trees and restart strategies, pattern matching, mix projects and releases — or when processes misbehave (restart loops, mailbox growth, call timeouts). NOT a Phoenix web app, LiveView, Ecto or channels (that is `phoenix`).",
@@ -4687,6 +4711,31 @@
       ],
       "profiles": []
     },
+    {
+      "id": "show-me",
+      "description": "Use when the user needs to see how something works instead of reading about it: picks the smallest visual that carries the point — pseudocode, call tree, file tree, component tree, Mermaid, a shaped diff, or one HTML page. NOT visual identity (that is `design-loop`), NOT slides (that is `presentations`), NOT a from-zero explainer (that is `eli5`).",
+      "tags": [
+        "show-me",
+        "explain",
+        "diagram",
+        "visual",
+        "mermaid",
+        "diff",
+        "call-tree",
+        "ensename"
+      ],
+      "recommends": [
+        "eli5",
+        "presentations",
+        "technical-writing",
+        "codebase-onboarding"
+      ],
+      "profiles": [
+        "minimal",
+        "core",
+        "full"
+      ]
+    },
     {
       "id": "simplify-code",
       "description": "Use when correct working code is unnecessarily hard to read, change or verify and needs behaviour-preserving simplification in a bounded scope. Characterizes the observable contract, removes accidental complexity one concept at a time and proves equivalence. NOT fixing a failure (`debug`), NOT read-only diff judgment (`review`/`code-review`).",
@@ -5362,6 +5411,29 @@
         "full"
       ]
     },
+    {
+      "id": "unslop",
+      "description": "Use when a written text must be audited against a named catalogue of AI tells before it ships: puffery, `not just X but Y`, the rule of three, em dashes, filler, hedging, abstract metaphor nouns. Names each hit and fixes it. NOT the register rewrite in the user's own voice (that is `bro`), NOT a reusable voice guide (that is `brand-voice`).",
+      "tags": [
+        "unslop",
+        "ai-tells",
+        "editing",
+        "audit",
+        "slop",
+        "publish-check",
+        "revisar-texto"
+      ],
+      "recommends": [
+        "bro",
+        "brand-voice",
+        "technical-writing"
+      ],
+      "profiles": [
+        "minimal",
+        "core",
+        "full"
+      ]
+    },
     {
       "id": "unsloth",
       "description": "Use when fine-tuning an open-weight LLM fast on ONE GPU with low VRAM — Unsloth's fast model loaders with 4-bit QLoRA and the trl trainer, response-only loss masking so the prompt is not trained on, GRPO reasoning fine-tunes, and export to merged 16-bit, GGUF or the Hub. NOT whether, why or which method to fine-tune (that is `finetuning`), NOT running the exported GGUF locally (that is `ollama`), NOT serving-engine flags and throughput (that is `vllm`), NOT building the JSONL dataset (that is `training-data`).",

package/package.json

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

package/scripts/doctor.js

@@ -8,6 +8,7 @@ import { listBackups } from './lib/backups.js';
 import { SDD_GATE_TEXT } from '../targets/hook-once.mjs';
 import { isEnabled, checkSello, readSello, countFindings, readEffectiveConfig, validateRiskConfig } from '../targets/sello.mjs';
 import { designIdentity } from './lib/design-identity.js';
+import { startingPointSummary } from './lib/starting-point.js';
 import { countGaps } from './lib/capabilities.js';
 
 // The sello's health, surfaced where the user already looks (spec: non-blocking
@@ -62,6 +63,10 @@ export function doctor({ target, home, cwd }) {
     // stops without one; until lib/design-identity.js nothing checked it (P2). Reported here,
     // never nagged about and never blocking: a missing identity is low risk (P7).
     designIdentity: designIdentity(root),
+    // The other half of the same question: an identity is what this project settled on, a starting
+    // point is what it has to settle FROM. Three skills promise to propose one and none could look;
+    // this is the look. One field, not a section — a report grows for every user who runs it (P5).
+    designStartingPoint: startingPointSummary(root),
     // An inert gate must never read as an armed one (the same rule the sello follows):
     // the gitmoji guard has a per-project kill switch, so say which state it is in.
     gitmojiGuard: existsSync(join(root, '.rsc', '.no-gitmoji')) ? 'opted-out' : 'armed',

package/scripts/lib/domains.js

@@ -4,7 +4,7 @@
 // catalog grows deliberately, never silently.
 
 export const DOMAINS = [
-  { title: 'Core & control plane', ids: ['init', 'harness', 'orient', 'suggest', 'bro', 'author-skill', 'sdd-init'] },
+  { title: 'Core & control plane', ids: ['init', 'harness', 'orient', 'suggest', 'bro', 'unslop', 'author-skill', 'sdd-init'] },
   { title: 'Spec-Driven Development', ids: ['sdd', 'constitution', 'idea-refinement', 'specify', 'clarify', 'plan', 'tasks', 'analyze', 'decision-challenge', 'implement', 'source-grounded-development', 'verify', 'review', 'simplify-code', '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'] },
@@ -26,7 +26,7 @@ export const DOMAINS = [
   { 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: 'Motion & interface craft', ids: ['design-eng', 'animate', 'animate-expo', 'review-animations', 'improve-animations', 'find-animation-opportunities', 'animation-vocabulary', 'apple-design', 'prototype'] },
   { title: 'Design & content craft', ids: ['design-loop', 'design', 'design-dna', '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', 'roast-me', 'fable-operator'] },
+  { title: 'Knowledge & meta', ids: ['knowledge-ops', 'codebase-onboarding', 'research-ops', 'decision-records', 'continuous-learning', 'skill-scout', 'context-budget', 'roast-me', 'show-me', 'eli5', 'fable-operator'] },
 ];
 
 export function allDomainIds() {

package/scripts/lib/starting-point.js

@@ -0,0 +1,314 @@
+// What does this project already own to start from, and does its colour hold up?
+//
+// The design area declares three times that it will propose a starting point when the user has
+// none — `design-loop` phase 1 on `skip`, the closing line of `design`'s brand grounding, and
+// `design-dna`'s REUSE mode — and none of the three had anything behind it. An unbacked promise to
+// propose falls back to the model's prior, which is the AI-template median the area exists to
+// escape. Spec: 02-DOCS/wiki/sdd/specs/design-starting-point.md
+//
+// This file is the half that can be an algorithm (P1): listing what is installed, and refusing to
+// propose a colour that fails contrast. The half that needs judgement — which reference is the right
+// bar for what you are building — is prose, in design/references/starting-point.md.
+//
+// Read-only, always. `02-DOCS` is untracked and has no undo (P9), and a discovery pass has no
+// business writing anywhere.
+import { existsSync, lstatSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { designIdentity, BRAND_DIR } from './design-identity.js';
+
+// WCAG 2.2 AA. Body text, and the relaxed floor for large text and UI components.
+export const TEXT_MIN = 4.5;
+export const UI_MIN = 3.0;
+
+// Which palette roles are held to which floor. `design-dna`'s schema fixes the role vocabulary
+// (ground, ink, accent, secondary, hairline); anything outside it is skipped rather than guessed at,
+// because inventing a threshold for an unknown role is how a gate starts approving things.
+const TEXT_ROLES = new Set(['ink', 'secondary']);
+const UI_ROLES = new Set(['accent']);
+const GROUND_ROLE = 'ground';
+
+// A record is only reusable if it carries the fields a style is actually rebuilt from. Half a record
+// cannot be reused, so it is reported as unreadable instead of offered as a candidate.
+const REQUIRED = ['palette'];
+const DIMENSIONS = ['palette', 'type', 'space', 'surface', 'motion', 'signatures', 'voice'];
+
+/** Where `design-dna` emits, and where rsc installs, in both scopes. */
+export function defaultRoots({ home = homedir(), cwd = process.cwd() } = {}) {
+  const roots = [];
+  for (const base of home === cwd ? [cwd] : [cwd, home]) {
+    roots.push(join(base, '.claude', 'skills'));
+    roots.push(join(base, '.rsc', 'skills'));
+  }
+  return roots;
+}
+
+function parseHex(hex) {
+  if (typeof hex !== 'string') return null;
+  const m = /^#([0-9a-fA-F]{6})$/.exec(hex.trim());
+  if (!m) return null;
+  const n = parseInt(m[1], 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
+// WCAG relative luminance. The sRGB transfer function, not a shortcut: an approximation here is a
+// wrong ratio everywhere downstream, and it would pass a test written against this file's own output.
+function luminance([r, g, b]) {
+  const lin = [r, g, b].map((c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
+}
+
+/**
+ * WCAG 2.x contrast ratio between two colours, 1.0 … 21.0. Symmetric.
+ * @param {string} a sRGB hex, `#rrggbb`
+ * @param {string} b sRGB hex, `#rrggbb`
+ */
+export function contrastRatio(a, b) {
+  const ca = parseHex(a);
+  const cb = parseHex(b);
+  if (!ca || !cb) throw new TypeError(`not an sRGB hex colour: ${!ca ? a : b}`);
+  const la = luminance(ca);
+  const lb = luminance(cb);
+  const [hi, lo] = la >= lb ? [la, lb] : [lb, la];
+  return (hi + 0.05) / (lo + 0.05);
+}
+
+/**
+ * Does this palette's text hold up against its own ground?
+ *
+ * Runs before a measured colour is written as a proposed dimension: a value that fails is not
+ * proposed at all, rather than proposed and flagged. Three outcomes are kept apart on purpose —
+ * measured-and-passing, measured-and-failing, and **not measured**. Collapsing the third into the
+ * first is the vacuous pass this area has already paid for twice.
+ *
+ * @param {Array<{role: string, hex: string, name?: string}>} colors — `palette.colors` from a dna.json
+ * @returns {{ok: boolean, pairs: Array<object>, failures: Array<object>, skipped: Array<object>,
+ *            unparsed: string[], reason: string}}
+ */
+export function checkPairings(colors) {
+  const list = Array.isArray(colors) ? colors : [];
+  const pairs = [];
+  const skipped = [];
+  const unparsed = [];
+
+  const ground = list.find((c) => c && c.role === GROUND_ROLE);
+  const groundHex = ground ? parseHex(ground.hex) : null;
+  if (!ground) {
+    return { ok: false, pairs, failures: [], skipped, unparsed, reason: 'no ground role in the palette — nothing to measure against' };
+  }
+  if (!groundHex) {
+    unparsed.push(String(ground.hex));
+    return { ok: false, pairs, failures: [], skipped, unparsed, reason: `ground colour is not an sRGB hex: ${ground.hex}` };
+  }
+
+  for (const c of list) {
+    if (!c || c.role === GROUND_ROLE) continue;
+    const isText = TEXT_ROLES.has(c.role);
+    const isUi = UI_ROLES.has(c.role);
+    if (!isText && !isUi) {
+      // A hairline is not text. Saying so is not the same as saying it passed.
+      skipped.push({ role: c.role, name: c.name, reason: 'role carries no text, so no text floor applies' });
+      continue;
+    }
+    if (!parseHex(c.hex)) {
+      unparsed.push(String(c.hex));
+      continue;
+    }
+    const min = isText ? TEXT_MIN : UI_MIN;
+    const ratio = Math.round(contrastRatio(c.hex, ground.hex) * 100) / 100;
+    pairs.push({ role: c.role, name: c.name, fg: c.hex, bg: ground.hex, ratio, min, ok: ratio >= min });
+  }
+
+  const failures = pairs.filter((p) => !p.ok);
+  // Not measuring anything is not a pass. An empty failure list only means green when at least one
+  // pair was actually evaluated and nothing was left unparsed.
+  const ok = failures.length === 0 && unparsed.length === 0 && pairs.length > 0;
+  const reason = unparsed.length
+    ? `${unparsed.length} colour(s) could not be parsed, so they were not measured`
+    : pairs.length === 0
+      ? 'no text or UI role to measure against the ground'
+      : failures.length
+        ? `${failures.length} pair(s) below their floor`
+        : `${pairs.length} pair(s) measured, all above their floor`;
+  return { ok, pairs, failures, skipped, unparsed, reason };
+}
+
+function readRecord(dir, slug) {
+  const file = join(dir, 'dna.json');
+  let raw;
+  try {
+    raw = readFileSync(file, 'utf8');
+  } catch (e) {
+    return { error: `cannot read dna.json: ${e.code || e.message}` };
+  }
+  let dna;
+  try {
+    dna = JSON.parse(raw);
+  } catch (e) {
+    return { error: `dna.json is not valid JSON: ${e.message}` };
+  }
+  const missing = REQUIRED.filter((k) => !dna || !dna[k]);
+  if (missing.length) return { error: `record is missing ${missing.join(', ')} — half a record cannot be reused` };
+
+  return {
+    record: {
+      slug: (dna.meta && dna.meta.slug) || slug,
+      name: (dna.meta && dna.meta.name) || slug,
+      path: file,
+      covers: DIMENSIONS.filter((d) => dna[d]),
+      palette: (dna.palette && dna.palette.colors) || [],
+    },
+  };
+}
+
+// What the harness's own identity articles mention. A record the project actually used outranks one
+// that merely happens to be installed — but the others stay on the list, because choosing for the
+// user is exactly what the spec forbids.
+function citedSlugs(harnessRoot) {
+  const dir = join(harnessRoot, BRAND_DIR);
+  let text = '';
+  try {
+    for (const f of readdirSync(dir)) {
+      if (!f.endsWith('.md')) continue;
+      try { text += readFileSync(join(dir, f), 'utf8').toLowerCase(); } catch { /* one unreadable article is not the answer */ }
+    }
+  } catch { /* no identity here; designIdentity reports that half */ }
+  return text;
+}
+
+/**
+ * What this project already owns to start a design from.
+ *
+ * @param {string[]} roots — skill directories to scan. Defaults to both scopes, both layouts.
+ * @param {string} harnessRoot — where `02-DOCS/` lives, for the identity half and the ordering.
+ * @returns {{state: 'owned'|'none'|'inconclusive', identity: object, records: object[],
+ *            unreadable: Array<{path: string, reason: string}>, reason: string, fix?: string}}
+ *   `owned`        — an identity or at least one legible record exists.
+ *   `none`         — looked everywhere, found nothing. Carries the way out (P6).
+ *   `inconclusive` — something could not be read. Never reported as `none`, never as green.
+ */
+export function ownedStartingPoints(roots = defaultRoots(), harnessRoot = process.cwd()) {
+  const identity = designIdentity(harnessRoot);
+  const records = [];
+  const unreadable = [];
+  let blind = 0;
+
+  for (const root of roots) {
+    // existsSync follows symlinks, so a dangling one answers false and would be filed as "nothing
+    // installed here". That is unreadability, not absence — the exact conflation designIdentity was
+    // fixed for. lstat sees the link itself and tells them apart.
+    if (!existsSync(root)) {
+      let dangling = false;
+      try { dangling = lstatSync(root).isSymbolicLink(); } catch { /* genuinely absent */ }
+      if (dangling) {
+        blind += 1;
+        unreadable.push({ path: root, reason: 'skills root is a symlink that does not resolve' });
+      }
+      continue;
+    }
+    let entries;
+    try {
+      if (!statSync(root).isDirectory()) {
+        blind += 1;
+        unreadable.push({ path: root, reason: 'skills root exists but is not a directory' });
+        continue;
+      }
+      entries = readdirSync(root, { withFileTypes: true });
+    } catch (e) {
+      blind += 1;
+      unreadable.push({ path: root, reason: `cannot read skills root: ${e.code || e.message}` });
+      continue;
+    }
+    for (const entry of entries) {
+      // Dirents, not statSync: a symlinked entry could otherwise report on a directory outside the
+      // root we were asked to scan.
+      if (!entry.isDirectory()) continue;
+      const dir = join(root, entry.name);
+      if (!existsSync(join(dir, 'dna.json'))) continue;
+      const { record, error } = readRecord(dir, entry.name);
+      if (error) { unreadable.push({ path: join(dir, 'dna.json'), reason: error }); continue; }
+      if (!records.some((r) => r.slug === record.slug)) records.push(record);
+    }
+  }
+
+  const cited = citedSlugs(harnessRoot);
+  records.sort((a, b) => {
+    const ac = cited.includes(a.slug.toLowerCase()) ? 0 : 1;
+    const bc = cited.includes(b.slug.toLowerCase()) ? 0 : 1;
+    return ac - bc || a.slug.localeCompare(b.slug);
+  });
+
+  if (records.length || identity.state === 'present') {
+    return {
+      state: 'owned',
+      identity,
+      records,
+      unreadable,
+      reason: [
+        identity.state === 'present' ? `identity present (${identity.articles.length} article(s))` : 'no harness identity',
+        `${records.length} style record(s)`,
+        unreadable.length ? `${unreadable.length} unreadable` : null,
+      ].filter(Boolean).join(', '),
+    };
+  }
+
+  // Something was there and we could not use it. Saying "nothing to propose" would be a finding we
+  // did not earn, and saying nothing at all would hide it.
+  if (unreadable.length || blind || identity.state === 'inconclusive') {
+    return {
+      state: 'inconclusive',
+      identity,
+      records,
+      unreadable,
+      reason: unreadable.length
+        ? `could not read ${unreadable.length} candidate(s): ${unreadable[0].reason}`
+        : `identity could not be read: ${identity.reason}`,
+      fix: 'name what could not be read, and ask for another route to it — never propose past a blind spot',
+    };
+  }
+
+  return {
+    state: 'none',
+    identity,
+    records: [],
+    unreadable,
+    reason: 'no harness identity and no style record installed in any scope',
+    fix: 'propose at most three openable references as candidate bars (design/references/starting-point.md), then run `design-loop`',
+  };
+}
+
+/**
+ * The compact projection `doctor` reports: one object, not a section (P5 — every byte of a report is
+ * paid by every user who runs it). Contrast is folded in per record because a record whose own
+ * palette fails is not a starting point anyone should be offered.
+ *
+ * @returns {{state: string, records: string[], contrast: string, unreadable: number, reason: string}}
+ */
+export function startingPointSummary(root = process.cwd(), roots = defaultRoots({ cwd: root })) {
+  const r = ownedStartingPoints(roots, root);
+  let failing = 0;
+  let unmeasured = 0;
+  for (const rec of r.records) {
+    const c = checkPairings(rec.palette);
+    if (c.failures.length) failing += 1;
+    else if (!c.ok) unmeasured += 1;
+  }
+  const contrast = r.records.length === 0
+    ? 'no record to measure'
+    : failing
+      ? `${failing} record(s) with a pair below its floor`
+      : unmeasured
+        ? `${unmeasured} record(s) could not be measured`
+        : 'all records above their floors';
+  return {
+    state: r.state,
+    records: r.records.map((x) => x.slug),
+    contrast,
+    unreadable: r.unreadable.length,
+    reason: r.reason,
+    ...(r.fix ? { fix: r.fix } : {}),
+  };
+}

package/scripts/rsc.js

@@ -161,17 +161,21 @@ async function wizard() {
   const m = loadManifest();
   await banner(m.counts.skills);
   say('  the skill catalog for your assistant (Claude Code · Codex · Cursor · Gemini · Antigravity)\n');
+  // The base set is READ from the manifest, never enumerated here: a hand-kept list in a menu
+  // label is parallel accounting (P3), and it silently starts lying the day a skill's profiles
+  // change. The exact ids are printed before the install confirmation either way.
+  const baseIds = skillsForProfile(m, 'minimal');
   // Navigable loop: esc / "← Back" / "no" all return here instead of quitting.
   for (;;) {
     const choice = await select('What do you want to do?', [
-      { key: 'base', label: 'Base install — the essentials (orient + suggest + bro + harness + init)' },
+      { key: 'base', label: `Base install — the essentials (${baseIds.length} skills)` },
       { key: 'sdd', label: 'Base + Spec-Driven Development — the specify → plan → implement → ship flow' },
       { key: 'manual', label: 'Pick skills by hand, by area' },
     ]);
     if (choice === null) { say('\nOK — nothing installed. Anytime: npx @ericrisco/rsc'); return; }
 
     let ids;
-    if (choice === 'base') ids = skillsForProfile(m, 'minimal');
+    if (choice === 'base') ids = baseIds;
     else if (choice === 'sdd') ids = skillsForProfile(m, 'core');
     else if (choice === 'manual') {
       const picked = await manualSelect();

package/skills/bro/SKILL.md

@@ -2,7 +2,7 @@
 name: bro
 description: "Use whenever the user asks to make an answer or draft sound human, natural, plain-spoken or less AI-written — including a terse bro after the last response. Rewrites or drafts in the same language while preserving meaning, facts and channel. NOT a reusable brand voice (that is `brand-voice`), NOT translation (that is `translation-l10n`)."
 tags: [bro, human-writing, humano, plain-language, natural-language, rewrite, no-jargon]
-recommends: [brand-voice, technical-writing, translation-l10n]
+recommends: [unslop, brand-voice, technical-writing, translation-l10n]
 profiles: [minimal, core, full]
 origin: risco
 ---
@@ -57,6 +57,14 @@ plain language instead of deleting precision.
 | Promise the result is undetectable as AI | No rewrite can honestly guarantee that | Promise clarity and naturalness, not detector outcomes |
 | Announce and justify every edit | The preamble becomes the same friction the user asked to remove | Lead with the finished words |
 
+## Where this ends
+
+`unslop` owns the other half of this job: the **named** audit of a text that already exists, tell by
+catalogued tell (puffery, `not just X but Y`, em dashes, bold-label lists, hedging), run before the
+text ships. This skill owns the **register**: which language, which relationship, which channel, and
+the cadence that fits them. A bare "bro" is always this skill. "Check this for AI tells before I
+publish it" is `unslop`. When a text needs both, audit first, register last.
+
 ## Output boundary
 
 Treat the rewritten text as an artifact: keep harness commentary outside it. If the task also

package/skills/bro/evals/cases.yaml

@@ -46,6 +46,10 @@ should_not_trigger:
     route_to: "simplify-code"
     why: "The requested source-code simplification is owned by simplify-code; 'rewrite' does not make it a prose task."
 
+  - prompt: "Revisa este README antes de publicarlo y dime qué frases suenan a IA, una por una."
+    route_to: "unslop"
+    why: "A named, per-phrase audit of an existing text before shipping is unslop's contract; bro rewrites the register instead of enumerating tells."
+
 capability:
   - scenario: "The previous assistant answer is a long Spanish status update full of headings, repeated summaries, corporate jargon and fake enthusiasm. Rewrite it for a client while preserving a June 30 deadline, a EUR 2,400 price, one unresolved risk, two URLs and the original uncertainty."
     must_include:

package/skills/design/SKILL.md

@@ -35,6 +35,8 @@ Follow the harness 02-DOCS convention (brand study = wiki articles under `02-DOC
 
 The completeness checklist spans visual identity (OKLCH color system, type pairing & scale, logo, imagery/illustration mood, density, radius/shadow/motion personality), reference/inspiration sites the user loves, layout preferences, dark-mode stance, accessibility & performance constraints, and brand voice/positioning (so copy and design agree). Full checklist + exact question script → `references/brand-grounding.md`.
 
+**When a dimension has no answer** — the non-technical default, and the reason this gate used to be impassable: do not invent one and do not wave the STOP through. `references/starting-point.md` is how a starting point gets proposed instead: what the project already owns is checked first, the value comes from a reference you opened and measured, and it is written marked `propuesto` — which does **not** count as complete until the user confirms it.
+
 The order is: **brand grounding → trend research → build.**
 
 ## Pick a direction first
@@ -66,7 +68,7 @@ Then map the project type to composition, density, and motion budget. Density an
 Trends churn quarterly and your built-in aesthetic prior is the median of every AI template ever scraped. Never prescribe from stale memory; counter it with a loop:
 
 1. Define 2–3 reference archetypes from the DIRECTION BRIEF (e.g. "Linear-grade dev tool, dark, type-led").
-2. WebSearch award galleries and tier-1 product sites: `awwwards.com`, `godly.website`, `land-book.com`, `mobbin.com`, Refactoring UI, and the tier-1 sites (Linear, Stripe, Vercel, Cursor, Resend).
+2. Browse the dated registry in `references/inspiration-sources.md` — whole pages to beat, SaaS and conversion surfaces, real product flows (Mobbin, Page Flows), single patterns, and the design systems that are specification rather than inspiration — plus the tier-1 sites (Linear, Stripe, Vercel, Cursor, Resend). Every entry there carries a verification date; `godly.website` now redirects to `recent.design`, which is exactly why the list is dated and not inline.
 3. WebFetch 3–5 exemplars, prompting each for type, color, layout, motion, and copy voice — concrete details, not adjectives.
 4. Extract a pattern table from what they share and where they differ.
 5. Synthesize a one-paragraph DESIGN DIRECTION with citations (which URL contributed what).

package/skills/design/references/brand-grounding.md

@@ -96,7 +96,7 @@ Ask **one batch at a time**. Send the batch, wait for the answer, persist what y
     extend rather than replace?
 ```
 
-If the user can't answer a question, that dimension stays incomplete — note the gap, keep the STOP in place for that dimension, and offer to propose a researched default (from the research-first protocol / `trends-2026.md`) they can confirm, rather than silently defaulting to your generic prior.
+If the user can't answer a question, that dimension stays incomplete — note the gap, keep the STOP in place for that dimension, and offer to propose a researched default they can confirm, rather than silently defaulting to your generic prior. **How to actually propose one: `starting-point.md`.** It is the difference between offering something and improvising something: what the project already owns is checked first, the value comes from a reference you opened and measured, and it is written marked `propuesto`. A proposed-and-unconfirmed dimension does **not** count as complete against the checklist above — the STOP stays up until the user confirms it.
 
 ## Persistence format
 

package/skills/design/references/design-systems.md

@@ -39,3 +39,11 @@ Everything in `../SKILL.md` that is not styling: the brand gate, the accessibili
 the Core Web Vitals budget, the 5-second value-prop test, and the tell registry in
 `../scripts/verify.sh`. An official design system settles which components you use. It does
 not settle whether the page says anything.
+
+## Where to browse for component ideas
+
+When a surface needs an idea rather than a primitive, `../../pick-ui-library/references/component-galleries.md`
+names where to go — Aceternity for marketing effects, 21st.dev for breadth, React Bits for tunable
+animation — and what each is good for. Take the technique and rebuild it in this project's tokens;
+check the brand study for what it refuses first, because a component that contradicts a stated ban
+makes the page look less designed, not more.