refacil-sdd-ai 2.2.1 → 2.6.0

package/lib/compact/rules.js

@@ -0,0 +1,190 @@
+function hasFlagAfterBase(cmd, baseTokens) {
+  const tokens = cmd.trim().split(/\s+/);
+  return tokens.slice(baseTokens).some((t) => t.startsWith('-'));
+}
+
+function hasPipeOrRedirect(cmd) {
+  return /[|><]/.test(cmd);
+}
+
+const RULES = [
+  // --- Fase 1: git / tests / docker logs ---
+  {
+    id: 'git-log',
+    match: (cmd) =>
+      /^\s*git\s+log(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+log)/, '$1 --oneline -20'),
+    reason: 'git log → --oneline -20',
+    savedTokensEst: 850,
+  },
+  {
+    id: 'git-status',
+    match: (cmd) =>
+      /^\s*git\s+status(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+status)/, '$1 -s'),
+    reason: 'git status → -s',
+    savedTokensEst: 120,
+  },
+  {
+    id: 'git-diff',
+    match: (cmd) => /^\s*git\s+diff\s*$/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+diff)\s*$/, '$1 --stat'),
+    reason: 'git diff → --stat',
+    savedTokensEst: 400,
+  },
+  {
+    id: 'git-show',
+    match: (cmd) =>
+      /^\s*git\s+show(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    rewrite: (cmd) => cmd.replace(/^(\s*git\s+show)/, '$1 --stat'),
+    reason: 'git show → --stat',
+    savedTokensEst: 200,
+  },
+  {
+    id: 'docker-logs',
+    match: (cmd) => {
+      if (!/^\s*docker\s+logs(\s|$)/.test(cmd)) return false;
+      if (/\s--tail\b/.test(cmd)) return false;
+      if (/\s-n\s+\d/.test(cmd)) return false;
+      if (/\s--since\b/.test(cmd)) return false;
+      return true;
+    },
+    rewrite: (cmd) => cmd.replace(/^(\s*docker\s+logs)/, '$1 --tail 100'),
+    reason: 'docker logs → --tail 100',
+    savedTokensEst: 1500,
+  },
+  {
+    id: 'pkg-test',
+    match: (cmd) => /^\s*(npm|yarn|pnpm)\s+(test|t)\s*$/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -80`,
+    reason: 'test bare → tail -80',
+    savedTokensEst: 2400,
+  },
+  {
+    id: 'jest-bare',
+    match: (cmd) => /^\s*(npx\s+)?jest\s*$/.test(cmd),
+    rewrite: (cmd) =>
+      cmd.replace(/^(\s*(?:npx\s+)?jest)\s*$/, '$1 --silent --reporters=summary'),
+    reason: 'jest → silent summary',
+    savedTokensEst: 1800,
+  },
+  {
+    id: 'pytest-bare',
+    match: (cmd) => /^\s*pytest\s*$/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*pytest)\s*$/, '$1 -q'),
+    reason: 'pytest → -q',
+    savedTokensEst: 600,
+  },
+  // --- Fase 2A: linters / type checkers / build ---
+  {
+    id: 'eslint',
+    match: (cmd) => /^\s*eslint(\s+[^-]\S*)*\s*$/.test(cmd),
+    rewrite: (cmd) => {
+      const tokens = cmd.trim().split(/\s+/);
+      if (tokens.length === 1) {
+        return 'eslint . --format compact --quiet';
+      }
+      return `${cmd.trim()} --format compact`;
+    },
+    reason: 'eslint → --format compact',
+    savedTokensEst: 700,
+  },
+  {
+    id: 'biome-check',
+    match: (cmd) =>
+      /^\s*biome\s+check(\s|$)/.test(cmd) && !/--reporter\b/.test(cmd),
+    rewrite: (cmd) =>
+      cmd.replace(/^(\s*biome\s+check)/, '$1 --reporter=summary'),
+    reason: 'biome check → --reporter=summary',
+    savedTokensEst: 500,
+  },
+  {
+    id: 'tsc',
+    match: (cmd) => {
+      if (!/^\s*(npx\s+)?tsc(\s|$)/.test(cmd)) return false;
+      if (/(^|\s)--watch\b|(^|\s)-w\b/.test(cmd)) return false;
+      if (hasPipeOrRedirect(cmd)) return false;
+      return true;
+    },
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | head -80`,
+    reason: 'tsc → head -80',
+    savedTokensEst: 1200,
+  },
+  {
+    id: 'prettier-check',
+    match: (cmd) =>
+      /^\s*prettier\s+--check\b/.test(cmd) && !/--loglevel\b/.test(cmd),
+    rewrite: (cmd) =>
+      cmd.replace(/^(\s*prettier\s+--check)/, '$1 --loglevel warn'),
+    reason: 'prettier --check → --loglevel warn',
+    savedTokensEst: 300,
+  },
+  {
+    id: 'npm-audit',
+    match: (cmd) => /^\s*npm\s+audit\s*$/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -10`,
+    reason: 'npm audit → tail -10',
+    savedTokensEst: 900,
+  },
+  {
+    id: 'npm-ls',
+    match: (cmd) => /^\s*npm\s+ls\s*$/.test(cmd),
+    rewrite: (cmd) => cmd.replace(/^(\s*npm\s+ls)/, '$1 --depth=0'),
+    reason: 'npm ls → --depth=0',
+    savedTokensEst: 700,
+  },
+  {
+    id: 'cargo-bare',
+    match: (cmd) => /^\s*cargo\s+(build|test|check)\s*$/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} --quiet`,
+    reason: 'cargo → --quiet',
+    savedTokensEst: 400,
+  },
+  {
+    id: 'go-test',
+    match: (cmd) => {
+      if (!/^\s*go\s+test\b/.test(cmd)) return false;
+      const rest = cmd.trim().substring('go test'.length);
+      if (/\s-\S/.test(rest)) return false;
+      if (hasPipeOrRedirect(cmd)) return false;
+      return true;
+    },
+    rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -80`,
+    reason: 'go test → tail -80',
+    savedTokensEst: 1500,
+  },
+  {
+    id: 'mvn-test',
+    match: (cmd) => /^\s*mvn\s+test\s*$/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} -q`,
+    reason: 'mvn test → -q',
+    savedTokensEst: 1800,
+  },
+  {
+    id: 'gradle-test',
+    match: (cmd) => /^\s*(\.\/gradlew|gradle)\s+test\s*$/.test(cmd),
+    rewrite: (cmd) => `${cmd.trim()} -q`,
+    reason: 'gradle test → -q',
+    savedTokensEst: 1500,
+  },
+  {
+    id: 'ps-aux',
+    // Unix-only: en Windows `ps` mapea a PowerShell Get-Process y no entiende estos flags
+    match: (cmd) =>
+      process.platform !== 'win32' && /^\s*ps\s+aux\s*$/.test(cmd),
+    rewrite: () => 'ps -eo pid,pcpu,pmem,comm | head -30',
+    reason: 'ps aux → compact columns + head -30',
+    savedTokensEst: 800,
+  },
+];
+
+function findRule(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  if (/\bCOMPACT=0\b/.test(cmd)) return null;
+  for (const rule of RULES) {
+    if (rule.match(cmd)) return rule;
+  }
+  return null;
+}
+
+module.exports = { RULES, findRule };

