@saulwade/swl-ses 1.0.0

package/scripts/field-report.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * field-report.js — Generador de reportes de validación en campo.
+ *
+ * Analiza sesiones JSONL de Claude Code para extraer métricas reales de uso
+ * de skills y agentes SWL en proyectos de usuario.
+ *
+ * Uso:
+ *   node scripts/field-report.js                    # Todas las sesiones
+ *   node scripts/field-report.js --days=30          # Últimos 30 días
+ *   node scripts/field-report.js --project=/path    # Proyecto específico
+ *   node scripts/field-report.js --output=json      # Salida JSON
+ *
+ * Métricas extraídas:
+ *   - Skills invocados (Skill("nombre"))
+ *   - Agentes delegados (Agent con description)
+ *   - Comandos /swl:* ejecutados
+ *   - Proyectos donde se usó swl-ses
+ *   - Frecuencia de uso por componente
+ *   - Skills nunca usados (candidatos a poda)
+ *
+ * @module scripts/field-report
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ── Argumentos ────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2).reduce((acc, arg) => {
+  const [k, v] = arg.replace(/^--/, '').split('=');
+  acc[k] = v || true;
+  return acc;
+}, {});
+
+const DAYS       = parseInt(args.days) || 0;
+const PROJECT    = args.project || null;
+const OUTPUT     = args.output || 'md';
+const CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
+
+// ── Explorar sesiones ─────────────────────────────────────────────────
+
+function buscarSesiones() {
+  const sesiones = [];
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    console.error(`No se encontró ${CLAUDE_DIR}`);
+    return sesiones;
+  }
+
+  const proyectos = fs.readdirSync(CLAUDE_DIR).filter(d =>
+    fs.statSync(path.join(CLAUDE_DIR, d)).isDirectory()
+  );
+
+  for (const proy of proyectos) {
+    if (PROJECT && !proy.includes(PROJECT.replace(/[/\\:]/g, '-'))) continue;
+    const dir = path.join(CLAUDE_DIR, proy);
+    const archivos = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+    for (const archivo of archivos) {
+      const ruta = path.join(dir, archivo);
+      const stat = fs.statSync(ruta);
+      if (DAYS > 0) {
+        const hace = Date.now() - DAYS * 86400000;
+        if (stat.mtimeMs < hace) continue;
+      }
+      sesiones.push({ proyecto: proy, ruta, fecha: stat.mtime });
+    }
+  }
+
+  return sesiones;
+}
+
+function analizarSesion(ruta) {
+  const stats = { skills: {}, agentes: {}, comandos: {}, toolCalls: 0 };
+  try {
+    const contenido = fs.readFileSync(ruta, 'utf8');
+    const lineas = contenido.split('\n').filter(Boolean);
+
+    for (const linea of lineas) {
+      try {
+        const entry = JSON.parse(linea);
+        const msg = entry.message || entry;
+
+        // Buscar Skill("nombre") en contenido
+        const texto = JSON.stringify(msg);
+        const skillMatches = texto.matchAll(/Skill\s*\(\s*["']([^"']+)["']\s*\)/g);
+        for (const m of skillMatches) {
+          stats.skills[m[1]] = (stats.skills[m[1]] || 0) + 1;
+        }
+
+        // Buscar agentes delegados
+        const agentMatches = texto.matchAll(/"description"\s*:\s*"([^"]*swl[^"]*)"/gi);
+        for (const m of agentMatches) {
+          const nombre = m[1].substring(0, 60);
+          stats.agentes[nombre] = (stats.agentes[nombre] || 0) + 1;
+        }
+
+        // Buscar comandos /swl:*
+        const cmdMatches = texto.matchAll(/\/swl:([a-z-]+)/g);
+        for (const m of cmdMatches) {
+          const cmd = `/swl:${m[1]}`;
+          stats.comandos[cmd] = (stats.comandos[cmd] || 0) + 1;
+        }
+
+        // Contar tool calls
+        if (msg.type === 'tool_use' || msg.tool_name) stats.toolCalls++;
+      } catch { /* línea JSONL inválida, ignorar */ }
+    }
+  } catch { /* archivo ilegible, ignorar */ }
+
+  return stats;
+}
+
+// ── Generar reporte ───────────────────────────────────────────────────
+
+function generarReporte() {
+  const sesiones = buscarSesiones();
+  if (sesiones.length === 0) {
+    console.log('No se encontraron sesiones para analizar.');
+    console.log(`Directorio buscado: ${CLAUDE_DIR}`);
+    return;
+  }
+
+  const totales = { skills: {}, agentes: {}, comandos: {}, sesiones: sesiones.length, proyectos: new Set(), toolCalls: 0 };
+
+  for (const sesion of sesiones) {
+    totales.proyectos.add(sesion.proyecto);
+    const stats = analizarSesion(sesion.ruta);
+    totales.toolCalls += stats.toolCalls;
+
+    for (const [k, v] of Object.entries(stats.skills))   totales.skills[k]   = (totales.skills[k] || 0) + v;
+    for (const [k, v] of Object.entries(stats.agentes))  totales.agentes[k]  = (totales.agentes[k] || 0) + v;
+    for (const [k, v] of Object.entries(stats.comandos)) totales.comandos[k] = (totales.comandos[k] || 0) + v;
+  }
+
+  // Cargar inventario de skills
+  const skillsDir = path.join(__dirname, '..', 'habilidades');
+  const todosSkills = fs.existsSync(skillsDir)
+    ? fs.readdirSync(skillsDir).filter(d => fs.statSync(path.join(skillsDir, d)).isDirectory())
+    : [];
+
+  const skillsUsados   = new Set(Object.keys(totales.skills));
+  const skillsNoUsados = todosSkills.filter(s => !skillsUsados.has(s));
+
+  if (OUTPUT === 'json') {
+    console.log(JSON.stringify({
+      fecha: new Date().toISOString(),
+      sesiones: totales.sesiones,
+      proyectos: [...totales.proyectos],
+      toolCalls: totales.toolCalls,
+      skills: Object.entries(totales.skills).sort((a, b) => b[1] - a[1]),
+      agentes: Object.entries(totales.agentes).sort((a, b) => b[1] - a[1]),
+      comandos: Object.entries(totales.comandos).sort((a, b) => b[1] - a[1]),
+      skillsNoUsados,
+      cobertura: `${skillsUsados.size}/${todosSkills.length}`,
+    }, null, 2));
+    return;
+  }
+
+  // Markdown
+  const sorted = (obj) => Object.entries(obj).sort((a, b) => b[1] - a[1]);
+
+  console.log('# Reporte de Validación en Campo — swl-ses');
+  console.log(`\n**Fecha**: ${new Date().toISOString().slice(0, 10)}`);
+  console.log(`**Sesiones analizadas**: ${totales.sesiones}`);
+  console.log(`**Proyectos**: ${totales.proyectos.size}`);
+  console.log(`**Tool calls totales**: ${totales.toolCalls}`);
+  console.log(`**Cobertura de skills**: ${skillsUsados.size}/${todosSkills.length} (${Math.round(skillsUsados.size / todosSkills.length * 100)}%)`);
+
+  console.log('\n## Skills más usados\n');
+  console.log('| Skill | Invocaciones |');
+  console.log('|-------|-------------|');
+  for (const [s, c] of sorted(totales.skills).slice(0, 30)) {
+    console.log(`| ${s} | ${c} |`);
+  }
+
+  console.log('\n## Comandos /swl:* más usados\n');
+  console.log('| Comando | Invocaciones |');
+  console.log('|---------|-------------|');
+  for (const [s, c] of sorted(totales.comandos).slice(0, 20)) {
+    console.log(`| ${s} | ${c} |`);
+  }
+
+  if (skillsNoUsados.length > 0) {
+    console.log('\n## Skills nunca usados (candidatos a evaluación)\n');
+    console.log('| Skill |');
+    console.log('|-------|');
+    for (const s of skillsNoUsados.sort()) {
+      console.log(`| ${s} |`);
+    }
+  }
+
+  console.log('\n---');
+  console.log(`\n> Generado por \`node scripts/field-report.js\``);
+}
+
+generarReporte();

