@damiangilgonzalez/harness 1.3.23 → 1.3.25

package/README.md

@@ -61,6 +61,23 @@ Todo confluye en una rama de integración.
 `code-review` revisa contra los estándares del repo y contra la spec. `pr` abre la PR con
 resumen, evidencia y peligro de fusión.
 
+### Seguridad y front dentro de la cadena
+
+La cadena no cambia: ni pasos nuevos ni comandos nuevos. Lo que cambia es que dos pasos que ya
+existían ahora piden seguridad y front **cuando el cambio los toca** (auth, un endpoint, una tabla,
+un secreto o una pantalla):
+
+| Cuándo | Qué pasa |
+|---|---|
+| Al iniciar sesión | Un aviso corto según el proyecto. Con backend, API o `.env`: los 10 puntos de seguridad. Con react, next, vue, svelte o astro: el modelo mental del front. Sin ninguno de los dos, no sale nada. |
+| `to-spec` | La spec lleva una sección «Decisiones de seguridad y de front»: qué puntos aplican y cuáles quedan fuera a propósito. |
+| `code-review` | El eje de Estándares suma un baseline: una ruta sin rate limit o sin validación en el servidor es `should-fix`; un secreto en el repo es `blocker`. |
+| Antes de publicar | `secure-coding` trae la lista con una prueba por punto. Es un punto de partida; la auditoría es `hardening`. |
+
+Los 10 puntos: rate limiting, claves fuera del código, secretos de producción en la plataforma,
+límites por IP, entradas validadas, validación en el servidor, RLS, contraseñas con hash y datos
+cifrados, sesiones que vencen y CORS solo con tu dominio. Se apaga con `.rsc/.no-stack-hints`.
+
 La guía completa del método, fase a fase: [`docs/skills/`](docs/skills/).
 
 ---
@@ -107,7 +124,7 @@ Empiezas pequeño. El resto se carga bajo demanda: el harness te propone una ski
 la pide, con la evidencia que lo justifica.
 
 ```bash
-rsc install --profile minimal   # la base: orient + suggest + bro + unslop + show-me + eli5 + harness + init + teach + tunel-ngrok + hardening
+rsc install --profile minimal   # la base: orient + suggest + bro + unslop + show-me + eli5 + harness + init + teach + tunel-ngrok + hardening + no-me-rayes
 rsc install --profile core      # la base + el método completo
 rsc install --profile full      # todo el catálogo
 ```