package/lib/compact/telemetry.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME_DIR = path.join(os.homedir(), '.refacil-sdd-ai');
+const LOG_PATH = path.join(HOME_DIR, 'compact.log');
+const DISABLED_PATH = path.join(HOME_DIR, 'disabled');
+
+function ensureDir() {
+  try {
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+  } catch (_) {}
+}
+
+function isDisabled() {
+  return fs.existsSync(DISABLED_PATH);
+}
+
+function logRewrite(ruleId, savedTokensEst) {
+  try {
+    ensureDir();
+    const line =
+      JSON.stringify({
+        ts: new Date().toISOString(),
+        ruleId,
+        savedTokensEst: savedTokensEst || 0,
+      }) + '\n';
+    fs.appendFileSync(LOG_PATH, line);
+  } catch (_) {
+    // Telemetry must never break the hook
+  }
+}
+
+function readLog() {
+  try {
+    const content = fs.readFileSync(LOG_PATH, 'utf8');
+    return content
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch (_) {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+function stats() {
+  const entries = readLog();
+  const byRule = {};
+  let totalSaved = 0;
+  for (const e of entries) {
+    if (!byRule[e.ruleId]) byRule[e.ruleId] = { count: 0, saved: 0 };
+    byRule[e.ruleId].count++;
+    byRule[e.ruleId].saved += e.savedTokensEst || 0;
+    totalSaved += e.savedTokensEst || 0;
+  }
+  return { byRule, totalSaved, totalRewrites: entries.length };
+}
+
+function disable() {
+  ensureDir();
+  fs.writeFileSync(DISABLED_PATH, new Date().toISOString());
+}
+
+function enable() {
+  try {
+    fs.unlinkSync(DISABLED_PATH);
+  } catch (_) {}
+}
+
+function clearLog() {
+  try {
+    fs.unlinkSync(LOG_PATH);
+  } catch (_) {}
+}
+
+module.exports = {
+  HOME_DIR,
+  LOG_PATH,
+  DISABLED_PATH,
+  isDisabled,
+  logRewrite,
+  stats,
+  disable,
+  enable,
+  clearLog,
+};

package/lib/compact-guidance.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+const path = require('path');
+
+const MARKER_START = '<!-- refacil-sdd-ai:compact-guidance:start -->';
+const MARKER_END = '<!-- refacil-sdd-ai:compact-guidance:end -->';
+
+function readTemplate(packageRoot) {
+  const tplPath = path.join(packageRoot, 'templates', 'compact-guidance.md');
+  return fs.readFileSync(tplPath, 'utf8').trimEnd();
+}
+
+function buildBlock(templateContent) {
+  return `${MARKER_START}\n${templateContent}\n${MARKER_END}`;
+}
+
+function syncCompactGuidance(projectRoot, packageRoot) {
+  const agentsPath = path.join(projectRoot, 'AGENTS.md');
+  if (!fs.existsSync(agentsPath)) {
+    return { status: 'skipped-no-agents-md' };
+  }
+
+  const template = readTemplate(packageRoot);
+  const block = buildBlock(template);
+  const existing = fs.readFileSync(agentsPath, 'utf8');
+
+  const startIdx = existing.indexOf(MARKER_START);
+  const endIdx = existing.indexOf(MARKER_END);
+
+  let next;
+  let action;
+
+  if (startIdx === -1 || endIdx === -1) {
+    next = existing.trimEnd() + '\n\n' + block + '\n';
+    action = 'appended';
+  } else {
+    const before = existing.substring(0, startIdx);
+    const after = existing.substring(endIdx + MARKER_END.length);
+    next = before + block + after;
+    action = 'replaced';
+  }
+
+  if (next === existing) {
+    return { status: 'unchanged' };
+  }
+
+  fs.writeFileSync(agentsPath, next);
+  return { status: action };
+}
+
+function removeCompactGuidance(projectRoot) {
+  const agentsPath = path.join(projectRoot, 'AGENTS.md');
+  if (!fs.existsSync(agentsPath)) {
+    return { status: 'skipped-no-agents-md' };
+  }
+
+  const existing = fs.readFileSync(agentsPath, 'utf8');
+  const startIdx = existing.indexOf(MARKER_START);
+  const endIdx = existing.indexOf(MARKER_END);
+
+  if (startIdx === -1 || endIdx === -1) {
+    return { status: 'not-present' };
+  }
+
+  const before = existing.substring(0, startIdx).trimEnd();
+  const after = existing.substring(endIdx + MARKER_END.length);
+  const next = (before + '\n' + after.replace(/^\s+/, '')).trimEnd() + '\n';
+
+  fs.writeFileSync(agentsPath, next);
+  return { status: 'removed' };
+}
+
+module.exports = {
+  syncCompactGuidance,
+  removeCompactGuidance,
+  MARKER_START,
+  MARKER_END,
+};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "refacil-sdd-ai",
-  "version": "2.2.1",
+  "version": "2.6.0",
   "description": "SDD-AI: Specification-Driven Development with AI — metodologia de desarrollo con IA usando OpenSpec, Claude Code y Cursor",
   "bin": {
     "refacil-sdd-ai": "./bin/cli.js"
   },
   "files": [
     "bin/",
+    "lib/",
     "skills/",
     "templates/",
     "config/",

package/skills/apply/SKILL.md

@@ -8,10 +8,7 @@ user-invocable: true
 
 Este comando envuelve la funcionalidad de OpenSpec apply y agrega las convenciones del equipo.
 
-## Antes de empezar
-
-Lee `SKILL.md` en `.claude/skills/refacil-prereqs/` o `.cursor/skills/refacil-prereqs/` (misma skill en Claude Code y Cursor) y aplica el **perfil `openspec`** antes de continuar.
-Lee `METHODOLOGY-CONTRACT.md` en `refacil-prereqs` para reglas transversales del flujo.
+**Prerequisitos**: perfil `openspec` de `refacil-prereqs/SKILL.md` + reglas de `METHODOLOGY-CONTRACT.md`.
 
 ## Instrucciones
 
@@ -79,7 +76,6 @@ Al terminar la implementacion de OpenSpec, agrega este resumen:
 
 ## Reglas
 
-- NUNCA implementar codigo sin proposal, design, tasks y **especificacion** (`specs.md` y/o `specs/**/*.md` segun la tabla del Paso 0)
 - NUNCA generar artefactos SDD desde este comando — eso es responsabilidad exclusiva de `/refacil:propose`
-- SIEMPRE leer los artefactos completos antes de escribir codigo
+- Antes de implementar, cumplir las precondiciones del Paso 0 (artefactos completos) y del Paso 1 (rama de trabajo valida)
 - Si `openspec/changes/` no tiene cambios activos o estan incompletos, informar y redirigir a `/refacil:propose`

package/skills/archive/SKILL.md

@@ -8,10 +8,7 @@ user-invocable: true
 
 Este comando envuelve la funcionalidad de OpenSpec archive (que internamente llama a sync-specs) y agrega verificaciones previas del equipo.
 
-## Antes de empezar
-
-Lee `SKILL.md` en `.claude/skills/refacil-prereqs/` o `.cursor/skills/refacil-prereqs/` (misma skill en Claude Code y Cursor) y aplica el **perfil `openspec`** antes de continuar.
-Lee `METHODOLOGY-CONTRACT.md` en `refacil-prereqs` para reglas transversales del flujo.
+**Prerequisitos**: perfil `openspec` de `refacil-prereqs/SKILL.md` + reglas de `METHODOLOGY-CONTRACT.md`.
 
 ## Instrucciones
 

package/skills/bug/SKILL.md

@@ -8,10 +8,7 @@ user-invocable: true
 
 Eres un asistente especializado en investigacion y correccion de bugs. Guias al desarrollador por un flujo estructurado paso a paso.
 
-## Contexto
-
-Lee `SKILL.md` en `.claude/skills/refacil-prereqs/` o `.cursor/skills/refacil-prereqs/` (misma skill en Claude Code y Cursor) y aplica el **perfil `agents`** antes de continuar.
-Lee `METHODOLOGY-CONTRACT.md` en `refacil-prereqs` para reglas transversales del flujo.
+**Prerequisitos**: perfil `agents` de `refacil-prereqs/SKILL.md` + reglas de `METHODOLOGY-CONTRACT.md`.
 
 ## Instrucciones
 
@@ -29,52 +26,22 @@ Este flujo crea evidencia en `openspec/changes/`. Antes de continuar:
 
 ### Paso 1: Describir el bug
 
-Preguntale al usuario (si no lo proporciono en $ARGUMENTS):
-
-1. **Que esta pasando?** — Comportamiento actual (el error)
-2. **Que deberia pasar?** — Comportamiento esperado
-3. **Pasos para reproducir** — Como llegar al error
-4. **Evidencia** — Logs, screenshots, stack traces (pedir que los peguen)
-5. **Desde cuando ocurre?** — Siempre, desde un deploy, desde un cambio especifico
-6. **Severidad** — Critico (bloquea produccion), Alto, Medio, Bajo
-
-### Paso 2: Investigar la causa raiz
-
-Con la informacion del paso 1:
+Si `$ARGUMENTS` no los trae, pregunta al usuario: comportamiento actual, esperado, pasos de reproduccion, evidencia (logs/stack traces), cuando empezo a ocurrir, severidad (Critico/Alto/Medio/Bajo).
 
-1. **Buscar en el codebase**:
-   - Busca las funciones/archivos mencionados en los logs o stack traces
-   - Busca el flujo de datos del escenario que falla
-   - Revisa commits recientes si el bug es nuevo (`git log --oneline -20`)
+### Paso 2: Investigar causa raiz
 
-2. **Trazar el flujo**:
-   - Desde el punto de entrada (controller/endpoint) hasta donde falla
-   - Identifica cada componente en la cadena
-   - Busca donde se rompe la cadena
-
-3. **Formular hipotesis**:
-   - Presenta al usuario 1-3 hipotesis de causa raiz
-   - Para cada una, muestra el archivo y linea sospechosa
-   - Pide al usuario que confirme o descarte
+- Busca en codebase los simbolos/archivos de logs o stack traces.
+- Traza el flujo desde entrada (controller/endpoint) hasta el punto de falla.
+- Revisa commits recientes si el bug es nuevo: `git log --oneline -20`.
+- Presenta al usuario 1-3 hipotesis con archivo y linea sospechosa; pide que confirme o descarte.
 
 ### Paso 3: Diagnosticar
 
-Una vez confirmada la hipotesis:
-
-1. **Confirmar la causa raiz**: Muestra el codigo exacto que causa el bug
-2. **Explicar por que falla**: Que condicion o caso no esta manejado
-3. **Evaluar impacto**: Que mas podria estar afectado
+Con la hipotesis confirmada: muestra el codigo exacto que falla, explica que condicion no se maneja, evalua impacto en otras zonas.
 
 ### Paso 4: Proponer correccion
 
-Presenta la correccion propuesta:
-
-1. **Cambio minimo**: La correccion mas pequeña posible que resuelve el bug
-2. **Archivos a modificar**: Lista con descripcion del cambio
-3. **Riesgos**: Que podria romperse con el fix
-4. **Alternativas**: Si hay mas de una forma de corregirlo
-
-Espera aprobacion del usuario antes de implementar.
+Presenta: cambio minimo, archivos a modificar, riesgos, alternativas (si existen). Espera aprobacion antes de implementar.
 
 ### Paso 5: Validar rama de trabajo (antes de escribir codigo)
 

package/skills/explore/SKILL.md

@@ -8,9 +8,7 @@ user-invocable: true
 
 Este comando envuelve la funcionalidad de OpenSpec explore y agrega contexto del proyecto.
 
-## Antes de empezar
-
-Lee `SKILL.md` en `.claude/skills/refacil-prereqs/` o `.cursor/skills/refacil-prereqs/` (misma skill en Claude Code y Cursor) y aplica el **perfil `openspec`** antes de continuar (incluye el uso continuo de `AGENTS.md` durante la exploracion, segun ese archivo).
+**Prerequisitos**: perfil `openspec` de `refacil-prereqs/SKILL.md` — usa `AGENTS.md` como contexto activo durante toda la exploracion.
 
 ## Instrucciones
 

package/skills/prereqs/SKILL.md

@@ -4,39 +4,30 @@ description: Referencia interna — prerequisitos SDD-AI compartidos por el rest
 user-invocable: false
 ---
 
-# Prerequisitos SDD-AI (centralizado)
+# Prerequisitos SDD-AI
 
-La metodologia SDD-AI es **la misma** en **Claude Code** y **Cursor**: `refacil-sdd-ai init` instala copias equivalentes bajo `.claude/skills/refacil-*` y `.cursor/skills/refacil-*`. Usa la ruta del directorio que corresponda al IDE que tengas abierto.
+Metodologia identica en Claude Code (`.claude/skills/refacil-*`) y Cursor (`.cursor/skills/refacil-*`). Usa la ruta del IDE abierto.
 
-Las demas skills `refacil:*` remiten aqui para no duplicar instrucciones. **Lee esta skill cuando otra skill indique un perfil** y ejecuta los pasos en orden; si uno falla, **detente** y muestra al usuario el mensaje indicado.
-Ademas, lee y aplica `METHODOLOGY-CONTRACT.md` (misma carpeta) para reglas transversales: estados del flujo, politica de ramas, tests multi-stack y modo de salida.
+Reglas transversales (estados, ramas, tests, salida): `METHODOLOGY-CONTRACT.md` en esta misma carpeta.
 
-## Perfil `openspec` (OpenSpec + repo + AGENTS.md)
+## Perfil `openspec`
 
-Usar cuando la skill diga: *Aplica el perfil `openspec`.*
+Una skill pide este perfil cuando usa OpenSpec y necesita `AGENTS.md`. Estas validaciones son obligatorias en cada ejecucion de skill que declare este perfil.
 
-1. **OpenSpec instalado**: Ejecuta `openspec --version 2>&1`. Si el comando falla o no se reconoce, informa al usuario: "OpenSpec no esta instalado. Ejecuta `/refacil:setup` para instalarlo y configurar el repositorio." y **detente**.
+1. Verifica comando OpenSpec: `openspec --version 2>&1`. Si falla: *"OpenSpec no esta instalado o no esta en PATH. Ejecuta `/refacil:setup`"* y **detente**.
+2. Verifica `openspec/` en la raiz del repo. Si falta: *"OpenSpec no esta inicializado en este repo. Ejecuta `/refacil:setup`"* y **detente**.
+3. Lee `AGENTS.md` de la raiz. Si falta: *"No se encontro AGENTS.md. Ejecuta `/refacil:setup`"* y **detente**.
+4. Si un comando de OpenSpec falla despues, consulta `.claude/skills/refacil-setup/troubleshooting.md`.
+5. Si `AGENTS.md` incluye bloque `compact-guidance`, aplica esas reglas de eficiencia de tokens en toda la ejecucion.
 
-2. **OpenSpec inicializado**: Verifica que exista la carpeta `openspec/` en la raiz del proyecto. Si no existe, informa al usuario: "OpenSpec no esta inicializado en este repositorio. Ejecuta `/refacil:setup` para configurarlo." y **detente**.
+Caso especial: en `refacil:explore`, `AGENTS.md` es contexto activo durante toda la exploracion.
 
-3. **AGENTS.md**: Si existe `AGENTS.md` en la raiz del proyecto, leelo para entender convenciones, arquitectura y patrones. Si NO existe, informa al usuario: "No se encontro AGENTS.md. Ejecuta `/refacil:setup` para generarlo." y **detente**.
+## Perfil `agents`
 
-   - Si la skill activa es **`refacil:explore`**, usa lo leido en `AGENTS.md` como **contexto activo** durante toda la exploracion (no solo al inicio).
+Solo requiere `AGENTS.md`. Si existe, leelo y aplica `compact-guidance` si esta presente. Si falta: continua con baseline generico y avisa al usuario: *"No se encontro AGENTS.md; ejecuta `/refacil:setup` para reglas del proyecto."*
 
-## Perfil `agents` (solo AGENTS.md)
+## OPENSPEC-DELTAS.md
 
-Usar cuando la skill diga: *Aplica el perfil `agents`.*
+Convenciones Refacil al delegar a skills `openspec-*`: ver `OPENSPEC-DELTAS.md` (misma carpeta), leer junto a la skill OpenSpec que se invoque.
 
-Si existe `AGENTS.md` en la raiz del proyecto, leelo para entender convenciones, arquitectura y patrones.
-Si NO existe, informa al usuario: "No se encontro AGENTS.md. Continuare con baseline generico; para reglas del proyecto ejecuta `/refacil:setup`." y continua.
-
-## Ubicacion de este archivo
-
-En el repo del proyecto (elige segun herramienta):
-
-- Claude Code: `.claude/skills/refacil-prereqs/SKILL.md`
-- Cursor: `.cursor/skills/refacil-prereqs/SKILL.md`
-
-En la **misma carpeta** esta `OPENSPEC-DELTAS.md`: convenciones Refacil al delegar en skills `openspec-*` (leer junto a la skill OpenSpec indicada).
-
-Si ninguna existe, ejecuta `refacil-sdd-ai update` (o `init`).
+Si faltan estos archivos, ejecuta `refacil-sdd-ai update` (o `init`).

package/skills/propose/SKILL.md

@@ -8,9 +8,7 @@ user-invocable: true
 
 Este comando envuelve la funcionalidad de OpenSpec fast-forward (ff) y agrega las convenciones del equipo.
 
-## Antes de empezar
-
-Lee `SKILL.md` en `.claude/skills/refacil-prereqs/` o `.cursor/skills/refacil-prereqs/` (misma skill en Claude Code y Cursor) y aplica el **perfil `openspec`** antes de continuar.
+**Prerequisitos**: perfil `openspec` de `refacil-prereqs/SKILL.md` + reglas de `METHODOLOGY-CONTRACT.md`.
 
 ## Instrucciones
 

package/skills/review/SKILL.md

@@ -8,12 +8,9 @@ user-invocable: true
 
 Eres un reviewer exigente pero constructivo que evalua el codigo contra el checklist de calidad del equipo.
 
-## Contexto
+**Prerequisitos**: perfil `agents` de `refacil-prereqs/SKILL.md` + modo de salida de `METHODOLOGY-CONTRACT.md`.
 
-Lee `SKILL.md` en `.claude/skills/refacil-prereqs/` o `.cursor/skills/refacil-prereqs/` (misma skill en Claude Code y Cursor) y aplica el **perfil `agents`** antes de continuar.
-Lee `METHODOLOGY-CONTRACT.md` en `refacil-prereqs` y aplica el modo de salida definido ahi.
-
-### Cargar checklists
+## Checklists a cargar
 
 1. **Siempre** lee el checklist general: [checklist.md](checklist.md)
 2. **Detecta el tipo de proyecto** inspeccionando dependencias, `AGENTS.md`, o la estructura del repo:
@@ -77,62 +74,27 @@ Usa severidad para priorizar correcciones, no para inflar el reporte.
 
 ### Paso 4: Reporte
 
+Por defecto, usa salida **concisa** (segun `METHODOLOGY-CONTRACT.md`):
+
 ```
 === Review Report ===
-
 VEREDICTO: APROBADO | APROBADO CON OBSERVACIONES | REQUIERE CORRECCIONES
 BLOCKERS: [si/no]
 
-## Hallazgos priorizados (solo FAIL)
+## Hallazgos priorizados (solo FAIL, maximo 5)
 1. [CRITICO|ALTO|MEDIO|BAJO] [seccion/item] — [problema]
    - Evidencia: [archivo/rango o comportamiento]
    - Correccion sugerida: [accion concreta]
 
-## Checklist General
-- Alcance y foco: [PASS/FAIL/N/A]
-- Conformidad con Spec: [PASS/FAIL/N/A]
-- Calidad de Codigo: [PASS/FAIL/N/A]
-- Arquitectura: [PASS/FAIL/N/A]
-- Manejo de errores: [PASS/FAIL/N/A]
-- Testing: [PASS/FAIL/N/A]
-- Seguridad: [PASS/FAIL/N/A]
-- Dependencias: [PASS/FAIL/N/A]
-- Mantenibilidad y observabilidad: [PASS/FAIL/N/A]
-- Git y Deploy: [PASS/FAIL/N/A]
-- Reglas del proyecto (AGENTS.md): [PASS/FAIL/N/A]
-
-## Checklist Backend (si aplica)
-- Validacion de entrada: [PASS/FAIL/N/A]
-- Contratos de API: [PASS/FAIL/N/A]
-- Manejo de errores: [PASS/FAIL/N/A]
-- Arquitectura y patrones: [PASS/FAIL/N/A]
-- Concurrencia y atomicidad: [PASS/FAIL/N/A]
-- Consultas a BD: [PASS/FAIL/N/A]
-- Caching: [PASS/FAIL/N/A]
-- Resiliencia y conexiones: [PASS/FAIL/N/A]
-- Colas y mensajeria: [PASS/FAIL/N/A]
-- Performance: [PASS/FAIL/N/A]
-- Logging: [PASS/FAIL/N/A]
-- Testing backend: [PASS/FAIL/N/A]
-
-## Checklist Frontend (si aplica)
-- Componentes y estructura: [PASS/FAIL/N/A]
-- Estado y datos: [PASS/FAIL/N/A]
-- Manejo de errores en UI: [PASS/FAIL/N/A]
-- Integracion con APIs: [PASS/FAIL/N/A]
-- Validacion de formularios: [PASS/FAIL/N/A]
-- Ruteo y navegacion: [PASS/FAIL/N/A]
-- Consistencia visual: [PASS/FAIL/N/A]
-- Performance frontend: [PASS/FAIL/N/A]
-- Accesibilidad: [PASS/FAIL/N/A]
-- Seguridad frontend: [PASS/FAIL/N/A]
-- Testing frontend: [PASS/FAIL/N/A]
-
 ## Correcciones minimas para aprobar
 1. [item accionable]
 2. [item accionable]
+
+Siguiente paso: [/refacil:archive | /refacil:verify]
 ```
 
+Si el usuario pide modo **detallado**, agrega tras el bloque conciso una seccion por cada checklist cargado (`checklist.md`, `checklist-back.md`, `checklist-front.md` segun aplique) con cada item y su estado `[PASS/FAIL/N/A]`. No inventes items; usa literalmente los de los archivos. Marca N/A si un item no aplica.
+
 ### Paso 5: Marcador de review (obligatorio si APROBADO)
 
 Si el veredicto es **APROBADO** o **APROBADO CON OBSERVACIONES**, crea un archivo marcador en el directorio del cambio activo:

package/skills/setup/SKILL.md

@@ -64,6 +64,12 @@ Analiza el repo y genera `AGENTS.md` (espanol, terminos tecnicos en ingles). Si
 
 **6.4** — Muestra el resultado; si el usuario aprueba, escribe en la raiz.
 
+**6.5 Eficiencia de tokens (hook + bloque auto-gestionado)**:
+- Explica al usuario que `refacil-sdd-ai` mantiene en `AGENTS.md` un bloque `compact-guidance` para reducir consumo de contexto.
+- Ese bloque se sincroniza automaticamente por el hook `check-update` en cada `SessionStart` (y tambien en `init`/`update`).
+- Si `AGENTS.md` aun no existe, la sincronizacion se omite sin error.
+- Indica que no debe editar manualmente el contenido entre marcadores `compact-guidance` porque se sobrescribe.
+
 ### Paso 7: Verificar skills
 
 - OpenSpec: 10 carpetas bajo `.claude/skills/` y `.cursor/skills/`: `openspec-apply-change`, `openspec-archive-change`, `openspec-bulk-archive-change`, `openspec-continue-change`, `openspec-explore`, `openspec-ff-change`, `openspec-new-change`, `openspec-onboard`, `openspec-sync-specs`, `openspec-verify-change`. Si falta alguna: sugerir `openspec init --tools claude,cursor` o `openspec config list`.