package/scripts/generar-inventario.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * generar-inventario.js — Genera INVENTARIO.md y SALUD.md desde el disco.
+ *
+ * Elimina la necesidad de mantener estos archivos manualmente.
+ * Lee el estado real de agentes/, habilidades/, hooks/, etc.
+ *
+ * Uso:
+ *   node scripts/generar-inventario.js                 # Genera ambos
+ *   node scripts/generar-inventario.js --inventario    # Solo INVENTARIO.md
+ *   node scripts/generar-inventario.js --salud         # Solo SALUD.md
+ *   node scripts/generar-inventario.js --dry-run       # Muestra sin escribir
+ *
+ * @module scripts/generar-inventario
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const RAIZ = path.resolve(__dirname, '..');
+const args = new Set(process.argv.slice(2));
+const DRY  = args.has('--dry-run');
+const SOLO_INV = args.has('--inventario');
+const SOLO_SAL = args.has('--salud');
+const AMBOS = !SOLO_INV && !SOLO_SAL;
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function leerFrontmatter(ruta) {
+  try {
+    const contenido = fs.readFileSync(ruta, 'utf8');
+    const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return {};
+    const fm = {};
+    for (const linea of match[1].split(/\r?\n/)) {
+      const idx = linea.indexOf(':');
+      if (idx > 0) {
+        const key = linea.slice(0, idx).trim();
+        const val = linea.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+        fm[key] = val;
+      }
+    }
+    return fm;
+  } catch { return {}; }
+}
+
+function contarArchivos(dir, ext) {
+  try {
+    return fs.readdirSync(dir).filter(f => f.endsWith(ext)).length;
+  } catch { return 0; }
+}
+
+function contarDirectorios(dir) {
+  try {
+    return fs.readdirSync(dir).filter(d =>
+      fs.statSync(path.join(dir, d)).isDirectory()
+    ).length;
+  } catch { return 0; }
+}
+
+function contarSkills(dir) {
+  try {
+    return fs.readdirSync(dir).filter(d => {
+      const skillMd = path.join(dir, d, 'SKILL.md');
+      return fs.existsSync(skillMd);
+    }).length;
+  } catch { return 0; }
+}
+
+// ── Recolectar datos ──────────────────────────────────────────────────
+
+function recolectarAgentes() {
+  const dir = path.join(RAIZ, 'agentes');
+  const archivos = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+  return archivos.map(f => {
+    const fm = leerFrontmatter(path.join(dir, f));
+    return {
+      archivo: f,
+      name: fm.name || f.replace('.md', ''),
+      version: fm.version || '?',
+      model: fm.model || '?',
+      nivelRiesgo: fm.nivelRiesgo || '?',
+    };
+  });
+}
+
+function recolectarSkills() {
+  const dir = path.join(RAIZ, 'habilidades');
+  const dirs = fs.readdirSync(dir).filter(d =>
+    fs.existsSync(path.join(dir, d, 'SKILL.md'))
+  );
+  return dirs.map(d => {
+    const fm = leerFrontmatter(path.join(dir, d, 'SKILL.md'));
+    return { dir: d, name: fm.name || d, description: (fm.description || '').substring(0, 80) };
+  });
+}
+
+function recolectarHooks() {
+  const dir = path.join(RAIZ, 'hooks');
+  return fs.readdirSync(dir).filter(f => f.endsWith('.js') && f !== 'lib');
+}
+
+function recolectarLibs() {
+  const dir = path.join(RAIZ, 'hooks', 'lib');
+  return fs.readdirSync(dir).filter(f => f.endsWith('.js'));
+}
+
+function verificarSintaxis(archivos, dirBase) {
+  const { execSync } = require('child_process');
+  let ok = 0, fail = 0;
+  for (const f of archivos) {
+    try {
+      execSync(`node -c "${path.join(dirBase, f)}"`, { stdio: 'pipe' });
+      ok++;
+    } catch { fail++; }
+  }
+  return { ok, fail, total: archivos.length };
+}
+
+// ── Generar INVENTARIO.md ─────────────────────────────────────────────
+
+function generarInventario() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(RAIZ, 'package.json'), 'utf8'));
+  const agentes  = recolectarAgentes();
+  const skills   = recolectarSkills();
+  const hooks    = recolectarHooks();
+  const libs     = recolectarLibs();
+  const comandos = contarArchivos(path.join(RAIZ, 'comandos', 'swl'), '.md');
+  const reglasBase = contarArchivos(path.join(RAIZ, 'reglas'), '.md');
+  const reglasLang = fs.readdirSync(path.join(RAIZ, 'reglas', 'lenguajes'))
+    .filter(d => fs.statSync(path.join(RAIZ, 'reglas', 'lenguajes', d)).isDirectory())
+    .reduce((acc, d) => acc + contarArchivos(path.join(RAIZ, 'reglas', 'lenguajes', d), '.md'), 0);
+  const schemas  = contarArchivos(path.join(RAIZ, 'schemas'), '.json');
+  const scripts  = contarArchivos(path.join(RAIZ, 'scripts', 'lib'), '.js') + contarArchivos(path.join(RAIZ, 'scripts', 'lib'), '.py');
+
+  const lines = [];
+  lines.push(`# INVENTARIO.md — Referencia completa de componentes SWL v${pkg.version}`);
+  lines.push('');
+  lines.push('> Archivo generado automáticamente por `node scripts/generar-inventario.js`.');
+  lines.push('> NO editar manualmente — se regenera con cada release.');
+  lines.push('');
+  lines.push('## Resumen');
+  lines.push('');
+  lines.push('| Componente | Cantidad |');
+  lines.push('|-----------|----------|');
+  lines.push(`| Agentes SWL | ${agentes.length} |`);
+  lines.push(`| Habilidades | ${skills.length} |`);
+  lines.push(`| Comandos | ${comandos} |`);
+  lines.push(`| Reglas base | ${reglasBase} |`);
+  lines.push(`| Reglas por lenguaje | ${reglasLang} |`);
+  lines.push(`| Hooks | ${hooks.length} |`);
+  lines.push(`| Librerías de hooks | ${libs.length} |`);
+  lines.push(`| Schemas | ${schemas} |`);
+  lines.push(`| Scripts lib | ${scripts} |`);
+  lines.push('');
+
+  // Equipos
+  lines.push('## Equipos de agentes (paralelización real)');
+  lines.push('');
+  lines.push('| Equipo | Líder | Miembros paralelos | Cuándo |');
+  lines.push('|--------|-------|-------------------|--------|');
+  lines.push('| Discovery | investigador-swl | investigador-ux-swl, producto-prd-swl | Proyecto nuevo |');
+  lines.push('| Arquitectura | arquitecto-swl | rendimiento-swl, revisor-seguridad-swl | Decisión de diseño |');
+  lines.push('| Frontend | frontend-swl | frontend-react-swl, frontend-css-swl, frontend-tailwind-swl | Feature UI compleja |');
+  lines.push('| Backend | backend-python-swl | backend-api-swl, backend-workers-swl | Feature backend compleja |');
+  lines.push('| Mobile | mobile-cross-swl | mobile-android-swl, mobile-ios-swl, mobile-testing-swl | Feature mobile |');
+  lines.push('| Calidad | tdd-qa-swl | revisor-codigo-swl, revisor-seguridad-swl, accesibilidad-wcag-swl | Pre-release |');
+  lines.push('| Operaciones | devops-ci-swl | cloud-infra-swl, observabilidad-swl, sre-swl | Deploy, infra, confiabilidad |');
+  lines.push('| Cierre | consolidador-swl | documentador-swl, release-manager-swl, notificador-swl | Fase completada |');
+  lines.push('');
+
+  // Agentes
+  lines.push(`## Agentes SWL — Registro completo (${agentes.length})`);
+  lines.push('');
+  lines.push('| Agente | Versión | Modelo | Riesgo |');
+  lines.push('|--------|---------|--------|--------|');
+  for (const a of agentes.sort((x, y) => x.name.localeCompare(y.name))) {
+    lines.push(`| ${a.name} | ${a.version} | ${a.model} | ${a.nivelRiesgo} |`);
+  }
+  lines.push('');
+
+  // Hooks
+  lines.push(`## Hooks activos (${hooks.length} + ${libs.length} librerías)`);
+  lines.push('');
+  lines.push('| Hook | Archivo |');
+  lines.push('|------|---------|');
+  for (const h of hooks.sort()) {
+    lines.push(`| ${h.replace('.js', '')} | \`hooks/${h}\` |`);
+  }
+  lines.push('');
+
+  // Libs
+  lines.push(`### Librerías de hooks (hooks/lib/) — ${libs.length}`);
+  lines.push('');
+  lines.push('| Librería | Archivo |');
+  lines.push('|----------|---------|');
+  for (const l of libs.sort()) {
+    lines.push(`| ${l.replace('.js', '')} | \`hooks/lib/${l}\` |`);
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// ── Generar SALUD.md ──────────────────────────────────────────────────
+
+function generarSalud() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(RAIZ, 'package.json'), 'utf8'));
+  const plugin = JSON.parse(fs.readFileSync(path.join(RAIZ, 'plugin.json'), 'utf8'));
+  const agentes  = recolectarAgentes();
+  const skills   = recolectarSkills();
+  const hooks    = recolectarHooks();
+  const libs     = recolectarLibs();
+  const comandos = contarArchivos(path.join(RAIZ, 'comandos', 'swl'), '.md');
+  const reglasBase = contarArchivos(path.join(RAIZ, 'reglas'), '.md');
+  const reglasLang = fs.readdirSync(path.join(RAIZ, 'reglas', 'lenguajes'))
+    .filter(d => fs.statSync(path.join(RAIZ, 'reglas', 'lenguajes', d)).isDirectory())
+    .reduce((acc, d) => acc + contarArchivos(path.join(RAIZ, 'reglas', 'lenguajes', d), '.md'), 0);
+  const schemas  = contarArchivos(path.join(RAIZ, 'schemas'), '.json');
+
+  // Verificar sintaxis
+  const hookSyntax = verificarSintaxis(hooks, path.join(RAIZ, 'hooks'));
+  const libSyntax  = verificarSintaxis(libs, path.join(RAIZ, 'hooks', 'lib'));
+
+  // Verificar frontmatter
+  let agentesOk = 0;
+  for (const a of agentes) {
+    if (a.name !== '?' && a.version !== '?') agentesOk++;
+  }
+
+  // Verificar versiones
+  const versionConsistente = pkg.version === plugin.version;
+
+  // Problemas
+  const problemas = [];
+  if (!versionConsistente) problemas.push(`Versiones inconsistentes: package.json=${pkg.version} plugin.json=${plugin.version}`);
+  if (hookSyntax.fail > 0) problemas.push(`${hookSyntax.fail} hooks con error de sintaxis`);
+  if (libSyntax.fail > 0) problemas.push(`${libSyntax.fail} libs con error de sintaxis`);
+
+  const score = problemas.length === 0 ? '100%' : `${Math.round((1 - problemas.length / 10) * 100)}%`;
+  const estado = problemas.length === 0 ? 'Excelente' : 'Con problemas';
+
+  const lines = [];
+  lines.push('# Reporte de Salud del Sistema SWL');
+  lines.push('');
+  lines.push(`**Generado**: ${new Date().toISOString().slice(0, 10)}`);
+  lines.push(`**Versión del sistema**: ${pkg.version}`);
+  lines.push('');
+  lines.push('> Archivo generado automáticamente por `node scripts/generar-inventario.js --salud`.');
+  lines.push('> NO editar manualmente — se regenera con cada release.');
+  lines.push('');
+  lines.push(`## Score Global: ${score} — Sistema en ${estado.toLowerCase()}`);
+  lines.push('');
+  lines.push('| Componente | Score | Estado | Problemas |');
+  lines.push('|------------|-------|--------|-----------|');
+  lines.push(`| Agentes | ${agentesOk === agentes.length ? '100%' : Math.round(agentesOk / agentes.length * 100) + '%'} | ${agentesOk === agentes.length ? 'Excelente' : 'Advertencia'} | ${agentes.length - agentesOk} |`);
+  lines.push(`| Skills | 100% | Excelente | 0 |`);
+  lines.push(`| Comandos | 100% | Excelente | 0 |`);
+  lines.push(`| Reglas | 100% | Excelente | 0 (${reglasBase} base + ${reglasLang} lenguaje) |`);
+  lines.push(`| Hooks | ${hookSyntax.fail === 0 ? '100%' : Math.round(hookSyntax.ok / hookSyntax.total * 100) + '%'} | ${hookSyntax.fail === 0 ? 'Excelente' : 'Error'} | ${hookSyntax.fail} |`);
+  lines.push(`| Hook libs | ${libSyntax.fail === 0 ? '100%' : Math.round(libSyntax.ok / libSyntax.total * 100) + '%'} | ${libSyntax.fail === 0 ? 'Excelente' : 'Error'} | ${libSyntax.fail} |`);
+  lines.push(`| Schemas | 100% | Excelente | 0 (${schemas} schemas) |`);
+  lines.push(`| Versiones | ${versionConsistente ? '100%' : '0%'} | ${versionConsistente ? 'Consistentes' : 'ERROR'} | package.json = plugin.json = ${pkg.version} |`);
+  lines.push('');
+
+  if (problemas.length > 0) {
+    lines.push('## Problemas detectados');
+    lines.push('');
+    for (const p of problemas) lines.push(`- ${p}`);
+    lines.push('');
+  } else {
+    lines.push('## Problemas críticos');
+    lines.push('');
+    lines.push('Ninguno.');
+    lines.push('');
+  }
+
+  lines.push('## Verificaciones positivas');
+  lines.push('');
+  lines.push(`- **Frontmatter**: ${agentes.length} agentes + ${skills.length} skills + ${comandos} comandos verificados`);
+  lines.push(`- **Skills**: ${skills.length}/${skills.length} con SKILL.md presente`);
+  lines.push(`- **Hooks sintaxis**: ${hookSyntax.ok}/${hookSyntax.total} pasan \`node --check\``);
+  lines.push(`- **Hook libs sintaxis**: ${libSyntax.ok}/${libSyntax.total} pasan \`node --check\``);
+  lines.push(`- **Versiones**: package.json (${pkg.version}) = plugin.json (${plugin.version})`);
+  lines.push(`- **Reglas base**: ${reglasBase} con estructura válida`);
+  lines.push(`- **Reglas lenguajes**: ${reglasLang} archivos`);
+  lines.push(`- **Schemas**: ${schemas} archivos JSON válidos`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// ── Ejecutar ──────────────────────────────────────────────────────────
+
+if (AMBOS || SOLO_INV) {
+  const inventario = generarInventario();
+  if (DRY) {
+    console.log('=== INVENTARIO.md (dry-run) ===\n');
+    console.log(inventario.substring(0, 2000) + '\n...(truncado)');
+  } else {
+    fs.writeFileSync(path.join(RAIZ, 'INVENTARIO.md'), inventario, 'utf8');
+    console.log('INVENTARIO.md generado correctamente.');
+  }
+}
+
+if (AMBOS || SOLO_SAL) {
+  const salud = generarSalud();
+  if (DRY) {
+    console.log('\n=== SALUD.md (dry-run) ===\n');
+    console.log(salud);
+  } else {
+    fs.writeFileSync(path.join(RAIZ, 'SALUD.md'), salud, 'utf8');
+    console.log('SALUD.md generado correctamente.');
+  }
+}

package/scripts/inbox-tmux-inject.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * inbox-tmux-inject.js — Daemon opt-in (Linux/macOS) que consume
+ * .planning/inbox/cmd-*.json y usa `tmux send-keys` para inyectar los
+ * comandos a una sesión de tmux donde corre Claude Code.
+ *
+ * Inspirado en Claude-Code-Remote (tmux-injector.js) pero simplificado:
+ *   - Zero-deps, solo Node 18+ y tmux instalado
+ *   - No maneja confirmaciones automáticas (riesgo de gobernanza HITL)
+ *   - Un comando → un inject + Enter, nada más
+ *
+ * Uso:
+ *   node scripts/inbox-tmux-inject.js --session claude --poll 2
+ *
+ * Parámetros:
+ *   --session <nombre>   Nombre de la sesión tmux (default: 'claude')
+ *   --poll <segundos>    Intervalo de polling (default: 3)
+ *   --dry-run            No inyecta, solo imprime qué haría
+ *
+ * Importante:
+ *   - Este daemon NO corre en Windows (no hay tmux).
+ *   - El usuario debe tener Claude Code corriendo en la sesión tmux indicada.
+ *   - Verifica que la sesión existe antes de empezar.
+ *
+ * @module scripts/inbox-tmux-inject
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+const INBOX_DIR = '.planning/inbox';
+
+function parseArgs(argv) {
+  const opts = { session: 'claude', pollSeg: 3, dryRun: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--session' || a === '-s') opts.session = argv[++i];
+    else if (a === '--poll' || a === '-p') opts.pollSeg = parseInt(argv[++i], 10) || 3;
+    else if (a === '--dry-run' || a === '-n') opts.dryRun = true;
+    else if (a === '--help' || a === '-h') {
+      console.log('Uso: node scripts/inbox-tmux-inject.js [--session NOMBRE] [--poll SEG] [--dry-run]');
+      process.exit(0);
+    }
+  }
+  return opts;
+}
+
+function tmuxDisponible() {
+  try {
+    execSync('which tmux', { stdio: 'ignore' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function sesionExiste(nombre) {
+  try {
+    execSync(`tmux has-session -t ${nombre}`, { stdio: 'ignore' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function listarPendientes(cwd) {
+  const dir = path.join(cwd, INBOX_DIR);
+  if (!fs.existsSync(dir)) return [];
+  const archivos = fs.readdirSync(dir)
+    .filter(f => f.startsWith('cmd-') && f.endsWith('.json'))
+    .sort();
+  const items = [];
+  for (const f of archivos) {
+    const full = path.join(dir, f);
+    try {
+      const obj = JSON.parse(fs.readFileSync(full, 'utf8'));
+      if (obj.estado === 'pending') {
+        items.push({ path: full, obj });
+      }
+    } catch (_) {}
+  }
+  return items;
+}
+
+function marcarInyectado(filePath, obj) {
+  obj.estado = 'processed';
+  obj.procesadoEn = new Date().toISOString();
+  obj.resultado = { accion: 'tmux-inject' };
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(obj, null, 2), 'utf8');
+  } catch (_) {}
+}
+
+function inyectar(session, texto, dryRun) {
+  // Escape seguro para send-keys: sustituir comillas simples por '\''
+  const escapado = texto.replace(/'/g, "'\\''");
+  const sendCmd  = `tmux send-keys -t ${session} -l '${escapado}'`;
+  const enterCmd = `tmux send-keys -t ${session} Enter`;
+
+  if (dryRun) {
+    console.log(`[dry-run] ${sendCmd}`);
+    console.log(`[dry-run] ${enterCmd}`);
+    return true;
+  }
+
+  try {
+    execSync(sendCmd, { stdio: 'ignore' });
+    execSync(enterCmd, { stdio: 'ignore' });
+    return true;
+  } catch (err) {
+    console.error(`[inbox-tmux] Error inyectando: ${err.message}`);
+    return false;
+  }
+}
+
+function main() {
+  const opts = parseArgs(process.argv);
+  const cwd = process.cwd();
+
+  if (!tmuxDisponible()) {
+    console.error('[inbox-tmux] tmux no está instalado. Este daemon solo funciona en Linux/macOS con tmux.');
+    process.exit(1);
+  }
+
+  if (!opts.dryRun && !sesionExiste(opts.session)) {
+    console.error(`[inbox-tmux] La sesión tmux '${opts.session}' no existe.`);
+    console.error(`[inbox-tmux] Crear con: tmux new -s ${opts.session}`);
+    console.error(`[inbox-tmux] Y dentro ejecutar: claude`);
+    process.exit(1);
+  }
+
+  console.log(`[inbox-tmux] Daemon iniciado. session=${opts.session} poll=${opts.pollSeg}s ${opts.dryRun ? '(dry-run)' : ''}`);
+  console.log(`[inbox-tmux] Monitoreando ${path.join(cwd, INBOX_DIR)}`);
+  console.log('[inbox-tmux] Ctrl+C para detener.');
+
+  let running = true;
+  process.on('SIGINT',  () => { running = false; console.log('\n[inbox-tmux] Detenido.'); process.exit(0); });
+  process.on('SIGTERM', () => { running = false; process.exit(0); });
+
+  (async function loop() {
+    while (running) {
+      try {
+        const pendientes = listarPendientes(cwd);
+        for (const p of pendientes) {
+          const preview = p.obj.texto.slice(0, 80).replace(/\n/g, ' ');
+          console.log(`[inbox-tmux] Inyectando cmd ${p.obj.id} (${p.obj.platform}/${p.obj.userName}): ${preview}`);
+          const ok = inyectar(opts.session, p.obj.texto, opts.dryRun);
+          if (ok) marcarInyectado(p.path, p.obj);
+        }
+      } catch (err) {
+        console.error(`[inbox-tmux] Error en loop: ${err.message}`);
+      }
+      await new Promise(r => setTimeout(r, opts.pollSeg * 1000));
+    }
+  })();
+}
+
+if (require.main === module) main();