@@ -128,10 +145,10 @@ Hooks que vigilan por ti: recuerdan la cadena, piden confirmación antes de un `
 
 ![Plugins de serie: superpowers, skins, savvy-progress y cache-tax](docs/img/readme/readme-16-plugins.png)
 
-En Claude Code quedan activados `skins`, `savvy-progress` y `cache-tax`
-(mantiene caliente la caché, y eso gasta tokens). `superpowers` llega cuando el proyecto usa el método.
+En Claude Code quedan activados `skins`, `savvy-progress`, `context-bar`, `prompt-enhancer`, `modelo-justo`,
+`where-am-i` y `cache-tax` (este mantiene caliente la caché, y eso gasta tokens). `superpowers` llega cuando el proyecto usa el método.
 
-En cifras: 296 skills, 34 agentes y 43 entradas de comando, para 17 asistentes
+En cifras: 297 skills, 34 agentes y 43 entradas de comando, para 17 asistentes
 (Claude Code, Codex, Cursor, Copilot, Gemini…). Detalle en la [referencia técnica](docs/referencia-tecnica.md).
 
 ---
@@ -249,9 +266,9 @@ Guía completa: [la memoria del harness](docs/como-funciona/memoria.md).
 
 ## Catálogo
 
-![296 skills por dominio](docs/img/readme/readme-15-catalogo.png)
+![297 skills por dominio](docs/img/readme/readme-15-catalogo.png)
 
-296 skills en 25 dominios: software, negocio, contenido, datos e IA.
+297 skills en 25 dominios: software, negocio, contenido, datos e IA.
 Cada una se activa sola cuando la tarea encaja.
 
 **[Ver el catálogo completo →](docs/catalogo.md)** · [Referencia técnica](docs/referencia-tecnica.md) ·

package/manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "1.3.23",
+  "version": "1.3.25",
   "counts": {
-    "skills": 296,
+    "skills": 297,
     "agents": 34,
     "commands": 43,
     "fixedCommands": 10
@@ -3532,6 +3532,30 @@
       ],
       "profiles": []
     },
+    {
+      "id": "no-me-rayes",
+      "description": "Use on EVERY reply and progress update, especially after tool work or a long task: the assistant must report in short bullet points what is done, what it is doing now, what blocks it, and a final summary, each marked with its own emoji. Cuts the wall-of-text answers some models give. NOT rewriting a text to sound human (that is `bro`), NOT a plain-language explanation (that is `eli5`), NOT a session handoff document (that is `handoff`).",
+      "tags": [
+        "no-me-rayes",
+        "concise",
+        "bullets",
+        "status-report",
+        "progress",
+        "emojis",
+        "short-answers"
+      ],
+      "recommends": [
+        "bro",
+        "eli5",
+        "handoff"
+      ],
+      "profiles": [
+        "minimal",
+        "core",
+        "ui",
+        "full"
+      ]
+    },
     {
       "id": "nodejs",
       "description": "Use when building or operating a plain Node.js / Express 5 backend service: project layout, async correctness, central error middleware, fail-fast config, graceful shutdown on SIGTERM. NOT DI modules/providers/guards (that is `nestjs`), NOT the type system or tsconfig (that is `typescript`), NOT REST contract design (that is `api-design`).",
@@ -4539,7 +4563,7 @@
     },
     {
       "id": "secure-coding",
-      "description": "Use when securing application code: threat-modeling a feature, security-reviewing a diff, hardening auth/authz, secrets, CORS/CSP, or fixing OWASP-class bugs (access control, injection, SSRF, supply chain) in FastAPI, Next.js, Go or Flutter. NOT running the scanners (that is security-scan), NOT agent prompt-injection guardrails (that is agent-safety).",
+      "description": "Use when securing application code: threat-modeling a feature, security-reviewing a diff, hardening auth/authz, secrets, CORS/CSP, running the pre-publish checklist (rate limiting, RLS, server-side validation) before shipping an AI-built project, or fixing OWASP-class bugs (access control, injection, SSRF, supply chain) in FastAPI, Next.js, Go or Flutter. NOT running the scanners (that is security-scan), NOT agent prompt-injection guardrails (that is agent-safety).",
       "tags": [
         "security",
         "owasp",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damiangilgonzalez/harness",
-  "version": "1.3.23",
+  "version": "1.3.25",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {

package/scripts/lib/default-skill-floor.js

@@ -6,7 +6,7 @@
 // without paying for its body on unrelated turns. `tunel-ngrok` y `hardening` son
 // obligatorias por decisión del usuario: van al suelo para que también lleguen con
 // el update a los proyectos que ya existían, no solo a las instalaciones nuevas.
-export const DEFAULT_SKILL_FLOOR = Object.freeze(['orient', 'suggest', 'bro', 'tunel-ngrok', 'hardening']);
+export const DEFAULT_SKILL_FLOOR = Object.freeze(['orient', 'suggest', 'bro', 'tunel-ngrok', 'hardening', 'no-me-rayes']);
 
 export function withDefaultSkillFloor(skillIds = []) {
   return [...new Set([...DEFAULT_SKILL_FLOOR, ...skillIds])];

package/scripts/lib/domains.js

@@ -27,7 +27,7 @@ export const DOMAINS = [
   { title: 'Motion & interface craft', ids: ['motion-craft', 'ui-engineering', 'variant-explorer'] },
   { 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', 'continuous-learning', 'skill-scout', 'context-budget', 'roast-me', 'show-me', 'eli5', 'fable-operator'] },
-  { title: 'Personal catalog — workflow (Spanish)', ids: ['grill-me', 'grill-with-docs', 'grilling', 'wayfinder', 'to-spec', 'to-tickets', 'to-questionnaire', 'implement', 'implement-spec', 'pr', 'retro', 'revision-de-cambios', 'code-review', 'research', 'prototype', 'domain-modeling', 'handoff', 'write-adr', 'wait-what', 'writing-for-agents', 'claude-project-setup', 'muscle-memory', 'teach', 'tunel-ngrok', 'hardening'] },
+  { title: 'Personal catalog — workflow (Spanish)', ids: ['grill-me', 'grill-with-docs', 'grilling', 'wayfinder', 'to-spec', 'to-tickets', 'to-questionnaire', 'implement', 'implement-spec', 'pr', 'retro', 'revision-de-cambios', 'code-review', 'research', 'prototype', 'domain-modeling', 'handoff', 'write-adr', 'wait-what', 'writing-for-agents', 'claude-project-setup', 'muscle-memory', 'teach', 'tunel-ngrok', 'hardening', 'no-me-rayes'] },
   { title: 'Personal catalog — interface design (Spanish)', ids: ['flujo-interfaz', 'animar', 'diseno-apple', 'diseno-landing', 'ingeniero-diseno-web', 'leyes-de-percepcion', 'leyes-de-retencion', 'mejor-accesibilidad', 'mejor-colores', 'mejor-layout', 'mejor-redaccion', 'mejor-tipografia', 'mejor-ui', 'sitios-calidad-premio', 'tastemaker', 'video-a-superprompt', 'vocabulario-animacion', 'revision-interfaz'] },
 ];
 

package/skills/code-review/SKILL.md

@@ -60,6 +60,15 @@ Cada smell se lee *qué es* → *cómo arreglarlo*; contrástalo con el diff:
 - **Intermediario (Middle Man)** — una clase o función que casi solo delega hacia adelante. → córtala, llama al objetivo real directamente.
 - **Herencia rechazada (Refused Bequest)** — una subclase o implementador que ignora o sobrescribe casi todo lo que hereda. → suelta la herencia, usa composición.
 
+### Baseline de seguridad y de front
+
+Cuando el diff toca una ruta, un endpoint, una tabla, un secreto, una sesión o un componente, el eje de Estándares lleva además este baseline. Es un juicio, no una violación dura, y un estándar documentado del repo lo supera. Pégalo completo en el prompt del sub-agente, que no tiene otro acceso a él:
+
+- **Seguridad** (los 10 puntos de `secure-coding`, `references/pre-publish.md`). Una ruta nueva sin rate limit o sin validación en el servidor es un hallazgo `should-fix`, no un nit. Un secreto en el repo o con el prefijo público del framework es `blocker`. Mira también: tabla nueva sin RLS, CORS con `*` y credenciales, hash débil, sesión que no vence, consulta SQL construida a mano.
+- **Front** (`react` y `nextjs`). Estado copiado desde props o derivado guardado en `useState`, `useEffect` que calcula en vez de sincronizar, dependencias que faltan, valores no deterministas en el primer render (`Date.now()`, `Math.random()`, `window`) que rompen la hidratación, `"use client"` demasiado arriba y secretos importados desde un componente de cliente.
+
+Si el diff no toca nada de esto, no lo añadas.
+
 ### 4. Lanzar ambos sub-agentes en paralelo
 
 Envía un único mensaje con dos llamadas a la herramienta `Agent`. Usa el subagente `general-purpose` para ambos.
@@ -67,7 +76,7 @@ Envía un único mensaje con dos llamadas a la herramienta `Agent`. Usa el subag
 **Prompt del sub-agente de Estándares** — incluye:
 
 - El comando de diff completo y la lista de commits.
-- La lista de archivos-fuente de estándares que encontraste en el paso 3, **más el smell baseline del paso 3 pegado completo** — el sub-agente no tiene otro acceso a él.
+- La lista de archivos-fuente de estándares que encontraste en el paso 3, **más el smell baseline del paso 3 pegado completo, y el baseline de seguridad y de front cuando aplique** — el sub-agente no tiene otro acceso a él.
 - El encargo: "Reporta — por archivo/hunk donde proceda — (a) cada lugar donde el diff viola un estándar documentado: cita el estándar (archivo + la regla); y (b) cualquier smell del baseline que detectes: nómbralo y cita el hunk. Distingue violaciones duras de juicios — las infracciones de estándar documentado pueden ser duras, pero los smells del baseline son siempre juicios, y un estándar documentado del repo prevalece sobre el baseline. Sáltate lo que el tooling imponga. Menos de 400 palabras."
 
 **Prompt del sub-agente de Spec** — incluye:

package/skills/hardening/zonas.md

@@ -66,7 +66,15 @@ Encargo de cada subagente del paso 2 de [`SKILL.md`](SKILL.md). Copia el **marco
   - longitud de los textos;
   - inyección de prompt con efecto en las herramientas;
   - fórmulas en el Excel.
-- Límite de peticiones y de gasto.
+- Límite de peticiones y de gasto:
+  - por IP y por identidad, con la IP real tras el proxy;
+  - más estricto en login, OTP, registro y endpoints que cuestan dinero;
+  - un contador en memoria no vale con más de una réplica.
+- Validación en el servidor, no solo en el navegador: rehacer a mano la petición con el campo que el formulario bloquearía.
+- Sesiones que vencen, rotación del refresh y cookie `HttpOnly`/`Secure`/`SameSite`.
+- Contraseñas con hash fuerte (Argon2id o bcrypt) y datos sensibles cifrados.
+- CORS con lista de orígenes, nunca `*` con credenciales.
+- Secretos de producción en la plataforma (Vercel, Supabase, GitHub), nunca solo en `.env` ni en el repo.
 - Errores que filtran detalles internos, cabeceras, CSP y CORS.
 - Front: `innerHTML` y dónde se guarda la sesión.
 - Dependencias: si están fijadas y si algo las escanea. `npm audit` se puede lanzar porque solo lee.

package/skills/nextjs/SKILL.md

@@ -334,6 +334,8 @@ const r = schema.safeParse(Object.fromEntries(formData));
 if (!r.success) return { status: "error", message: "Invalid" };
 ```
 
