refacil-sdd-ai 2.4.0 → 2.7.0

package/README.md

@@ -7,7 +7,9 @@ Instala skills para **Claude Code** y **Cursor** que guian al desarrollador por
 ## Requisitos
 
 - **Node.js >= 20.19.0** (requerido por OpenSpec)
-- **Claude Code** o **Cursor** instalado
+- **Claude Code >= 2.1.89** (requerido por el hook `compact-bash` para rewrite silencioso de comandos via `updatedInput`) o **Cursor**
+
+`refacil-sdd-ai init` verifica la version de Claude Code y muestra advertencia si es inferior. Con version < 2.1.89 el resto de la metodologia funciona, pero el hook `compact-bash` no tendra efecto (Claude Code ignora `updatedInput` en versiones antiguas).
 
 ## Instalacion y Setup
 
@@ -53,6 +55,11 @@ refacil-sdd-ai init          # Instalar skills, hooks y crear configs en el repo
 refacil-sdd-ai update        # Actualizar skills y hooks a la ultima version
 refacil-sdd-ai check-update  # Verifica si hay una version mas reciente en npm (usado por hook)
 refacil-sdd-ai check-review  # Verifica que el review se haya completado (usado por hook)
+refacil-sdd-ai compact-bash  # Hook de rewrite de comandos Bash bare (usado por hook, no invocar manual)
+refacil-sdd-ai compact stats     # Estadisticas completas (hook + ya-compacto) + tokens estimados + USD
+refacil-sdd-ai compact disable   # Desactiva el hook compact-bash sin desinstalarlo
+refacil-sdd-ai compact enable    # Reactiva el hook compact-bash
+refacil-sdd-ai compact clear-log # Limpia ~/.refacil-sdd-ai/compact.log
 refacil-sdd-ai clean         # Eliminar skills y remover hooks SDD-AI del repo
 refacil-sdd-ai help          # Ver ayuda
 ```
@@ -328,6 +335,7 @@ El paquete instala hooks en `.claude/settings.json` durante `init` y `update`:
 | Hook | Evento | Que hace |
 |------|--------|----------|
 | `check-update` | `SessionStart` | Verifica si hay nueva version del paquete en npm y la instala automaticamente. Tambien **sincroniza el bloque `compact-guidance`** en `AGENTS.md` (ver [Eficiencia de tokens](#eficiencia-de-tokens-bloque-auto-gestionado-en-agentsmd)). |
+| `compact-bash` | `PreToolUse` (Bash) | Reescribe **silenciosamente** comandos Bash bare (git/tests/docker logs) a su forma compacta usando `updatedInput`. Sin turnos extra y sin que Claude vea el cambio. Requiere Claude Code >= 2.1.89. |
 | `check-review` | `PreToolUse` (Bash) | Intercepta `git push` y verifica que exista `.review-passed` en cada cambio activo de `openspec/changes/`. Si falta, **bloquea el push** y emite instrucciones para ejecutar `/refacil:review`. El hook no invoca skills por si mismo. |
 
 #### Flujo del hook de review
@@ -378,6 +386,84 @@ openspec/changes/fix-session-timeout-redis/
 
 El archivo `.review-passed` contiene: veredicto, fecha, resumen, cantidad de hallazgos y si hubo blockers.
 
+### Hook `compact-bash` — rewrite silencioso de comandos Bash
+
+Segunda capa de reduccion de tokens, **sin costo conversacional**. Antes de que Claude Code ejecute un comando Bash, el hook `compact-bash` inspecciona el comando y, si matchea una regla, lo reescribe usando el campo `updatedInput` del hook. Claude **no ve el cambio**, no hay turno adicional, no hay bloqueo.
+
+**Reglas activas (19 reglas)**:
+
+Fase 1 — git, tests base, docker logs:
+
+| Comando bare | Reescrito a | Ahorro tipico |
+|---|---|---|
+| `git log` | `git log --oneline -20` | ~85% |
+| `git status` | `git status -s` | ~70% |
+| `git diff` (sin args) | `git diff --stat` | ~80% |
+| `git show` | `git show --stat` | ~70% |
+| `docker logs <container>` | `docker logs --tail 100 <container>` | ~80%+ |
+| `npm test` / `yarn test` / `pnpm test` | `… 2>&1 \| tail -80` | ~90% |
+| `jest` | `jest --silent --reporters=summary` | ~85% |
+| `pytest` | `pytest -q` | ~60% |
+
+Fase 2A — linters, type checkers, build, sistema:
+
+| Comando bare | Reescrito a | Ahorro tipico |
+|---|---|---|
+| `eslint` | `eslint . --format compact --quiet` | ~70% |
+| `eslint <path>` | `eslint <path> --format compact` | ~60% |
+| `biome check` | `biome check --reporter=summary` | ~65% |
+| `tsc` / `npx tsc …` | `… 2>&1 \| head -80` | variable |
+| `prettier --check <path>` | `prettier --check <path> --loglevel warn` | ~50% |
+| `npm audit` | `npm audit 2>&1 \| tail -10` | ~80% |
+| `npm ls` | `npm ls --depth=0` | ~90% |
+| `cargo build` / `cargo test` / `cargo check` | `… --quiet` | ~50% |
+| `go test …` (sin flags) | `… 2>&1 \| tail -80` | ~70% |
+| `mvn test` | `mvn test -q` | ~60% |
+| `./gradlew test` / `gradle test` | `… -q` | ~60% |
+| `ps aux` | `ps -eo pid,pcpu,pmem,comm \| head -30` | ~80% |
+
+**Detector de intencion**: si el comando ya tiene flags explicitos (`git log -p`, `git log --all`, `jest --watch`, `docker logs --tail 50 …`), el hook **no interviene**. Tu intencion manda.
+
+**Escape mecanismo**: prefija `COMPACT=0` al comando para desactivar el rewrite puntualmente: `COMPACT=0 git log`.
+
+**Pipes y redirecciones** en test bare: si ya hay `|` o `>`, el detector no las envuelve de nuevo.
+
+**Subcomandos de control**:
+
+```bash
+refacil-sdd-ai compact stats       # estadisticas completas (hook + ya-compacto) + tokens estimados + USD
+refacil-sdd-ai compact disable     # desactiva el hook sin desinstalar
+refacil-sdd-ai compact enable      # reactiva el hook
+refacil-sdd-ai compact clear-log   # limpia ~/.refacil-sdd-ai/compact.log
+```
+
+**Telemetria**: cada evento genera una linea JSON en `~/.refacil-sdd-ai/compact.log` con timestamp, ruleId y estimacion de tokens. Hay dos tipos de evento: `hook_rewrite` (el hook reescribe) y `already_compact` (el comando ya llega compacto, asumido por skill/agente). `compact stats` muestra ambos por defecto y calcula costo estimado (a razon de $3/MTok input de Sonnet, conservador). La telemetria es local; nada se envia a la nube.
+
+**Flujo del hook**:
+
+```
+Claude emite "git log"
+  │
+  ▼
+Hook compact-bash recibe tool_input via stdin (JSON)
+  │
+  ▼
+¿Matchea alguna regla y no tiene intent flags?
+  │
+  ├─ SI  ──► stdout JSON:
+  │          {
+  │            "hookSpecificOutput": {
+  │              "hookEventName": "PreToolUse",
+  │              "permissionDecision": "allow",
+  │              "updatedInput": { "command": "git log --oneline -20", ... },
+  │              "permissionDecisionReason": "compact-bash: git log → --oneline -20"
+  │            }
+  │          }
+  │          Claude Code ejecuta el comando reescrito. Claude no lo ve.
+  │
+  └─ NO  ──► stdout vacio → Claude Code ejecuta el comando original.
+```
+
 ### Eficiencia de tokens (bloque auto-gestionado en AGENTS.md)
 
 La metodologia SDD-AI genera consumo elevado de contexto (artefactos, specs, prompts de skills). Para compensarlo, `refacil-sdd-ai` mantiene un bloque de guia de eficiencia de tokens dentro de `AGENTS.md` que instruye a la IA sobre como pedir salidas compactas (Read con offset/limit, `git log --oneline`, tests solo con failures, etc.).
@@ -475,6 +561,29 @@ npm uninstall -g refacil-sdd-ai
 - [Claude Code](https://claude.ai/code) — CLI de Anthropic
 - [Cursor](https://cursor.sh) — IDE con IA
 
+## Cambios recientes
+
+**v2.6.0** — Fase 2 del hook `compact-bash`:
+- 11 reglas nuevas: `eslint`, `biome check`, `tsc`, `prettier --check`, `npm audit`, `npm ls`, `cargo build/test/check`, `go test`, `mvn test`, `gradle test`, `ps aux` (total: 19 reglas)
+- Telemetria local en `~/.refacil-sdd-ai/compact.log`
+- Subcomandos `compact stats | disable | enable | clear-log`
+- `ps-aux` solo se activa en Unix (Linux/Mac); en Windows la regla no interviene
+
+**v2.5.0** — Fase 1 del hook `compact-bash`:
+- Hook `PreToolUse` que reescribe silenciosamente comandos Bash bare via `updatedInput` (requiere Claude Code >= 2.1.89)
+- Reglas iniciales: git log/status/diff/show, docker logs, npm/yarn/pnpm test, jest, pytest
+- Escape mecanismo `COMPACT=0 <cmd>`
+
+**v2.4.0** — Reduccion de tokens en la metodologia:
+- Boilerplate "Antes de empezar" unificado en 9 skills
+- Validacion de OpenSpec simplificada en `prereqs/SKILL.md`
+- Templates consolidados (`claude-md.md` + `cursorrules.md` → `methodology-guide.md` unico)
+- Compactacion de `review/SKILL.md`, `bug/SKILL.md`, `test/SKILL.md`
+
+**v2.3.0** — Bloque `compact-guidance` auto-gestionado en `AGENTS.md`:
+- Hook `SessionStart` sincroniza el bloque en cada sesion
+- Fuente de verdad: `templates/compact-guidance.md`
+
 ## Licencia
 
 MIT

package/bin/cli.js

@@ -6,6 +6,8 @@ const {
   syncCompactGuidance,
   removeCompactGuidance,
 } = require('../lib/compact-guidance');
+const compactBash = require('../lib/compact/bash');
+const compactTelemetry = require('../lib/compact/telemetry');
 
 const SKILLS = [
   'setup',
@@ -128,6 +130,29 @@ function removeSkills() {
   return removed;
 }
 
+function checkClaudeCodeVersion() {
+  const { execSync } = require('child_process');
+  try {
+    const output = execSync('claude --version 2>&1', {
+      encoding: 'utf8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match) return { ok: null, version: null };
+    const maj = Number(match[1]);
+    const min = Number(match[2]);
+    const patch = Number(match[3]);
+    const ok =
+      maj > 2 ||
+      (maj === 2 && min > 1) ||
+      (maj === 2 && min === 1 && patch >= 89);
+    return { ok, version: `${maj}.${min}.${patch}` };
+  } catch (_) {
+    return { ok: null, version: null };
+  }
+}
+
 function checkNodeVersion() {
   const version = process.version; // e.g. v20.19.5
   const major = parseInt(version.split('.')[0].replace('v', ''));
@@ -174,9 +199,28 @@ function installHook() {
     changed = true;
   }
 
-  // PreToolUse: check-review
+  // PreToolUse
   if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
 
+  // compact-bash (must run BEFORE check-review so rewrite is visible to subsequent hooks)
+  const hasCompactHook = settings.hooks.PreToolUse.some(
+    (h) => h._sdd_compact === true,
+  );
+  if (!hasCompactHook) {
+    settings.hooks.PreToolUse.unshift({
+      _sdd_compact: true,
+      matcher: 'Bash',
+      hooks: [
+        {
+          type: 'command',
+          command: 'refacil-sdd-ai compact-bash',
+        },
+      ],
+    });
+    changed = true;
+  }
+
+  // check-review
   const hasReviewHook = settings.hooks.PreToolUse.some(
     (h) => h._sdd_review === true,
   );
@@ -232,7 +276,7 @@ function uninstallHook() {
   if (Array.isArray(settings.hooks.PreToolUse)) {
     const original = settings.hooks.PreToolUse.length;
     settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
-      (h) => h._sdd_review !== true,
+      (h) => h._sdd_review !== true && h._sdd_compact !== true,
     );
     if (settings.hooks.PreToolUse.length !== original) changed = true;
     if (settings.hooks.PreToolUse.length === 0) delete settings.hooks.PreToolUse;
@@ -362,6 +406,18 @@ function init() {
     console.log(`  Node.js ${process.version} OK`);
   }
 
+  // Check Claude Code version (for compact-bash hook)
+  const claudeCheck = checkClaudeCodeVersion();
+  if (claudeCheck.ok === true) {
+    console.log(`  Claude Code ${claudeCheck.version} OK`);
+  } else if (claudeCheck.ok === false) {
+    console.log(`\n  ADVERTENCIA: Claude Code ${claudeCheck.version} detectado.`);
+    console.log('  El hook compact-bash requiere Claude Code >= 2.1.89 para rewrite silencioso.');
+    console.log('  Con version inferior se instala igual pero el rewrite no tendra efecto.');
+    console.log('  Actualiza con: npm install -g @anthropic-ai/claude-code\n');
+  }
+  // ok === null: claude no esta en PATH, silencioso
+
   // Install skills
   const count = installSkills();
   console.log(`  ${count} skills instaladas en .claude/skills/ y .cursor/skills/`);
@@ -453,6 +509,95 @@ function clean() {
   console.log('  Para eliminar OpenSpec: rm -rf openspec/ .claude/commands/opsx .cursor/commands/opsx\n');
 }
 
+// --- Compact subcommands (stats / enable / disable / clear-log) ---
+
+function handleCompactSubcommand(sub) {
+  switch (sub) {
+    case 'stats':
+      showCompactStats();
+      break;
+    case 'disable':
+      compactTelemetry.disable();
+      console.log('  compact-bash deshabilitado. Reactiva con: refacil-sdd-ai compact enable');
+      break;
+    case 'enable':
+      compactTelemetry.enable();
+      console.log('  compact-bash habilitado.');
+      break;
+    case 'clear-log':
+      compactTelemetry.clearLog();
+      console.log('  compact.log limpiado.');
+      break;
+    default:
+      console.log('Uso: refacil-sdd-ai compact <stats|disable|enable|clear-log>');
+  }
+}
+
+function showCompactStats() {
+  const s = compactTelemetry.stats();
+  if (s.totalEvents === 0) {
+    console.log('\n  No hay eventos registrados todavia. Ejecuta comandos Bash para generar telemetria de compactacion.\n');
+    return;
+  }
+
+  const sortedRewrites = Object.entries(s.byRule)
+    .filter(([, data]) => data.rewriteCount > 0)
+    .sort((a, b) => b[1].rewriteSaved - a[1].rewriteSaved);
+  const sortedAlreadyCompact = Object.entries(s.byRule)
+    .filter(([, data]) => data.alreadyCompactCount > 0)
+    .sort((a, b) => b[1].alreadyCompactPotential - a[1].alreadyCompactPotential);
+
+  console.log(`\n  compact-bash stats\n`);
+  console.log(`  Rewrites por hook: ${s.totalRewrites}`);
+  console.log(`  Comandos ya compactos detectados (skill/agente): ${s.totalAlreadyCompact}\n`);
+
+  if (sortedRewrites.length > 0) {
+    console.log('  Ahorro aplicado por hook (rewrite):');
+    for (const [id, data] of sortedRewrites) {
+      const kTokens = (data.rewriteSaved / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.rewriteCount).padStart(6)} rewrites   ~${kTokens.padStart(7)}k tokens`,
+      );
+    }
+    const totalHookK = (s.totalSaved / 1000).toFixed(1);
+    const hookUsd = ((s.totalSaved / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
+    console.log(
+      `    ${'Total hook'.padEnd(18)} ${String(s.totalRewrites).padStart(6)} rewrites   ~${totalHookK.padStart(7)}k tokens (~$${hookUsd} USD)`,
+    );
+    console.log('');
+  }
+
+  if (sortedAlreadyCompact.length > 0) {
+    console.log('  Ahorro potencial ya capturado por skill/agente (sin rewrite):');
+    for (const [id, data] of sortedAlreadyCompact) {
+      const kTokens = (data.alreadyCompactPotential / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.alreadyCompactCount).padStart(6)} eventos    ~${kTokens.padStart(7)}k tokens potenciales`,
+      );
+    }
+    const totalAgentK = (s.totalAlreadyCompactPotential / 1000).toFixed(1);
+    const agentUsd = ((s.totalAlreadyCompactPotential / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
+    console.log(
+      `    ${'Total skill'.padEnd(18)} ${String(s.totalAlreadyCompact).padStart(6)} eventos    ~${totalAgentK.padStart(7)}k tokens (~$${agentUsd} USD)`,
+    );
+    console.log('');
+  }
+
+  const totalK = (s.totalObservedPotential / 1000).toFixed(1);
+  const totalUsd = ((s.totalObservedPotential / 1_000_000) * 3).toFixed(2);
+  console.log(`    ${'-'.repeat(62)}`);
+  console.log(
+    `    ${'Total observado'.padEnd(18)} ${String(s.totalEvents).padStart(6)} eventos    ~${totalK.padStart(7)}k tokens (~$${totalUsd} USD, Sonnet input)`,
+  );
+  console.log(`\n  Log: ${compactTelemetry.LOG_PATH}`);
+  if (compactTelemetry.isDisabled()) {
+    console.log('  Estado: DESHABILITADO (no se registran nuevos eventos)');
+  }
+  console.log('');
+}
+
 function help() {
   console.log(`
   refacil-sdd-ai — Metodologia SDD-AI con OpenSpec
@@ -462,6 +607,12 @@ function help() {
     update        Re-copia skills (para actualizar a nueva version del paquete)
     check-update  Verifica si hay una version mas reciente en npm y sincroniza compact-guidance en AGENTS.md
     check-review  Verifica que el review se haya completado (usado por hook PreToolUse)
+    compact-bash  Reescribe comandos Bash bare para reducir tokens (usado por hook PreToolUse)
+    compact       Subcomandos del hook compact-bash:
+                    compact stats      - Estadisticas completas (hook + ya-compacto) y ahorro estimado
+                    compact disable    - Desactiva el rewrite temporalmente
+                    compact enable     - Re-activa el rewrite
+                    compact clear-log  - Borra el log historico
     clean         Elimina skills y remueve hooks SDD-AI de .claude/settings.json
     help          Muestra esta ayuda
 
@@ -473,7 +624,7 @@ function help() {
 
   Requisitos:
     - Node.js >= 20.19.0 (requerido por OpenSpec)
-    - Claude Code o Cursor instalado
+    - Claude Code >= 2.1.89 (requerido por compact-bash para rewrite silencioso) o Cursor
   `);
 }
 
@@ -494,6 +645,12 @@ switch (command) {
   case 'check-review':
     checkReview();
     break;
+  case 'compact-bash':
+    compactBash.run();
+    break;
+  case 'compact':
+    handleCompactSubcommand(process.argv[3]);
+    break;
   case 'clean':
     clean();
     break;

package/lib/compact/bash.js

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const { findRule, findAlreadyCompactRule } = require('./rules');
+const telemetry = require('./telemetry');
+
+function run() {
+  let input;
+  try {
+    const stdin = fs.readFileSync(0, 'utf8');
+    if (!stdin.trim()) return;
+    input = JSON.parse(stdin);
+  } catch (_) {
+    return;
+  }
+
+  if (input.tool_name !== 'Bash') return;
+  if (telemetry.isDisabled()) return;
+
+  const origCommand = input.tool_input && input.tool_input.command;
+  if (typeof origCommand !== 'string') return;
+
+  const rule = findRule(origCommand);
+  if (!rule) {
+    const compactRule = findAlreadyCompactRule(origCommand);
+    if (compactRule) {
+      telemetry.logAlreadyCompact(compactRule.id, compactRule.savedTokensEst);
+    }
+    return;
+  }
+
+  let newCommand;
+  try {
+    newCommand = rule.rewrite(origCommand);
+  } catch (_) {
+    return;
+  }
+
+  if (!newCommand || newCommand === origCommand) return;
+
+  telemetry.logRewrite(rule.id, rule.savedTokensEst);
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+      permissionDecisionReason: `compact-bash: ${rule.reason}`,
+      updatedInput: {
+        ...input.tool_input,
+        command: newCommand,
+      },
+    },
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+module.exports = { run };

package/lib/compact/rules.js

@@ -0,0 +1,236 @@
+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),
+    compactMatch: (cmd) =>
+      /^\s*git\s+log(\s|$)/.test(cmd) &&
+      (/--oneline\b/.test(cmd) || /(^|\s)-\d+\b/.test(cmd)),
+    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),
+    compactMatch: (cmd) =>
+      /^\s*git\s+status(\s|$)/.test(cmd) &&
+      (/\s-s(\s|$)/.test(cmd) || /--short\b/.test(cmd)),
+    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),
+    compactMatch: (cmd) => /^\s*git\s+diff(\s|$)/.test(cmd) && /--stat\b/.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),
+    compactMatch: (cmd) => /^\s*git\s+show(\s|$)/.test(cmd) && /--stat\b/.test(cmd),
+    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;
+    },
+    compactMatch: (cmd) =>
+      /^\s*docker\s+logs(\s|$)/.test(cmd) &&
+      (/\s--tail\b/.test(cmd) || /\s-n\s+\d/.test(cmd) || /\s--since\b/.test(cmd)),
+    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),
+    compactMatch: (cmd) =>
+      /^\s*(npm|yarn|pnpm)\s+(test|t)\b/.test(cmd) &&
+      (hasPipeOrRedirect(cmd) || /--silent\b/.test(cmd) || /\b-q\b/.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),
+    compactMatch: (cmd) =>
+      /^\s*(npx\s+)?jest(\s|$)/.test(cmd) &&
+      (/--silent\b/.test(cmd) || /--reporters=summary\b/.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),
+    compactMatch: (cmd) => /^\s*pytest(\s|$)/.test(cmd) && /(^|\s)-q(\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),
+    compactMatch: (cmd) =>
+      /^\s*eslint(\s|$)/.test(cmd) &&
+      (/--format\s+compact\b/.test(cmd) || /--quiet\b/.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),
+    compactMatch: (cmd) =>
+      /^\s*biome\s+check(\s|$)/.test(cmd) && /--reporter=summary\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;
+    },
+    compactMatch: (cmd) =>
+      /^\s*(npx\s+)?tsc(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
+    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),
+    compactMatch: (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),
+    compactMatch: (cmd) => /^\s*npm\s+audit(\s|$)/.test(cmd) && hasPipeOrRedirect(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),
+    compactMatch: (cmd) => /^\s*npm\s+ls(\s|$)/.test(cmd) && /--depth=0\b/.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),
+    compactMatch: (cmd) =>
+      /^\s*cargo\s+(build|test|check)(\s|$)/.test(cmd) && /--quiet\b/.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;
+    },
+    compactMatch: (cmd) => /^\s*go\s+test(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
+    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),
+    compactMatch: (cmd) => /^\s*mvn\s+test(\s|$)/.test(cmd) && /(^|\s)-q(\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),
+    compactMatch: (cmd) =>
+      /^\s*(\.\/gradlew|gradle)\s+test(\s|$)/.test(cmd) &&
+      /(^|\s)-q(\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;
+}
+
+function findAlreadyCompactRule(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  for (const rule of RULES) {
+    if (typeof rule.compactMatch === 'function' && rule.compactMatch(cmd)) {
+      return rule;
+    }
+  }
+  return null;
+}
+
+module.exports = { RULES, findRule, findAlreadyCompactRule };

package/lib/compact/telemetry.js

@@ -0,0 +1,137 @@
+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 logEvent(eventType, ruleId, savedTokensEst, meta = {}) {
+  try {
+    ensureDir();
+    const line =
+      JSON.stringify({
+        ts: new Date().toISOString(),
+        eventType: eventType || 'hook_rewrite',
+        ruleId,
+        savedTokensEst: savedTokensEst || 0,
+        ...meta,
+      }) + '\n';
+    fs.appendFileSync(LOG_PATH, line);
+  } catch (_) {
+    // Telemetry must never break the hook
+  }
+}
+
+function logRewrite(ruleId, savedTokensEst) {
+  logEvent('hook_rewrite', ruleId, savedTokensEst);
+}
+
+function logAlreadyCompact(ruleId, savedTokensEst) {
+  // Assumption: command arrived compact due to skills/agent discipline.
+  logEvent('already_compact', ruleId, savedTokensEst, {
+    source: 'skill_assumed',
+  });
+}
+
+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;
+  let totalAlreadyCompactPotential = 0;
+  let totalAlreadyCompact = 0;
+  let totalRewrites = 0;
+
+  for (const e of entries) {
+    const eventType = e.eventType || 'hook_rewrite';
+    if (!byRule[e.ruleId]) {
+      byRule[e.ruleId] = {
+        rewriteCount: 0,
+        rewriteSaved: 0,
+        alreadyCompactCount: 0,
+        alreadyCompactPotential: 0,
+      };
+    }
+
+    if (eventType === 'already_compact') {
+      byRule[e.ruleId].alreadyCompactCount++;
+      byRule[e.ruleId].alreadyCompactPotential += e.savedTokensEst || 0;
+      totalAlreadyCompact++;
+      totalAlreadyCompactPotential += e.savedTokensEst || 0;
+    } else {
+      byRule[e.ruleId].rewriteCount++;
+      byRule[e.ruleId].rewriteSaved += e.savedTokensEst || 0;
+      totalRewrites++;
+      totalSaved += e.savedTokensEst || 0;
+    }
+  }
+
+  return {
+    byRule,
+    totalSaved,
+    totalRewrites,
+    totalAlreadyCompact,
+    totalAlreadyCompactPotential,
+    totalObservedPotential: totalSaved + totalAlreadyCompactPotential,
+    totalEvents: 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,
+  logAlreadyCompact,
+  stats,
+  disable,
+  enable,
+  clearLog,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "refacil-sdd-ai",
-  "version": "2.4.0",
+  "version": "2.7.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"