@ericrisco/rsc 1.0.25 → 1.0.27

package/README.md

@@ -119,6 +119,11 @@ also wires a `SessionStart` hook (so your assistant proposes new skills on its
 own) and a `UserPromptSubmit` hook that re-asserts the **SDD new-feature gate**
 on every turn — so a feature request, in any language, routes through `specify`
 first, before any skill writes code. Opt out per project with `.rsc/.no-feature-gate`.
+It also wires a `PreToolUse` **gitmoji guard**: a `git commit` whose message carries no
+[gitmoji](https://gitmoji.dev) is denied, with the corrected message inside the refusal
+(`✨ feat(api): add cursor paging`) — so `git log --oneline` stays readable at a glance instead of
+depending on the agent remembering a convention. It only judges messages it can actually read
+(`-m`, heredoc), never an editor commit or `--amend --no-edit`. Opt out with `.rsc/.no-gitmoji`.
 
 Everything stays **in the project**, and the real skill files are written
 **once** to `.rsc/skills/<id>/`. Each assistant you pick gets a lightweight

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.25",
+  "version": "1.0.27",
   "counts": {
     "skills": 264
   },
@@ -2114,11 +2114,12 @@
     },
     {
       "id": "git-workflow",
-      "description": "Use when naming or scoping a branch, writing or fixing a commit message, untangling history (rebase versus merge versus squash), or cutting a versioned release — the portable git-convention layer for any repo. Covers Conventional Commits, SemVer tags, branch hygiene, force-push safety and gh pr/release mechanics. NOT the land-it decision and pre-ship checklist (that is `ship`), NOT an isolated checkout before coding (that is `worktrees`), NOT CI/CD release automation (that is `deployment`).",
+      "description": "Use when naming or scoping a branch, writing or fixing a commit message, picking the gitmoji for a commit, untangling history (rebase versus merge versus squash), or cutting a versioned release — the portable git-convention layer for any repo. Covers gitmoji + Conventional Commits, SemVer tags, branch hygiene, force-push safety and gh pr/release mechanics. NOT the land-it decision and pre-ship checklist (that is `ship`), NOT an isolated checkout before coding (that is `worktrees`), NOT CI/CD release automation (that is `deployment`).",
       "tags": [
         "git",
         "version-control",
         "conventional-commits",
+        "gitmoji",
         "semver",
         "pull-request"
       ],
@@ -4556,7 +4557,7 @@
     },
     {
       "id": "specify",
-      "description": "Use when a feature, change, or product idea is still fuzzy and must become an approved WHAT/WHY spec before any planning or code — the brainstorming front door of SDD. Turns a one-line intent into problem, goals, users, scope, behaviour and acceptance criteria, via one-question-at-a-time dialogue and 2-3 approaches with a recommendation, carrying zero implementation detail. Fires whenever someone jumps to HOW before WHAT is agreed, in any language. NOT the technical plan (that is `plan`), NOT the de-risking ambiguity sweep (that is `clarify`), NOT project-wide principles (that is `constitution`).",
+      "description": "Use when a feature, change, or product idea is still fuzzy and must become an approved WHAT/WHY spec before any planning or code — the brainstorming front door of SDD. Turns a one-line intent into problem, goals, users, scope, behaviour and acceptance criteria, via frontier-round dialogue and 2-3 approaches with a recommendation, carrying zero implementation detail. Fires whenever someone jumps to HOW before WHAT is agreed, in any language. NOT the technical plan (that is `plan`), NOT the de-risking ambiguity sweep (that is `clarify`), NOT project-wide principles (that is `constitution`).",
       "tags": [
         "sdd",
         "spec",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     "drift:check": "node scripts/drift-check.js",
     "drift:knowledge": "node scripts/drift-check.js --knowledge",
     "knowledge:doctor": "node scripts/knowledge-doctor.js",
+    "spec:gate": "node scripts/spec-gate.js",
     "routing:audit": "node scripts/routing-audit.js",
     "test": "node --test",
     "coverage": "c8 --reporter=text node --test",

package/scripts/build-manifest.js

@@ -3,14 +3,15 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import Ajv from 'ajv';
 import { parseFrontmatter } from './lib/frontmatter.js';
+import { fenceBalance } from './lib/skill-lint.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const SKILLS = join(ROOT, 'skills');
 
-function skillDirs() {
-  return readdirSync(SKILLS).filter((d) => {
+function skillDirs(base = SKILLS) {
+  return readdirSync(base).filter((d) => {
     try {
-      return statSync(join(SKILLS, d)).isDirectory() && statSync(join(SKILLS, d, 'SKILL.md')).isFile();
+      return statSync(join(base, d)).isDirectory() && statSync(join(base, d, 'SKILL.md')).isFile();
     } catch {
       return false;
     }
@@ -47,6 +48,20 @@ export function validateFrontmatter() {
   return errors;
 }
 
+// A skill body whose code-block delimiters do not pair renders half its content as one code block,
+// and every other gate stays green while it happens. Deterministic defect, deterministic check —
+// and it lives here so `prepublishOnly` can never ship one.
+export function validateBodies(base = SKILLS) {
+  const errors = [];
+  for (const id of skillDirs(base)) {
+    const r = fenceBalance(readFileSync(join(base, id, 'SKILL.md'), 'utf8'));
+    if (!r.balanced) {
+      errors.push(`${id}: unbalanced code-block delimiter opened at line ${r.opened} (${r.fences} found)`);
+    }
+  }
+  return errors;
+}
+
 // A skill's `description` is in context on every turn it is installed, invoked or not, so the
 // catalog's total description weight is the one number that scales with the catalog itself.
 // The hard failure stays at the schema limit; this reports the soft ceiling the rubric asks for,
@@ -67,9 +82,10 @@ function main() {
   const arg = process.argv[2];
   const out = join(ROOT, 'manifest.json');
   if (arg === '--validate') {
-    const errs = validateFrontmatter();
+    const errs = [...validateFrontmatter(), ...validateBodies()];
     if (errs.length) { console.error(errs.join('\n')); process.exit(1); }
     console.log('frontmatter OK');
+    console.log('skill bodies OK (code-block delimiters balanced)');
     const w = descriptionWeight();
     console.log(
       `description weight: ${(w.total / 1024).toFixed(1)} KB across ${w.count} skills `

package/scripts/doctor.js

@@ -57,6 +57,9 @@ export function doctor({ target, home, cwd }) {
     },
     contextBudget: contextBudget({ target, home, cwd }),
     sello: selloStatus(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',
     // Counted, never interpreted — by spec, the gap log's reader is the user.
     automationGaps: countGaps(root),
   };

package/scripts/install-apply.js

@@ -60,6 +60,7 @@ function generatedHookFiles({ target, cwd }) {
     join(cwd, '.rsc', 'worklog-checkpoint.mjs'),
     join(cwd, '.rsc', 'ship-guard.mjs'),
     join(cwd, '.rsc', 'danger-guard.mjs'),
+    join(cwd, '.rsc', 'gitmoji-guard.mjs'),
     join(cwd, '.rsc', 'userprompt-gate.mjs'),
     join(cwd, '.rsc', 'hook-once.mjs'),
     join(cwd, '.rsc', 'sello.mjs'),

package/scripts/lib/skill-lint.js

@@ -0,0 +1,29 @@
+// Structural lint of a skill body. Pure: give it the text, get a verdict.
+//
+// Scope is deliberately one defect class. A stray closing delimiter inverts every block boundary
+// after it, so a skill can render half its body as one code block while every other gate stays
+// green: the frontmatter validates, the description fits, the prose reads fine in the source. It is
+// a purely deterministic defect, so it belongs to a binary, not to a reader's attention.
+
+const FENCE = /^(?:```|~~~)/;
+
+/**
+ * @param {string} body raw skill markdown
+ * @returns {{balanced: boolean, fences: number, opened: number|null}}
+ *   `fences` counts column-0 delimiters; `opened` is the 1-indexed line of the unpaired one.
+ */
+export function fenceBalance(body) {
+  const lines = String(body ?? '').split('\n');
+  let open = null; // line number of the delimiter that opened the current block
+  let fences = 0;
+
+  for (let i = 0; i < lines.length; i += 1) {
+    // Only a column-0 delimiter is a block boundary. Indented ones are content: a fenced sample
+    // inside a fenced block. Counting those would flag correct documents.
+    if (!FENCE.test(lines[i])) continue;
+    fences += 1;
+    open = open === null ? i + 1 : null;
+  }
+
+  return { balanced: open === null, fences, opened: open };
+}

package/scripts/lib/spec-gate.js

@@ -0,0 +1,122 @@
+// The exit gate of the `specify` phase, as a binary instead of a feeling.
+//
+// "Stop when the WHAT and WHY are complete enough to plan against" cannot tell done from not-done,
+// so the phase closed whenever the agent felt closed — with the write/review/approve steps visible
+// the whole time, pulling attention toward being finished. This checks the artifact instead: every
+// template section carries content or an explicit open point.
+//
+// What it does NOT check is returned in `unchecked`, on purpose. Detecting an unmarked assumption is
+// the problem `specify` exists to solve, not something a parser can do, and a gate that implies
+// otherwise is worse than one that admits its edge.
+
+// The four states a point can be in. Order is the table's order in the skill body.
+export const OPEN_POINT_TYPES = [
+  'pregunta abierta', // formulable now, unanswered → clarify asks it
+  'suposición tomada', // we decided, with the basis written → clarify validates it
+  'decisión diferida', // sharp, out of this cycle on purpose → clarify leaves it
+  'área no formulable', // known to be coming, not yet sharp → clarify notes it
+];
+
+// The corpus is Spanish, the template is English, and both carry drifting parentheticals
+// ("Objetivos (resultado)", "Criterios de aceptación (binarios)"). Matching literal strings would
+// be useless, so each family is a set of normalised prefixes.
+const FAMILIES = {
+  problem: ['problema & por que', 'problema y por que', 'problem & why'],
+  goals: ['objetivos', 'goals'],
+  nongoals: ['no-objetivos', 'no objetivos', 'non-goals'],
+  users: ['usuarios & contexto', 'usuarios y contexto', 'users & context'],
+  behaviour: ['comportamiento', 'behaviour', 'behavior'],
+  acceptance: ['criterios de aceptacion', 'acceptance criteria'],
+  open: ['puntos a clarificar', 'puntos de clarify', 'puntos que siguen abiertos', 'points to clarify'],
+};
+
+const UNCHECKED = [
+  'que ninguna sección contenga una suposición sin marcar (no es detectable por máquina; es el juicio que la fase existe para ejercer)',
+  'que el contenido de cada sección sea correcto, y no sólo presente',
+  'que los criterios de aceptación sean de verdad binarios',
+];
+
+function fold(s) {
+  return s
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .trim();
+}
+
+function familyOf(heading) {
+  const h = fold(heading);
+  for (const [family, prefixes] of Object.entries(FAMILIES)) {
+    if (prefixes.some((p) => h.startsWith(p))) return family;
+  }
+  return null;
+}
+
+// A heading with nothing under it is not a filled section. Neither is one holding only the
+// template's own italic/angle-bracket guidance, which is what a hurried pass leaves behind.
+function isSubstantive(line) {
+  const t = line.trim();
+  if (!t) return false;
+  if (/^<.*>$/.test(t)) return false; // <guidance from the template>
+  if (/^\*[^*].*\*$/.test(t) && t.length < 200) return false; // *italic guidance*
+  if (/^(-|\*)\s*$/.test(t)) return false; // an empty bullet
+  return true;
+}
+
+function parseOpenPoints(lines) {
+  const points = [];
+  for (const line of lines) {
+    const m = line.match(/^\s*[-*]\s+(?:\[[ x]\]\s*)?(.*)$/);
+    if (!m || !m[1].trim()) continue;
+    const body = m[1];
+    const declared = OPEN_POINT_TYPES.find((t) => {
+      const re = new RegExp(`^\\*\\*\\s*${t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\*\\*`, 'i');
+      return re.test(fold(body)) || re.test(body);
+    });
+    points.push({
+      type: declared || OPEN_POINT_TYPES[0], // the costliest default: treat it as a real question
+      typed: Boolean(declared),
+      text: body.trim(),
+    });
+  }
+  return points;
+}
+
+/**
+ * @param {string} markdown a written spec file
+ * @returns {{ok: boolean, missing: string[], empty: string[],
+ *            openPoints: Array<{type: string, typed: boolean, text: string}>,
+ *            untyped: string[], unchecked: string[]}}
+ */
+export function specCompleteness(markdown) {
+  const lines = String(markdown ?? '').split('\n');
+  const sections = new Map(); // family -> body lines
+
+  let current = null;
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.*)$/);
+    if (h) {
+      const fam = familyOf(h[1]);
+      current = fam;
+      if (fam && !sections.has(fam)) sections.set(fam, []);
+      continue;
+    }
+    if (current && sections.has(current)) sections.get(current).push(line);
+  }
+
+  const families = Object.keys(FAMILIES);
+  const missing = families.filter((f) => !sections.has(f));
+  const empty = families.filter((f) => sections.has(f) && !sections.get(f).some(isSubstantive));
+
+  const openPoints = sections.has('open') ? parseOpenPoints(sections.get('open')) : [];
+  const untyped = openPoints.filter((p) => !p.typed).map((p) => p.text);
+
+  return {
+    ok: missing.length === 0 && empty.length === 0,
+    missing,
+    empty,
+    openPoints,
+    untyped,
+    unchecked: UNCHECKED,
+  };
+}

package/scripts/spec-gate.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Runs the `specify` exit gate over written specs. Report-only: it never edits a spec.
+//
+// Not wired into `prepublishOnly`, and that is deliberate: specs live under 02-DOCS, which is never
+// tracked (principle 9), so a publish gate depending on them would fail in any clean clone. This is
+// the phase's own instrument, and the author's.
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { specCompleteness } from './lib/spec-gate.js';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const DEFAULT_DIR = join(ROOT, '02-DOCS', 'wiki', 'sdd', 'specs');
+
+function defaultTargets() {
+  try {
+    return readdirSync(DEFAULT_DIR)
+      .filter((f) => f.endsWith('.md') && !f.endsWith('.plan.md'))
+      .map((f) => join(DEFAULT_DIR, f));
+  } catch {
+    return [];
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const targets = args.length ? args : defaultTargets();
+  if (!targets.length) {
+    console.log('no specs found — pass a path, or write one to 02-DOCS/wiki/sdd/specs/');
+    return;
+  }
+
+  let failed = 0;
+  for (const path of targets) {
+    const r = specCompleteness(readFileSync(path, 'utf8'));
+    const name = basename(path);
+    if (r.ok) {
+      const typed = r.openPoints.length - r.untyped.length;
+      console.log(`PASS  ${name} — ${r.openPoints.length} open point(s), ${typed} typed`);
+      if (r.untyped.length) {
+        console.log(`      untyped (treated as open questions): ${r.untyped.length}`);
+      }
+    } else {
+      failed += 1;
+      console.log(`FAIL  ${name}`);
+      if (r.missing.length) console.log(`      missing section(s): ${r.missing.join(', ')}`);
+      if (r.empty.length) console.log(`      section(s) with no content: ${r.empty.join(', ')}`);
+    }
+  }
+
+  // A green here is narrower than the rule it enforces, so it says so every run rather than
+  // letting the reader assume the gate covered more than it did.
+  console.log(`\n${targets.length - failed}/${targets.length} pass. Not checked by this gate:`);
+  for (const u of specCompleteness('').unchecked) console.log(`  - ${u}`);
+  if (failed) process.exit(1);
+}
+
+main();

package/skills/clarify/SKILL.md

@@ -28,12 +28,36 @@ This is the fourth phase of the rsc SDD chain (`constitution` → `specify` →
 
 Clarify never works blind. Before asking a single question, load three things:
 
-1. **The spec.** Read the target spec under `02-DOCS/wiki/sdd/specs/<slug>.md` end to end. If the path wasn't given, find the most recently touched spec or ask which one.
+1. **The spec.** Read the target spec under `02-DOCS/wiki/sdd/specs/<slug>.md` end to end. If the path wasn't given, find the most recently touched spec or ask which one. Its *Points to clarify* is a **typed** handoff, not a question list — read the types before you plan a single question (below).
 2. **The constitution.** Read `02-DOCS/wiki/sdd/constitution.md` if it exists. Its principles (stack canon, quality bars, conventions) resolve a surprising number of "ambiguities" without bothering the user — if the constitution already fixes the auth method or the data region, that's answered, not open.
 3. **The harness profile.** `02-DOCS/wiki/harness/user-profile.md`, for the dial above.
 
 Citing what you read ("checked the constitution — auth is already fixed to OAuth, so that's not an open question") shows your work and prevents re-litigating settled decisions.
 
+## The typed handoff — what `specify` already decided
+
+*Points to clarify* holds four different objects, and each one gets a different action from you.
+Treating all four as questions is how clarify re-asks what was already decided and disturbs what was
+deliberately deferred:
+
+| Type in the spec | What it means | Your action |
+| --- | --- | --- |
+| **pregunta abierta** | Formulable, unanswered | Ask it — this is your queue |
+| **suposición tomada** | `specify` decided it; the basis is written | **Validate**, don't re-ask: state the assumption and its basis back, and ask only whether it still holds |
+| **decisión diferida** | Sharp, out of this cycle on purpose | Leave it. Do not reopen scope the author closed |
+| **área no formulable** | Known to be coming, not yet phrasable | Note it. If your pass sharpens it into a real question, it graduates — say that it did |
+
+**Declare what you did with each entry.** Close the pass with one line per point: asked, validated
+(held / broke), left deferred, or graduated. An entry you silently dropped is the gap that comes back
+at implementation time.
+
+**An untyped entry** (an older spec, or a hurried one) is read as **pregunta abierta** — the
+costliest reading, so nothing gets skipped by accident. Type it as you go, so the spec improves on
+the way through.
+
+Sharpness, not difficulty, is what separates a question from an unformulable area: *can you state it
+precisely now?* Not *can you answer it?*
+
 ## The ambiguity taxonomy — where specs hide their gaps
 
 Scan the spec against these categories. Most real gaps fall into one of them; walking the list is how you find the ones the author didn't think to write down.
@@ -111,7 +135,7 @@ After baking back, the spec line becomes a bounded, testable behavior with accep
 
 ## Exit gate
 
-The gate is passed when the spec, constitution and profile were all read (settled questions cited, not re-asked); all ten taxonomy categories were considered; only the build-changing gaps were put to the user, as dial-sized decisions with recommendations; every answer is baked into the spec body with observable acceptance criteria, logged under `## Clarifications` and bounded under `## Out of scope`; and the final re-read opened no new gap.
+The gate is passed when the spec, constitution and profile were all read (settled questions cited, not re-asked); **every typed point in the handoff has its declared outcome** (asked / validated / left deferred / graduated), with nothing silently dropped; all ten taxonomy categories were considered; only the build-changing gaps were put to the user, as dial-sized decisions with recommendations; every answer is baked into the spec body with observable acceptance criteria, logged under `## Clarifications` and bounded under `## Out of scope`; and the final re-read opened no new gap.
 
 ## Result envelope
 

package/skills/constitution/references/constitution-template.md

@@ -40,7 +40,7 @@ version: v1.0.0
 
 7. Naming & structure: <directory layout, module boundaries, file naming>.
 8. API & errors: <error shape, status codes, response envelope> where applicable.
-9. Commit messages: <format, e.g. Conventional Commits>.
+9. Commit messages: <format, e.g. gitmoji + Conventional Commits — `✨ feat(scope): subject`>.
 
 ## 4. Branching & shipping
 

package/skills/git-workflow/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: git-workflow
-description: "Use when naming or scoping a branch, writing or fixing a commit message, untangling history (rebase versus merge versus squash), or cutting a versioned release — the portable git-convention layer for any repo. Covers Conventional Commits, SemVer tags, branch hygiene, force-push safety and gh pr/release mechanics. NOT the land-it decision and pre-ship checklist (that is `ship`), NOT an isolated checkout before coding (that is `worktrees`), NOT CI/CD release automation (that is `deployment`)."
-tags: [git, version-control, conventional-commits, semver, pull-request]
+description: "Use when naming or scoping a branch, writing or fixing a commit message, picking the gitmoji for a commit, untangling history (rebase versus merge versus squash), or cutting a versioned release — the portable git-convention layer for any repo. Covers gitmoji + Conventional Commits, SemVer tags, branch hygiene, force-push safety and gh pr/release mechanics. NOT the land-it decision and pre-ship checklist (that is `ship`), NOT an isolated checkout before coding (that is `worktrees`), NOT CI/CD release automation (that is `deployment`)."
+tags: [git, version-control, conventional-commits, gitmoji, semver, pull-request]
 recommends: [ship, worktrees, deployment, github-actions]
 origin: risco
 ---
@@ -44,12 +44,12 @@ Good  fix/expired-refresh-token-401
 Good  chore/bump-node-22
 ```
 
-## Conventional Commits grammar
+## Commit grammar — gitmoji + Conventional Commits
 
-Write every commit to **Conventional Commits 1.0.0**. The structure:
+Write every commit to **Conventional Commits 1.0.0**, opened by a **gitmoji**. The structure:
 
 ```text
-type(scope)!: subject
+<gitmoji> type(scope)!: subject
 
 body — what changed and why, wrapped, optional
 
@@ -57,6 +57,8 @@ BREAKING CHANGE: description of the incompatible change
 Fixes #123
 ```
 
+- The **gitmoji is mandatory** and comes first — the intention of the change, readable in one glyph
+  when you scan `git log --oneline`. `type` is what tooling reads; the emoji is what humans read.
 - `type` is mandatory. `scope` in parentheses is optional. `!` before the colon marks a breaking change.
 - Subject: imperative mood ("add", not "added"/"adds"), ≤72 chars, no trailing period.
 - Body explains *why*, not *what the diff already shows*. Separate from subject by a blank line.
@@ -74,23 +76,44 @@ Type → SemVer effect:
 `BREAKING CHANGE` **must be uppercase** in the footer; the type/scope units are case-insensitive but
 write them lowercase by convention.
 
+Type → gitmoji, the everyday set (the full 75-emoji table, and *why* the emoji never replaces the
+type, are in **`references/gitmoji.md`**):
+
+| Type       | gitmoji | Type       | gitmoji | Type      | gitmoji |
+|------------|---------|------------|---------|-----------|---------|
+| `feat`     | ✨      | `refactor` | ♻️      | `build`   | 📦️      |
+| `fix`      | 🐛      | `test`     | ✅      | `style`   | 🎨      |
+| `docs`     | 📝      | `perf`     | ⚡️      | `revert`  | ⏪️      |
+| `chore`    | 🔧      | `ci`       | 👷      | breaking  | 💥      |
+
+Pick by **intention**, not by which file changed, and prefer the specific one: 🚑️ for a production
+hotfix, 🩹 for a trivial non-critical fix, 🔥 for a deletion, 🚚 for a rename, ⬆️ for a dep bump,
+🔖 for a release commit.
+
 ```text
 Bad   fix stuff
 Bad   updates
 Bad   Fixed the login bug.            (past tense, capitalized, trailing period)
-Good  fix(auth): reject expired refresh tokens
-Good  feat(api): add /v2/search endpoint with cursor paging
-Good  refactor(parser): extract token scanner, no behavior change
+Bad   fix(auth): reject expired refresh tokens        (no gitmoji)
+Bad   ✨ added a search endpoint                       (gitmoji but no type → no derivable bump)
+Good  🐛 fix(auth): reject expired refresh tokens
+Good  ✨ feat(api): add /v2/search endpoint with cursor paging
+Good  ♻️ refactor(parser): extract token scanner, no behavior change
 ```
 
 A breaking change, both forms equivalent:
 
 ```text
-feat(api)!: drop the legacy /v1 search endpoint
+💥 feat(api)!: drop the legacy /v1 search endpoint
 
 BREAKING CHANGE: /v1/search is removed; callers must migrate to /v2/search.
 ```
 
+If the repo runs a **strict** conventional parser (commitlint, semantic-release) it anchors the type
+at position 0 and rejects the emoji prefix. Either widen its `headerPattern` — the config is in
+`references/gitmoji.md` — or move the emoji behind the header (`feat(api): ✨ add cursor paging`),
+which every parser accepts. Both forms satisfy this convention; dropping the gitmoji does not.
+
 **Authorship is always Eric.** Never add a `Co-Authored-By: Claude` trailer, never a
 "Generated with" footer, never any line crediting an AI tool — in a commit *or* a PR body. The work
 is Eric's; the agent is a tool, like the compiler.
@@ -103,7 +126,7 @@ Decide by who else has the commits. The lease rule below is non-negotiable.
 |------------------------------------------------------|------------------------------------------------------|------------------------------------------------------------|
 | Private branch, only you have it, want linear history | `git rebase main`, then `git push --force-with-lease`| rebase rewrites hashes; safe because nobody built on them  |
 | Branch others have pulled / built on                  | `git merge main` — **never** rebase it               | rebase changes every hash; collaborators' work diverges    |
-| Noisy PR (many `wip` commits)                         | squash-merge into one conventional commit            | `main` gets one meaningful entry, not 9 scratch commits    |
+| Noisy PR (many `wip` commits)                         | squash-merge into one gitmoji + conventional commit            | `main` gets one meaningful entry, not 9 scratch commits    |
 | Already pushed, shared, *and* you rewrote it          | **STOP** — coordinate, or `git revert` instead       | force-pushing shared history breaks everyone downstream     |
 
 After a rebase, push with `--force-with-lease`, never bare `--force`:
@@ -168,7 +191,8 @@ enough to hand over. Setting up the isolated checkout *before* you start coding
 | Anti-pattern                                          | Why it hurts                                              | Instead                                              |
 |-------------------------------------------------------|-----------------------------------------------------------|------------------------------------------------------|
 | `git push --force` on a shared branch                 | silently erases teammates' commits                        | `--force-with-lease`, or don't rewrite shared history |
-| `git commit -m "wip"` / `"fix"` / `"updates"`         | the log carries zero signal for the next reader           | conventional `type(scope): imperative subject`        |
+| `git commit -m "wip"` / `"fix"` / `"updates"`         | the log carries zero signal for the next reader           | `<gitmoji> type(scope): imperative subject`           |
+| Commit message with no gitmoji                         | `git log --oneline` reads as a wall of undifferentiated text | pick the intention's emoji (`references/gitmoji.md`) |
 | Mixing unrelated changes in one commit                | can't revert or review one concern in isolation           | one logical change per commit                         |
 | Long-lived branch (weeks)                             | diverges from `main`, merge becomes a battle              | short-lived; rebase or merge `main` in often          |
 | Hand-computing the semver bump                        | breaking change shipped as a MINOR → broken downstream    | derive the bump from the commit log                   |
@@ -183,7 +207,7 @@ enough to hand over. Setting up the isolated checkout *before* you start coding
 
 - [ ] Working tree clean (`git status`), no stray or generated files staged.
 - [ ] Branch rebased on / merged with current `main`; no avoidable conflicts.
-- [ ] Every commit is conventional; `wip`/scratch commits squashed away.
+- [ ] Every commit carries its gitmoji **and** a conventional header; `wip`/scratch commits squashed away.
 - [ ] No secrets, no AI-attribution trailers.
 - [ ] PR body explains the why and links the issue (`Fixes #`).
 - [ ] (Release) version bump **derived from the commit log**, tag is `vX.Y.Z`, annotated.

package/skills/git-workflow/evals/cases.yaml

@@ -13,6 +13,10 @@ should_trigger:
     why: Spanish trigger covering history cleanup plus conventional-commit formatting.
   - prompt: "Name a branch for the OAuth PKCE work"
     why: Branch-naming convention — feat/ prefix plus kebab slug from intent.
+  - prompt: "Which gitmoji goes on this commit — I deleted a deprecated module"
+    why: Gitmoji selection by intention (🔥 remove code, not ♻️ refactor); the commit-grammar layer owns the emoji.
+  - prompt: "Mi commitlint rechaza el commit por el emoji delante del type"
+    why: Spanish; the strict-parser escape hatch (widen headerPattern or move the emoji behind the header) lives in this skill.
   - prompt: "Tag v2.1.0 and write the release notes"
     why: Release mechanics — annotated tag plus gh release create --generate-notes.
 
@@ -41,6 +45,7 @@ capability:
     must_include:
       - Collapses the two "wip" commits via squash or fixup and explains why (one meaningful entry in main).
       - Identifies a feat commit and a BREAKING CHANGE footer written in uppercase.
+      - Every proposed commit message opens with a gitmoji (✨ for the feature, 💥 for the breaking removal) before the conventional header.
       - Bump is MAJOR because of the breaking change, with a tag of the form vX.0.0.
       - Uses gh release create vX.0.0 --generate-notes (or an equivalent that produces notes).
       - Uses git push --force-with-lease (not bare --force) for the post-rebase push.