@saulwade/swl-ses 1.2.2 → 1.3.1

package/scripts/lib/transformadores/claude.js

@@ -1,124 +1,200 @@
-'use strict';
-
-const TransformadorBase = require('./base');
-
-class TransformadorClaude extends TransformadorBase {
-  transformarAgente(contenidoMd, metadatos) {
-    // Pass-through: Claude soporta el formato SWL directamente
-    return {
-      contenido: contenidoMd,
-      rutaRelativa: `agents/${metadatos.nombreArchivo}`,
-    };
-  }
-
-  transformarSkill(dirSkill, metadatos) {
-    // Pass-through: copiar directorio completo
-    return {
-      tipo: 'directorio',
-      rutaRelativa: `skills/${metadatos.nombreDirectorio}`,
-    };
-  }
-
-  transformarRegla(contenidoMd, metadatos) {
-    return {
-      contenido: contenidoMd,
-      rutaRelativa: `rules/${metadatos.nombreArchivo}`,
-    };
-  }
-
-  transformarComando(contenidoMd, metadatos) {
-    return {
-      contenido: contenidoMd,
-      rutaRelativa: `commands/swl/${metadatos.nombreArchivo}`,
-    };
-  }
-
-  /**
-   * Genera el bloque SWL para insertar en el CLAUDE.md del proyecto destino.
-   *
-   * A diferencia de los otros transformadores (codex/gemini/copilot/opencode)
-   * que generan el archivo completo de instrucciones desde cero, Claude usa
-   * un CLAUDE.md que el usuario mantiene y que puede tener contenido propio
-   * (reglas del proyecto, convenciones, notas). Por eso:
-   *
-   *   - El contenido devuelto es un BLOQUE (no archivo completo)
-   *   - Se devuelve `merge: { tipo: 'marcadores', ... }` para indicar al
-   *     caller que debe usar `append-con-marcadores` en lugar de writeFileSync
-   *   - Los marcadores `<!-- SWL-BEGIN vX.Y.Z -->` / `<!-- SWL-END -->`
-   *     permiten que la siguiente actualización reemplace solo este bloque
-   *     sin tocar el contenido del usuario
-   *
-   * El bloque es CONCISO a propósito: apunta a `.claude/` y a los comandos
-   * `/swl:*` en lugar de replicar el contenido completo del sistema. Objetivo:
-   * que Claude sepa que el sistema SWL está instalado y debe priorizarlo,
-   * sin inflar el CLAUDE.md del proyecto.
-   */
-  generarArchivoInstrucciones(contexto) {
-    const fecha = new Date().toISOString().split('T')[0];
-    const lineas = [
-      `> Gestionado por swl-ses v${contexto.version} — no editar entre estos marcadores.`,
-      `> Regenerado en ${fecha} con perfil \`${contexto.perfil || 'default'}\`.`,
-      `> Para excluir este bloque en futuras actualizaciones: \`npx swl-ses@latest install --no-claudemd\`.`,
-      '',
-      '## Sistema SWL — uso obligatorio',
-      '',
-      `Este proyecto usa swl-ses v${contexto.version} (sistema de ingeniería de software auto-evolutivo multi-runtime).`,
-      `Componentes instalados: ${contexto.conteos?.agentes || 0} agentes, ${contexto.conteos?.skills || 0} skills, ${contexto.conteos?.comandos || 0} comandos, ${contexto.conteos?.reglas || 0} reglas.`,
-      '',
-      '### Reglas de máxima prioridad',
-      '',
-      '1. **Idioma: español de México** — respuestas, código comentado, commits, PRs y docs. Evitar anglicismos innecesarios.',
-      '2. **Usar el sistema SWL** — invocar agentes especializados (`orquestador-swl`, `implementador-swl`, `depurador-swl`, etc.) en lugar de hacer trabajo directo. Cargar skills con `Skill("nombre")` antes de implementar. Usar comandos `/swl:*` cuando apliquen.',
-      '3. **Investigar antes de editar** — leer el archivo completo y entender el contexto antes de modificar código.',
-      '4. **Lectura de documentos Office/Jupyter** — usar `python scripts/vendor/markitdown/cli.py <archivo>` para `.docx`, `.xlsx`, `.pptx`, `.ipynb`. El Read tool no soporta esos formatos.',
-      '',
-      '### Dónde están los componentes',
-      '',
-      '- Agentes: `.claude/agents/*.md`',
-      '- Skills: `.claude/skills/*/SKILL.md` (invocar con `Skill("nombre")`)',
-      '- Comandos: `.claude/commands/swl/*.md` (invocar con `/swl:nombre`)',
-      '- Reglas: `.claude/rules/*.md` (se cargan automáticamente)',
-      '- Hooks: registrados en `.claude/settings.json`',
-      '',
-      '### Flujos recomendados',
-      '',
-      '- **Feature completa**: `/swl:discutir-fase N` → `/swl:planear-fase N` → `/swl:ejecutar-fase N` → `/swl:verificar`',
-      '- **Debugging**: delegar a `depurador-swl` con método científico (reproducir → aislar → hipótesis → fix → verificar)',
-      '- **Calidad**: `/swl:revisar` (código) + `revisor-seguridad-swl` antes de merge a main',
-      '- **Aprendizaje continuo**: `/swl:aprender` al final de fase, `/swl:evolucionar` ante fallos recurrentes de agentes',
-      '',
-      '### Consulta del sistema',
-      '',
-      '- `/swl:ayuda` — catálogo completo de comandos',
-      '- `/swl:salud` — diagnóstico de integridad',
-      '- `/swl:metricas` — tokens, costo y modelos usados en la sesión',
-      '- `/swl:skill-search <keyword>` — buscar skills relevantes',
-      '',
-      '### Convenciones de versionado y commits',
-      '',
-      '- Versionado semántico estricto (SemVer)',
-      '- Mensajes de commit en español, formato `<tipo>(<scope>): <descripción en imperativo>`',
-      '- Commits atómicos (un cambio lógico = un commit)',
-      '- Antes de release: `/swl:release` y gate `node scripts/verificar-release.js`',
-    ];
-
-    return {
-      contenido: lineas.join('\n'),
-      rutaRelativa: 'CLAUDE.md',
-      dirBase: '.',
-      merge: {
-        tipo: 'marcadores',
-        beginTag: `<!-- SWL-BEGIN v${contexto.version} — bloque gestionado por swl-ses -->`,
-        endTag: '<!-- SWL-END -->',
-        beginPrefix: '<!-- SWL-BEGIN',
-      },
-    };
-  }
-
-  transformarHooks(hooksConfig, opciones) {
-    // Los hooks de Claude se manejan via hooks-settings.js existente
-    return { formato: 'claude-settings', config: hooksConfig };
-  }
-}
-
-module.exports = TransformadorClaude;
+'use strict';
+
+const TransformadorBase = require('./base');
+const { detectarStackDetallado } = require('../detectar-stack-detallado');
+
+class TransformadorClaude extends TransformadorBase {
+  transformarAgente(contenidoMd, metadatos) {
+    // Pass-through: Claude soporta el formato SWL directamente
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `agents/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    // Pass-through: copiar directorio completo
+    return {
+      tipo: 'directorio',
+      rutaRelativa: `skills/${metadatos.nombreDirectorio}`,
+    };
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `rules/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `commands/swl/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  /**
+   * Genera el bloque SWL para insertar en el CLAUDE.md del proyecto destino.
+   *
+   * A diferencia de los otros transformadores (codex/gemini/copilot/opencode)
+   * que generan el archivo completo de instrucciones desde cero, Claude usa
+   * un CLAUDE.md que el usuario mantiene y que puede tener contenido propio
+   * (reglas del proyecto, convenciones, notas). Por eso:
+   *
+   *   - El contenido devuelto es un BLOQUE (no archivo completo)
+   *   - Se devuelve `merge: { tipo: 'marcadores', ... }` para indicar al
+   *     caller que debe usar `append-con-marcadores` en lugar de writeFileSync
+   *   - Los marcadores `<!-- SWL-BEGIN vX.Y.Z -->` / `<!-- SWL-END -->`
+   *     permiten que la siguiente actualización reemplace solo este bloque
+   *     sin tocar el contenido del usuario
+   *
+   * Aplicación de ADR-0016 (best practices Anthropic "The CLAUDE.md file"):
+   *   - Detecta stack del proyecto destino (lenguaje, framework, ORM,
+   *     package manager, comandos disponibles)
+   *   - Genera secciones canónicas: Stack / Comandos del proyecto / Sistema SWL
+   *   - Documenta jerarquía project / user-level (`~/.claude/CLAUDE.md`)
+   *   - Documenta patrón "ask Claude to save to memory" del video oficial
+   */
+  generarArchivoInstrucciones(contexto) {
+    const fecha = new Date().toISOString().split('T')[0];
+    const stack = contexto.dirProyecto
+      ? this._detectarStackSeguro(contexto.dirProyecto)
+      : null;
+
+    const lineas = [
+      `> Gestionado por swl-ses v${contexto.version} — no editar entre estos marcadores.`,
+      `> Regenerado en ${fecha} con perfil \`${contexto.perfil || 'default'}\`.`,
+      `> Para excluir este bloque en futuras actualizaciones: \`npx swl-ses@latest install --no-claudemd\`.`,
+      '',
+    ];
+
+    // ─── Stack del proyecto detectado (best practice Anthropic #2) ─────────
+    if (stack && stack.detectado) {
+      lineas.push('## Stack del proyecto');
+      lineas.push('');
+      const partes = [];
+      if (stack.lenguajePrincipal) {
+        partes.push(`**Lenguaje**: ${stack.lenguajePrincipal.lenguaje}` +
+          (stack.lenguajePrincipal.runtime ? ` (${stack.lenguajePrincipal.runtime})` : ''));
+      }
+      if (stack.framework) partes.push(`**Framework**: ${stack.framework}`);
+      if (stack.orm) partes.push(`**ORM/BD**: ${stack.orm}`);
+      if (stack.packageManager) partes.push(`**Package manager**: ${stack.packageManager}`);
+      lineas.push('- ' + partes.join('\n- '));
+      lineas.push('');
+    }
+
+    // ─── Comandos del proyecto (best practice Anthropic #3) ────────────────
+    if (stack && stack.comandos && stack.comandos.length > 0) {
+      lineas.push('## Comandos del proyecto');
+      lineas.push('');
+      lineas.push('| Comando | Propósito |');
+      lineas.push('|---------|-----------|');
+      for (const c of stack.comandos) {
+        lineas.push(`| \`${c.comando}\` | ${c.proposito} |`);
+      }
+      lineas.push('');
+    }
+
+    // ─── Sistema SWL (siempre presente) ────────────────────────────────────
+    lineas.push('## Sistema SWL — uso obligatorio');
+    lineas.push('');
+    lineas.push(`Este proyecto usa swl-ses v${contexto.version} (sistema de ingeniería de software auto-evolutivo multi-runtime).`);
+    lineas.push(`Componentes instalados: ${contexto.conteos?.agentes || 0} agentes, ${contexto.conteos?.skills || 0} skills, ${contexto.conteos?.comandos || 0} comandos, ${contexto.conteos?.reglas || 0} reglas.`);
+    lineas.push('');
+
+    lineas.push('### Reglas de máxima prioridad');
+    lineas.push('');
+    lineas.push('1. **Idioma: español de México** — respuestas, código comentado, commits, PRs y docs. Evitar anglicismos innecesarios.');
+    lineas.push('2. **Usar el sistema SWL** — invocar agentes especializados (`orquestador-swl`, `implementador-swl`, `depurador-swl`, etc.) en lugar de hacer trabajo directo. Cargar skills con `Skill("nombre")` antes de implementar. Usar comandos `/swl:*` cuando apliquen.');
+    lineas.push('3. **Investigar antes de editar** — leer el archivo completo y entender el contexto antes de modificar código.');
+    lineas.push('4. **Lectura de documentos Office/Jupyter** — usar `python scripts/vendor/markitdown/cli.py <archivo>` para `.docx`, `.xlsx`, `.pptx`, `.ipynb`. El Read tool no soporta esos formatos.');
+    lineas.push('');
+
+    lineas.push('### Dónde están los componentes');
+    lineas.push('');
+    lineas.push('- Agentes: `.claude/agents/*.md`');
+    lineas.push('- Skills: `.claude/skills/*/SKILL.md` (invocar con `Skill("nombre")`)');
+    lineas.push('- Comandos: `.claude/commands/swl/*.md` (invocar con `/swl:nombre`)');
+    lineas.push('- Reglas: `.claude/rules/*.md` (se cargan automáticamente)');
+    lineas.push('- Hooks: registrados en `.claude/settings.json`');
+    lineas.push('');
+
+    lineas.push('### Flujos recomendados');
+    lineas.push('');
+    lineas.push('- **Feature completa**: `/swl:discutir-fase N` → `/swl:planear-fase N` → `/swl:ejecutar-fase N` → `/swl:verificar`');
+    lineas.push('- **Debugging**: delegar a `depurador-swl` con método científico (reproducir → aislar → hipótesis → fix → verificar)');
+    lineas.push('- **Calidad**: `/swl:revisar` (código) + `revisor-seguridad-swl` antes de merge a main');
+    lineas.push('- **Aprendizaje continuo**: `/swl:aprender` al final de fase, `/swl:evolucionar` ante fallos recurrentes de agentes');
+    lineas.push('');
+
+    lineas.push('### Consulta del sistema');
+    lineas.push('');
+    lineas.push('- `/swl:ayuda` — catálogo completo de comandos');
+    lineas.push('- `/swl:salud` — diagnóstico de integridad (incluye calidad de CLAUDE.md)');
+    lineas.push('- `/swl:metricas` — tokens, costo y modelos usados en la sesión');
+    lineas.push('- `/swl:skill-search <keyword>` — buscar skills relevantes');
+    lineas.push('- `/swl:claudemd audit` — auditar este CLAUDE.md (líneas, bullets gigantes, secciones canónicas)');
+    lineas.push('');
+
+    lineas.push('### Convenciones de versionado y commits');
+    lineas.push('');
+    lineas.push('- Versionado semántico estricto (SemVer)');
+    lineas.push('- Mensajes de commit en español, formato `<tipo>(<scope>): <descripción en imperativo>`');
+    lineas.push('- Commits atómicos (un cambio lógico = un commit)');
+    lineas.push('- Antes de release: `/swl:release` y gate `node scripts/verificar-release.js`');
+    lineas.push('');
+
+    // ─── Jerarquía project / user-level (best practice Anthropic) ─────────
+    lineas.push('### Jerarquía de CLAUDE.md (recomendada)');
+    lineas.push('');
+    lineas.push('- **Project-level** (este archivo, `./CLAUDE.md`) — convenciones del proyecto, compartido vía VCS con el equipo.');
+    lineas.push('- **User-level** (`~/.claude/CLAUDE.md`) — preferencias personales transversales (estilo de comentarios, lenguaje preferido, atajos personales). NO se commitea.');
+    lineas.push('- Las **reglas globales** del usuario en `~/.claude/rules/*.md` se cargan automáticamente para todos los proyectos.');
+    lineas.push('- Si no tienes user-level, créalo con `/swl:claudemd init-user`.');
+    lineas.push('');
+
+    // ─── Patrón "ask Claude to save to memory" del video oficial ──────────
+    lineas.push('### Cómo evolucionar este archivo');
+    lineas.push('');
+    lineas.push('1. **Empieza mínimo**. No adelantes reglas. Agrega solo lo que tengas que corregir más de una vez.');
+    lineas.push('2. **Cuando corrijas a Claude**, pide explícitamente: *"guarda esto en memoria"* o *"agrega esto a CLAUDE.md"*. Esa es la forma natural de que el archivo crezca con valor.');
+    lineas.push('3. **Usa `@filepath`** para referenciar docs sin duplicar contenido (ej. `@docs/api.md`, `@.planning/PROYECTO.md`).');
+    lineas.push('4. **Si crece mucho**, ejecuta `/swl:claudemd refactor` para extraer secciones a archivos `@`-referenciados.');
+    lineas.push('');
+
+    return {
+      contenido: lineas.join('\n'),
+      rutaRelativa: 'CLAUDE.md',
+      dirBase: '.',
+      merge: {
+        tipo: 'marcadores',
+        beginTag: `<!-- SWL-BEGIN v${contexto.version} — bloque gestionado por swl-ses -->`,
+        endTag: '<!-- SWL-END -->',
+        beginPrefix: '<!-- SWL-BEGIN',
+      },
+    };
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    // Los hooks de Claude se manejan via hooks-settings.js existente
+    return { formato: 'claude-settings', config: hooksConfig };
+  }
+
+  /**
+   * Wrapper defensivo: si la detección de stack falla por cualquier razón
+   * (permisos, archivo corrupto, etc.), se ignora y se genera el bloque
+   * sin secciones de stack. NUNCA romper el installer.
+   */
+  _detectarStackSeguro(dirProyecto) {
+    try {
+      return detectarStackDetallado(dirProyecto);
+    } catch (e) {
+      // Silencioso: stack no detectado, bloque base se genera igualmente
+      return null;
+    }
+  }
+}
+
+module.exports = TransformadorClaude;