+Server vs Client placement, what breaks hydration and the stable-first-render fix: `references/rendering-hydration.md`.
+
 ## Auth & security (deep dive → references/security.md)
 
 Defense in depth with **three layers — middleware is NOT one of them**. Full wiring (Auth.js v5

package/skills/nextjs/references/rendering-hydration.md

@@ -0,0 +1,53 @@
+# Rendering and hydration in the App Router
+
+Short version of the five-word model (component, state, hooks, rendering, hydration) applied to
+Next.js. The generic model is in `../../react/references/mental-model.md` when `react` is installed.
+
+## Where each piece runs
+
+| Piece | Runs | Can use | Cannot use |
+|---|---|---|---|
+| **Server Component** (default) | Server only, at request or build time | `await`, DB, secrets, `fs` | state, effects, event handlers, browser APIs |
+| **Client Component** (`"use client"`) | Server for the first HTML **and** the browser after | state, effects, handlers | secrets (anything it imports ships to the browser) |
+| **Server Action** (`"use server"`) | Server, called from the browser | DB, secrets | trusting its input: it is a public endpoint |
+
+## Hydration, step by step
+
+1. The server renders the component tree to HTML and streams it.
+2. The browser paints that HTML (fast, not yet interactive).
+3. The JS loads and React **hydrates**: it renders the client components again and expects the
+   *same* output to attach handlers to the existing DOM.
+4. If the output differs, React warns (and may discard and re-render the subtree).
+
+## What breaks hydration
+
+- `Date.now()`, `new Date()` formatting, `Math.random()`, `crypto.randomUUID()` in the render body.
+- `typeof window !== "undefined"` branches that change the markup.
+- Locale/time-zone formatting that differs between server and browser.
+- Invalid nesting (`<div>` inside `<p>`, `<a>` inside `<a>`) that the browser "fixes" before React looks.
+- Reading `localStorage`/`matchMedia` during render.
+
+**Fix pattern:** render a stable first output, then update after mount.
+
+```tsx
+"use client";
+import { useEffect, useState } from "react";
+
+export function LocalTime({ iso }: { iso: string }) {
+  const [text, setText] = useState(iso);          // same on server and first client render
+  useEffect(() => setText(new Date(iso).toLocaleString()), [iso]); // browser-only, after hydration
+  return <time dateTime={iso}>{text}</time>;
+}
+```
+
+For values that must exist in render and legitimately differ (theme from a cookie), read them on
+the server and pass them down, so both sides agree.
+
+## Rules
+
+- Keep `"use client"` as deep (as leaf-like) as possible; a client boundary drags its imports into
+  the bundle.
+- Pass the client component data, not the secret that produced it.
+- Treat every Server Action and Route Handler as a public API: authenticate, authorize the object
+  and validate the input again. See `secure-coding` (the 10 holes, points 5–7).
+- `suppressHydrationWarning` is for a single known-different text node, never a blanket fix.

package/skills/no-me-rayes/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: no-me-rayes
+description: "Use on EVERY reply and progress update, especially after tool work or a long task: the assistant must report in short bullet points what is done, what it is doing now, what blocks it, and a final summary, each marked with its own emoji. Cuts the wall-of-text answers some models give. NOT rewriting a text to sound human (that is `bro`), NOT a plain-language explanation (that is `eli5`), NOT a session handoff document (that is `handoff`)."
+tags: [no-me-rayes, concise, bullets, status-report, progress, emojis, short-answers]
+recommends: [bro, eli5, handoff]
+profiles: [minimal, core, ui, full]
+origin: damiangil
+---
+
+# No me rayes
+
+Hay modelos que hablan demasiado. El usuario no quiere párrafos: quiere ver de un vistazo qué pasó. Esta skill se aplica **siempre**, en cada respuesta que cuente trabajo, y la forma no se negocia.
+
+## Formato obligatorio
+
+Cada bloque lleva su emoji y sus viñetas. Una viñeta, una idea, una línea.
+
+```
+✅ Hecho
+- Creé `skills/no-me-rayes/SKILL.md`
+- Pasé los tests de la base
+
+🔄 Ahora
+- Regenerando el manifest
+
+⛔ Bloqueos
+- Falta el token de ngrok en `.env`
+
+📌 Resumen
+- La skill ya está en la base; falta regenerar el manifest
+- Necesito el token para seguir con el túnel
+```
+
+| Bloque | Emoji | Qué va dentro |
+| --- | --- | --- |
+| Hecho | ✅ | Lo que ya está terminado y comprobado. |
+| Ahora | 🔄 | Lo que haces en este momento. Una cosa, no tu plan entero. |
+| Bloqueos | ⛔ | Lo que te frena y qué necesitas del usuario para seguir. |
+| Resumen | 📌 | Dos o tres viñetas con lo esencial, para quien solo lea esto. |
+
+## Reglas
+
+1. **Viñetas, nunca párrafos.** Ninguna viñeta pasa de una línea. Si no cabe, se parte en dos viñetas.
+2. **Solo los bloques que tengan algo.** Si no hay bloqueos, no escribas «Bloqueos: ninguno»: omite el bloque. `📌 Resumen` va siempre al final.
+3. **Resumen al cerrar un trabajo largo.** Tras varios pasos o herramientas, `📌 Resumen` es lo que el usuario lee de verdad: que se entienda sin subir.
+4. **Lo hecho es lo comprobado.** No pongas ✅ a algo que no has ejecutado o verificado; va en 🔄 o se dice que no se probó.
+5. **El bloqueo lleva su salida.** Cada ⛔ dice qué hace falta y de quién, no solo que algo falla.
+6. **Sin relleno.** Nada de «Claro, voy a…», ni de repetir lo que ya se vio en la herramienta, ni de cerrar con un párrafo de cortesía.
+7. **Código, rutas y comandos van exactos**, entre comillas inversas; no se resumen ni se parafrasean.
+8. **Una pregunta de una frase o una respuesta de una línea** no necesita los bloques: responde en una línea. Los bloques son para contar trabajo.
+
+## Cómo convive con el resto
+
+- **`orient`** cierra cada turno con su bloque-brújula (📍 ✅ 🧭 ➡️). Esta skill manda sobre **el cuerpo** de la respuesta; la brújula va después, sin repetir lo que ya dijo `✅ Hecho`.
+- **`bro`** reescribe un texto para que suene humano; **`eli5`** explica sin jerga. Si el usuario los pide, mandan ellos sobre el contenido; el formato de viñetas se mantiene.
+- **`handoff`** genera un documento de traspaso para otro agente; esto es el parte del turno, no ese documento.
+
+## Hecho cuando
+
+La respuesta se entiende leyendo solo los emojis y la primera palabra de cada viñeta.

package/skills/no-me-rayes/evals/cases.yaml

@@ -0,0 +1,33 @@
+skill: no-me-rayes
+
+should_trigger:
+  - prompt: "Hablas demasiado, dime solo qué has hecho."
+    why: "Disparador directo de no-me-rayes."
+  - prompt: "No me rayes con párrafos, ponlo en viñetas."
+    why: "Disparador directo de no-me-rayes."
+  - prompt: "Dame un parte de cómo va la tarea: qué está hecho, qué haces ahora y qué te bloquea."
+    why: "Disparador directo de no-me-rayes."
+  - prompt: "Acabas de tocar siete archivos. Resúmelo en viñetas con emojis."
+    why: "Disparador directo de no-me-rayes."
+  - prompt: "Your answers are too long; give me done, doing and blocked as short bullets."
+    why: "Disparador directo de no-me-rayes."
+
+should_not_trigger:
+  - prompt: "Reescribe este correo para que suene más natural y humano."
+    route_to: "bro"
+    why: "Reescribir un texto para que suene humano es el trabajo de bro, no de no-me-rayes."
+  - prompt: "Explícame qué es un túnel como si tuviera cinco años."
+    route_to: "eli5"
+    why: "Explicar sin jerga es el trabajo de eli5, no de no-me-rayes."
+  - prompt: "Prepara un documento de traspaso para que otro agente continúe esta conversación."
+    route_to: "handoff"
+    why: "El documento de traspaso entre agentes es el trabajo de handoff, no de no-me-rayes."
+  - prompt: "Haz una retrospectiva de esta sesión y dime qué cambiar en el entorno del agente."
+    route_to: "retro"
+    why: "La retrospectiva de una sesión es el trabajo de retro, no de no-me-rayes."
+
+capability:
+  - scenario: "El agente acaba de hacer varios cambios y debe contárselo al usuario."
+    must_include:
+      - "✅"
+      - "📌"

package/skills/react/SKILL.md

@@ -36,6 +36,8 @@ Adjacent jobs route out: the type system itself (generics, discriminated unions,
 
 ## Component & state architecture
 
+The five words behind most front-end bugs (component, state, hooks, rendering, hydration) and a symptom → cause table: `references/mental-model.md`.
+
 - **Colocate state** next to where it's used; only **lift** when two siblings must share it. Lifting earlier than needed is the #1 cause of re-render spread.
 - **Derive, don't duplicate.** If a value is computable from props/state, compute it in render — never mirror it into another `useState` synced by an effect.
 - **Context for low-frequency, wide values** (theme, current user, locale). It re-renders every consumer on every change.

package/skills/react/references/mental-model.md

@@ -0,0 +1,38 @@
+# The front-end mental model — five words that explain most bugs
+
+Frameworks change every few months; these five ideas do not. When something on screen is wrong,
+find which of the five is misplaced before touching code.
+
+| Word | What it is | The mistake it explains |
+|---|---|---|
+| **Component** | A function that takes props and returns UI. A boundary, not a file. | One giant component that fetches, formats and renders: nothing reusable, everything re-renders. |
+| **State** | Data that changes over time and that the screen must reflect. | State copied from props, or derived values stored (`fullName` in `useState`) and left to drift. |
+| **Hooks** | The way a function component remembers (`useState`) or reaches outside itself (`useEffect`). | Effects used to *compute* things (derive in render instead), missing/extra dependencies, hooks called in conditions. |
+| **Rendering** | Running your component to produce a description of the UI; React diffs it and updates the DOM. | Thinking render is a one-off: it runs on every state/prop change, so it must be pure and cheap. |
+| **Hydration** | In SSR/SSG, the server sends HTML; the browser then attaches React to it so it becomes interactive. | Server and client producing different output (`Date.now()`, `Math.random()`, `window`, locale formatting): hydration mismatch. |
+
+## Rules that follow
+
+- **State** goes to the outermost place that still needs it and no further (URL → server → shared
+  parent → component). See [`../SKILL.md`](../SKILL.md) and `ui-engineering`.
+- **Derive, don't mirror.** If it can be computed from props/state during render, compute it there.
+- **Render is pure.** No fetches, timers, `localStorage`, random or time reads in the body. Those
+  go in event handlers or effects.
+- **An effect is for synchronizing with something outside React** (a subscription, the DOM, a
+  network call). If you are using it to set state from other state, delete it.
+- **Hydration needs identical first output.** Anything that differs between server and browser
+  renders after mount (`useEffect` sets it) or is marked with `suppressHydrationWarning` only for
+  genuinely unavoidable text (a timestamp). Never use that flag to silence a real mismatch.
+- **Server vs client boundary** (frameworks with server components): data and secrets stay on the
+  server side; the client component gets only what it needs. A secret read in a client component
+  is public. See `secure-coding` hole 3 and 6.
+
+## Quick diagnosis
+
+| Symptom | Look first at |
+|---|---|
+| "Text content does not match server-rendered HTML" | Hydration: a non-deterministic value in the first render |
+| Value is one step behind / stale in a handler | State: closure over an old value; use the functional update or derive it |
+| Infinite re-render loop | Hooks: an effect that sets state it depends on |
+| Whole tree re-renders on every keystroke | State: it lives too high; colocate it or select a narrow slice |
+| Works on reload, breaks on navigation (or reverse) | State: it should be in the URL, or an effect ran once too often |

package/skills/secure-coding/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: secure-coding
-description: "Use when securing application code: threat-modeling a feature, security-reviewing a diff, hardening auth/authz, secrets, CORS/CSP, or fixing OWASP-class bugs (access control, injection, SSRF, supply chain) in FastAPI, Next.js, Go or Flutter. NOT running the scanners (that is security-scan), NOT agent prompt-injection guardrails (that is agent-safety)."
+description: "Use when securing application code: threat-modeling a feature, security-reviewing a diff, hardening auth/authz, secrets, CORS/CSP, running the pre-publish checklist (rate limiting, RLS, server-side validation) before shipping an AI-built project, or fixing OWASP-class bugs (access control, injection, SSRF, supply chain) in FastAPI, Next.js, Go or Flutter. NOT running the scanners (that is security-scan), NOT agent prompt-injection guardrails (that is agent-safety)."
 tags: [security, owasp, stride, auth, review]
 recommends: [deployment]
 origin: risco
@@ -291,6 +291,15 @@ export default { async headers() { return [{ source: "/:path*", headers }]; } };
 
 Full runbook: `references/secrets-and-supply-chain.md`.
 
+## Before publishing — the 10 holes
+
+Anything built fast with AI, before it goes public and again before each important launch: rate
+limiting, keys out of the code, production secrets in the platform, per-IP limits, validated and
+parameterized inputs, **validation on the server (the browser's is UX)**, RLS so each user sees only
+their data, hashed passwords and encrypted data, sessions that expire, CORS with only your domain.
+Each point has a concrete proof that it is closed, never "looks fine": `references/pre-publish.md`.
+It is a starting point, not an audit; the audit is [`hardening`](../hardening/SKILL.md).
+
 ## Anti-patterns
 
 | What gets said | Reality |

package/skills/secure-coding/references/pre-publish.md

@@ -0,0 +1,47 @@
+# Before publishing — the 10 holes
+
+A project built fast with AI ships the same ten holes again and again. This is a starting
+point, **not an audit** (the audit is [`hardening`](../../hardening/SKILL.md)). Run it before
+publishing and again before every important launch, about once a month.
+
+For each point: what goes wrong, how to **prove** it is closed (a command, a request, a query —
+never "looks fine"), and where the long version lives.
+
+| # | Hole | Prove it is closed |
+|---|---|---|
+| 1 | **Rate limiting** | Fire 20–50 requests in a few seconds at login, OTP, signup, search and any endpoint that costs money (LLM, email, SMS). Expect `429` well before the end. |
+| 2 | **Keys out of the code** | `gitleaks dir . --redact`; `git log -p -S"sk-" --all` for the history; `grep -rn "process.env" src` only reads names, never literals. `.env` is in `.gitignore` and not in `git ls-files`. |
+| 3 | **Production secrets in the platform** | The values live in Vercel / Supabase / GitHub Actions secrets, not in the repo or in a chat. Only `NEXT_PUBLIC_*` (or the framework's public prefix) reaches the browser: check that no secret carries it. |
+| 4 | **Limits per IP (and per identity)** | The limiter keys on IP **and** on user/session. Behind a proxy, it reads the real client IP (trusted `X-Forwarded-For` hop), not the proxy's. In-memory counters break with more than one replica: use Redis/KV. |
+| 5 | **Validated inputs, parameterized queries** | Every body, query and param passes a schema (Zod `.strict()`, Pydantic, validator) at the boundary. No string-built SQL: `grep -rnE "(query|execute)\(.*(\+|\\$\{)"`. Send `'; --` and `<script>` and see a `400`, not a `500`. |
+| 6 | **Validation on the server** | The browser validating is UX. Re-send the request by hand (`curl`, DevTools "Copy as cURL") with the field the form would have blocked. The server must refuse it. Server Actions and API routes are public. |
+| 7 | **RLS: each user sees only their data** | Every table exposed to the client has RLS **on** and a policy per operation. Log in as user A, request user B's row id: expect empty/`403`. `service_role` never ships to the browser. |
+| 8 | **Passwords hashed, data encrypted** | Argon2id (or bcrypt cost ≥ 12), never SHA-256/MD5, never plain. HTTPS only (HSTS). Sensitive columns (tokens, ids, health/payment data) encrypted at rest, and never written to logs. |
+| 9 | **Sessions that expire** | Short-lived access token, refresh rotation, `HttpOnly` + `Secure` + `SameSite` cookie, logout invalidates server-side. Check: a token from yesterday is rejected. |
+| 10 | **CORS only with your domain** | `Access-Control-Allow-Origin` is an explicit allowlist, never `*` with credentials. Check: `curl -H "Origin: https://evil.example" -I <api>` must not echo that origin back. |
+
+## The connection map (what each side may be trusted with)
+
+```
+Browser ──request──▶ Server ──query──▶ Database
+  │  validated here      │  validate AGAIN here     │  RLS decides here
+  └─ UX only             └─ the real gate           └─ last line of defence
+```
+
+An attacker never uses your browser: they replay or forge the request. Every check that lives
+only in the left box is decoration. Trust nothing that crossed the network; re-check identity,
+ownership and shape at the server, and let the database refuse what the server forgot.
+
+## How to use it in a task
+
+- **Writing code** that touches auth, an endpoint, a table or a secret: name which of the ten the
+  change affects and close it in the same change, with the proof above.
+- **Reviewing a diff** (`code-review`): any new route, table, env var or form must show its
+  matching rows. A route with no rate limit and no server validation is a finding, not a nit.
+- **Specifying a feature** (`to-spec`): the "Security" decisions section lists the rows that apply
+  and the ones that explicitly do not.
+- **Found a hole:** rotate the credential first, then fix the code, then add the test that fails
+  without the fix.
+
+Detail per topic: [`owasp-by-stack.md`](owasp-by-stack.md), [`authn-authz.md`](authn-authz.md),
+[`secrets-and-supply-chain.md`](secrets-and-supply-chain.md).

package/skills/to-spec/SKILL.md

@@ -61,6 +61,13 @@ NO incluyas rutas de archivo concretas ni snippets de código. Pueden quedar obs
 
 Excepción: si un prototipo produjo un snippet que codifica una decisión con más precisión que la prosa (máquina de estados, reducer, schema, forma de un tipo), inclúyelo dentro de la decisión correspondiente y anota brevemente que salió de un prototipo. Recórtalo a las partes ricas en decisión — no una demo funcional, solo lo importante.
 
+## Decisiones de seguridad y de front
+
+Solo si la feature toca autenticación, un endpoint, una tabla, un secreto o una pantalla. Si no toca nada de eso, escribe «No aplica» y por qué.
+
+- **Seguridad.** De los 10 puntos de `secure-coding` (`references/pre-publish.md`: rate limiting, claves fuera del código, secretos de producción, límites por IP, entradas validadas, validación en el servidor, RLS, hash y cifrado, sesiones que vencen, CORS), anota los que aplican a esta feature y los que quedan fuera a propósito. Cada uno que aplique se convierte en una historia de usuario o en un criterio de aceptación comprobable.
+- **Front.** Dónde vive el estado de cada pieza nueva (URL, servidor, padre compartido o componente), qué es componente de servidor y qué de cliente, y qué primer render debe ser idéntico en servidor y navegador (hidratación). Detalle en `react` y `nextjs` (`references/mental-model.md` y `references/rendering-hydration.md`).
+
 ## Decisiones de testing
 
 Una lista de las decisiones de testing tomadas. Incluye:

package/targets/claude.js

@@ -10,11 +10,17 @@ const HERE = dirname(fileURLToPath(import.meta.url));
 const SHELL_TOOLS = 'Bash|PowerShell';
 
 // Mods de la terminal de Claude Code que el harness deja activados en cada proyecto.
+// Los cuatro `@harness-mods` viven en este mismo repo (`mods/plugins/`, catálogo de los mods en
+// la raíz del repo): context-bar, prompt-enhancer, modelo-justo y where-am-i.
 // `cache-tax` mantiene caliente la caché del prompt en las pausas, y eso gasta tokens.
 export const CLAUDE_CODE_MODS = Object.freeze([
   { id: 'skins@hellosverre-mods', marketplace: 'hellosverre-mods', repo: 'hellosverre/claude-skins' },
   { id: 'savvy-progress@claude-kit', marketplace: 'claude-kit', repo: 'johnnyvizz/claude-kit' },
   { id: 'cache-tax@claude-code-mods', marketplace: 'claude-code-mods', repo: 'karanb192/claude-code-mods' },
+  { id: 'context-bar@harness-mods', marketplace: 'harness-mods', repo: 'damiangilgonzalez1995/rsc-harness' },
+  { id: 'prompt-enhancer@harness-mods', marketplace: 'harness-mods', repo: 'damiangilgonzalez1995/rsc-harness' },
+  { id: 'modelo-justo@harness-mods', marketplace: 'harness-mods', repo: 'damiangilgonzalez1995/rsc-harness' },
+  { id: 'where-am-i@harness-mods', marketplace: 'harness-mods', repo: 'damiangilgonzalez1995/rsc-harness' },
 ]);
 
 export function writeSkill(id, fromDir, toPath) {

package/targets/clone-bootstrap.mjs

@@ -43,7 +43,7 @@ const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/i;
  * nothing checks is just drift with a head start.
  */
 export const PROJECT_OPT_OUTS = [
-  'audit', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'knowledge-sync', 'ship-guard', 'trunk-guard', 'trunk-open', 'worktree-cleanup', 'worktree-isolation',
+  'audit', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'knowledge-sync', 'ship-guard', 'stack-hints', 'trunk-guard', 'trunk-open', 'worktree-cleanup', 'worktree-isolation',
 ];
 
 /**

package/targets/opt-outs.js

@@ -24,6 +24,7 @@ export const PROJECT_OPT_OUTS = [
   'gitmoji',          // the commit-message convention
   'knowledge-sync',   // 01-TOOLS/ + docs/ sync: one person off and the team stops seeing their work
   'ship-guard',       // branch/trunk discipline
+  'stack-hints',      // the session-start reminder that matches the stack (security floor, front-end model)
   'trunk-guard',      // «desbloquea main»: the default branch open for the agent, for the whole team
   'trunk-open',       // «ramas y PR»: the default branch closed even with nothing that looks complex
   'worktree-cleanup', // the reaper's notice (it only ever names, never acts)

package/targets/session-start.mjs

@@ -166,6 +166,53 @@ Originals are copied, never moved; deleting an emptied folder needs explicit con
   }
 }
 
+// Stack hints: a short reminder that matches what THIS project is made of, so it costs nothing
+// where it does not apply. The detail lives in the skills (`secure-coding`, `react`, `nextjs`);
+// these lines are only the part that must be present before anyone asks. Emitted once per session
+// (emitBody de-dups across scopes). Opt out with .rsc/.no-stack-hints.
+function readText(...p) { try { return readFileSync(join(root, ...p), 'utf8'); } catch { return ''; } }
+function stackOf() {
+  const pkg = readText('package.json');
+  const py = readText('pyproject.toml') + readText('requirements.txt');
+  const dep = (re) => re.test(pkg);
+  const front = dep(/"(react|preact|next|vue|nuxt|svelte|@sveltejs\/kit|solid-js|astro)"/);
+  const back = dep(/"(express|fastify|hono|koa|@nestjs\/core|next|@supabase\/supabase-js|prisma|@prisma\/client|drizzle-orm|firebase)"/)
+    || /fastapi|django|flask/i.test(py) || has('go.mod') || has('supabase')
+    || has('.env') || has('.env.local') || has('.env.example') || has('app', 'api') || has('pages', 'api');
+  return { front, back };
+}
+const skillIn = (id) => [root, homedir()].some((r) => existsSync(join(r, '.claude', 'skills', id, 'SKILL.md')));
+if (emitBody && !has('.rsc', '.no-stack-hints')) {
+  const { front, back } = stackOf();
+  if (back) {
+    process.stdout.write(`
+===== rsc security floor =====
+This project has a backend, an API or secrets. Before shipping, and in any change that touches auth,
+an endpoint, a table or a key, close these ten and PROVE each one (a request, a query, a command):
+rate limiting · keys out of the code (.env) · production secrets in the platform (Vercel, Supabase,
+GitHub) · limits per IP and per identity · validated inputs + parameterized queries · validation on
+the SERVER (the browser's is UX) · RLS: each user sees only their data · hashed passwords, encrypted
+data · sessions that expire · CORS only with your own domain.
+Browser validates -> server validates too -> database refuses what the server forgot.
+It is a starting point, not an audit.${skillIn('secure-coding') ? ' Detail and proofs: skill `secure-coding`, references/pre-publish.md. Audit: `hardening`.' : ''}
+Opt out with .rsc/.no-stack-hints.
+==============================
+`);
+  }
+  if (front) {
+    process.stdout.write(`
+===== rsc front-end model =====
+When building the front: component (a boundary, not a file) · state (outermost place that still
+needs it: URL, server, shared parent, component; derive, never mirror) · hooks (an effect syncs
+with the outside world, it does not compute) · rendering (pure, runs on every change) · hydration
+(server HTML and first client render must match: no Date.now/Math.random/window in render).
+Secrets and server-only data never go into a client component.${skillIn('react') || skillIn('nextjs') ? ' Detail: skills `react`, `nextjs` (references/mental-model.md, rendering-hydration.md).' : ''}
+Opt out with .rsc/.no-stack-hints.
+===============================
+`);
+  }
+}
+
 // Git required: version control is the substrate the SDD chain + ship guard assume.
 // If the project is not under git, push for it once per session. Persist the user's
 // "no" as .rsc/.no-git so the decision lives in a file and we stop re-asking.