package/scripts/publicar.js

@@ -12,10 +12,11 @@
 
 'use strict';
 
-const { execFileSync } = require('child_process');
+const { execFileSync, spawnSync } = require('child_process');
 const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
+const readline = require('readline');
 
 const {
   NOMBRE_GITHUB_MIRROR: GITHUB_NAME,
@@ -58,6 +59,159 @@ function npmExec(args, opts = {}) {
   return execFileSync(bin, args, { ...defaults, ...opts });
 }
 
+/**
+ * Variante de npmExec que captura stderr para detección posterior de errores
+ * estructurados (ej: EOTP). stdout sigue heredado (live-streaming visible al
+ * usuario) y stderr se pipea a un buffer + se ecoa a process.stderr al final.
+ *
+ * Retorna { status, stderr } sin lanzar — el caller inspecciona el status.
+ */
+function npmSpawnCaptureStderr(args, opts = {}) {
+  const defaults = { cwd: ROOT, timeout: 300_000, env: process.env };
+  const merged = { ...defaults, ...opts, stdio: ['inherit', 'inherit', 'pipe'] };
+  let res;
+  if (NPM_CLI_JS) {
+    res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
+  } else {
+    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    res = spawnSync(bin, args, merged);
+  }
+  const stderr = res.stderr ? String(res.stderr) : '';
+  // Ecoar stderr al usuario para que vea el diagnóstico de npm aunque se capturó.
+  if (stderr) process.stderr.write(stderr);
+  return { status: res.status, signal: res.signal, stderr, error: res.error };
+}
+
+/**
+ * Detecta si un blob de stderr indica que npm requiere una OTP de 2FA.
+ * Match defensivo: cubre tanto el código de error explícito (`EOTP`) como el
+ * mensaje canónico ("requires a one-time password"), porque npm ha cambiado
+ * el formato del mensaje entre versiones (npm 8 vs 10+).
+ *
+ * Pura — testeable sin dependencias. Exportada para tests.
+ */
+function esErrorOTP(stderr) {
+  if (!stderr) return false;
+  const blob = String(stderr);
+  return /\bEOTP\b/.test(blob) || /one-time password/i.test(blob);
+}
+
+/**
+ * Solicita una OTP al usuario via stdin (readline síncrono).
+ * Retorna la OTP normalizada (string de 6 dígitos) o null si:
+ *   - stdin no es TTY (CI, pipe) → no se puede pedir interactivamente
+ *   - el usuario cancela con Ctrl+C / línea vacía
+ *   - el formato no es válido (no 6 dígitos)
+ *
+ * El caller debe manejar el caso null como "fallback a guía manual".
+ */
+function solicitarOTPInteractiva() {
+  if (!process.stdin.isTTY) {
+    process.stderr.write('[publicar] stdin no es TTY: no se puede pedir OTP interactivamente.\n');
+    process.stderr.write('[publicar] Configurar NPM_CONFIG_OTP=<otp> antes de invocar este script.\n');
+    return null;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  // questionSync vía promesa NO funciona aquí — el script es síncrono.
+  // Usamos un truco: readline es async-only, así que dejamos al usuario
+  // el manejo bloqueante leyendo línea por línea con readSync vía read-int.
+  // Pero readline no expone modo síncrono. Alternativa: leer de stdin con
+  // fd 0 + readSync. En Windows con TTY funciona; en Linux idem.
+  try {
+    process.stderr.write('\nNPM requiere OTP (2FA). Ingresa el código de 6 dígitos de tu autenticador: ');
+    const otp = leerLineaStdinSync().trim();
+    rl.close();
+    if (!/^\d{6}$/.test(otp)) {
+      process.stderr.write(`\n[publicar] OTP inválida: se esperan 6 dígitos, se recibió: "${otp.slice(0, 20)}"\n`);
+      return null;
+    }
+    return otp;
+  } catch (err) {
+    rl.close();
+    process.stderr.write(`\n[publicar] error leyendo OTP: ${String(err.message).slice(0, 120)}\n`);
+    return null;
+  }
+}
+
+/**
+ * Lectura síncrona de una línea de stdin. Necesario porque readline solo
+ * expone API asíncrona, pero todo el flujo de publicar.js es síncrono.
+ * Lee byte por byte hasta encontrar newline o EOF.
+ */
+function leerLineaStdinSync() {
+  const BUFFER_SIZE = 256;
+  const buf = Buffer.alloc(BUFFER_SIZE);
+  let line = '';
+  while (true) {
+    let bytesRead;
+    try {
+      bytesRead = fs.readSync(0, buf, 0, BUFFER_SIZE, null);
+    } catch (err) {
+      // EAGAIN en stdin no-bloqueante: poco común en TTY, pero defensivo.
+      if (err.code === 'EAGAIN') continue;
+      throw err;
+    }
+    if (bytesRead === 0) break; // EOF
+    const chunk = buf.slice(0, bytesRead).toString('utf-8');
+    const nlIdx = chunk.indexOf('\n');
+    if (nlIdx >= 0) {
+      line += chunk.slice(0, nlIdx);
+      break;
+    }
+    line += chunk;
+  }
+  return line.replace(/\r$/, ''); // Windows envía \r\n
+}
+
+/**
+ * Ejecuta un `npm publish` con soporte automático de OTP (2FA).
+ *
+ * Flujo:
+ *   1. Si NPM_CONFIG_OTP está definida en el entorno, se usa directamente
+ *      (npm la lee automáticamente — no hay que pasarla como flag).
+ *   2. Si el publish falla con EOTP/one-time password, se intenta solicitar
+ *      la OTP interactivamente y reintentar con --ignore-scripts (los
+ *      scripts pre-publish ya pasaron en el primer intento).
+ *   3. Si no se puede obtener OTP (no TTY o usuario cancela), reporta el
+ *      error y retorna false.
+ *
+ * Retorna: { ok: boolean, stderr: string }
+ *
+ * Exportada para tests.
+ */
+function ejecutarPublishConOTP(args, opts = {}) {
+  // Intento 1: con OTP de env si existe, sin ella si no.
+  const intento1 = npmSpawnCaptureStderr(args, opts);
+  if (intento1.status === 0) {
+    return { ok: true, stderr: intento1.stderr };
+  }
+
+  // Si NO es EOTP, no podemos hacer nada — propagamos el fallo.
+  if (!esErrorOTP(intento1.stderr)) {
+    return { ok: false, stderr: intento1.stderr };
+  }
+
+  // Es EOTP. Intentar solicitar OTP interactivamente.
+  process.stderr.write('\n[publicar] npm rechazó el publish con EOTP (2FA requerida).\n');
+  const otp = solicitarOTPInteractiva();
+  if (!otp) {
+    process.stderr.write('[publicar] No se obtuvo OTP. Aborta. Reintentar con:\n');
+    process.stderr.write(`  NPM_CONFIG_OTP=<otp> node scripts/publicar.js ${process.argv.slice(2).join(' ')}\n`);
+    return { ok: false, stderr: intento1.stderr };
+  }
+
+  // Reintento con OTP via env + --ignore-scripts (los pre-publish ya pasaron).
+  process.stderr.write('\n[publicar] Reintentando publish con OTP recibida...\n');
+  const envConOTP = { ...(opts.env || process.env), NPM_CONFIG_OTP: otp };
+  const argsConIgnore = args.includes('--ignore-scripts') ? args : [...args, '--ignore-scripts'];
+  const intento2 = npmSpawnCaptureStderr(argsConIgnore, { ...opts, env: envConOTP });
+  if (intento2.status === 0) {
+    return { ok: true, stderr: intento2.stderr };
+  }
+  return { ok: false, stderr: intento2.stderr };
+}
+
 function leerPkg() {
   return JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
 }
@@ -245,14 +399,13 @@ function publicarNpmjs(pkg, dryRun) {
 
   const args = ['publish', `--registry=${NPMJS_REGISTRY}`, '--access', 'public'];
   if (dryRun) args.push('--dry-run');
-  try {
-    npmExec(args);
+  const resultado = ejecutarPublishConOTP(args);
+  if (resultado.ok) {
     console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${pkg.name}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en npmjs`);
     return true;
-  } catch (err) {
-    console.error(`ERROR publicando en npmjs: ${err.message}`);
-    return false;
   }
+  console.error(`ERROR publicando en npmjs (ver stderr arriba para diagnóstico de npm).`);
+  return false;
 }
 
 function publicarGitHub(pkg, dryRun) {
@@ -272,17 +425,16 @@ function publicarGitHub(pkg, dryRun) {
 
   const args = ['publish', `--registry=${GITHUB_REGISTRY}`];
   if (dryRun) args.push('--dry-run');
-  try {
-    npmExec(args, { cwd: tmpDir });
+  const resultado = ejecutarPublishConOTP(args, { cwd: tmpDir });
+  if (resultado.ok) {
     console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${GITHUB_NAME}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en GitHub Packages`);
     if (dryRun) console.log(`Directorio temporal: ${tmpDir}`);
     limpiar(tmpDir);
     return true;
-  } catch (err) {
-    console.error(`ERROR publicando en GitHub Packages: ${err.message}`);
-    limpiar(tmpDir);
-    return false;
   }
+  console.error(`ERROR publicando en GitHub Packages (ver stderr arriba para diagnóstico de npm).`);
+  limpiar(tmpDir);
+  return false;
 }
 
 function parsearArgs(argv) {
@@ -350,6 +502,8 @@ if (require.main === module) {
     prepararDirectorioTemporal,
     copiarDir,
     limpiar,
+    esErrorOTP,
+    ejecutarPublishConOTP,
     GITHUB_NAME,
     GITHUB_REGISTRY,
     NPMJS_REGISTRY,