@saulwade/swl-ses 2.1.0 → 2.2.0

package/habilidades/swl-claudemd/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: swl-claudemd
 description: Conocimiento operacional para auditar y mantener archivos CLAUDE.md — contrato canónico de secciones (best practices Anthropic, ADR-0016), umbrales de bloat (líneas totales, bullets gigantes, placeholders, @references rotas), reglas de extracción a archivos referenciados con @, y plantillas de inicialización (init-user para ~/.claude/CLAUDE.md, init-project para CLAUDE.md raíz detectando stack). Provee las reglas; el comando /swl:claudemd ejecuta el flujo. Cargar desde ese comando o cuando el hook claudemd-bloat-detector sugiera intervención.
-version: "1.2.1"
+version: "1.3.0"
 herramientasPermitidas: [Read, Write, Edit, Bash, Glob, Grep]
 exclusiones:
   - "No cargar para editar reglas globales en ~/.claude/rules/ — usar Edit directo."
@@ -58,12 +58,15 @@ Más dos prácticas auxiliares del video:
 Ejecuta el auditor determinista:
 
 ```bash
-node scripts/auditar-claudemd.js
-node scripts/auditar-claudemd.js --json    # para parsing
-node scripts/auditar-claudemd.js --strict  # exit 1 si WARN
+# Repo de swl-ses (script local): node scripts/auditar-claudemd.js [--json|--strict]
+# Proyecto downstream (NO existe el script local): usar el subcomando del CLI:
+npx -y @saulwade/swl-ses@latest audit-claudemd [--json|--strict]
 ```
 
-El auditor verifica ocho dimensiones:
+Regla: si `scripts/auditar-claudemd.js` no existe en el CWD, usar SIEMPRE
+`npx ... audit-claudemd` — ambas rutas ejecutan el mismo auditor.
+
+El auditor verifica nueve dimensiones (la fila `@references rotos` caza el `@reglas/...` roto downstream):
 
 | Dimensión | Regla | Severidad |
 |---|---|---|
@@ -72,6 +75,7 @@ El auditor verifica ocho dimensiones:
 | Bullets monolíticos | Cada bullet/párrafo ≤ `SWL_CLAUDEMD_MAX_BULLET_CHARS` (default 1000). Tablas y bloques de código se ignoran | WARN |
 | Secciones canónicas | Stack, Comandos, Code style, Conventions presentes | WARN |
 | @references | Archivos >80 líneas usan al menos un `@docs/...md` | WARN |
+| @references rotos | `@-include` con path relativo cuyo destino no existe (resuelto relativo al CLAUDE.md; omite `~/` y absolutas). Caza el `@reglas/...` roto en proyectos donde las reglas viven en `.claude/rules/` | WARN |
 | Placeholders | `[TBD]`, `[TODO]`, `[COMPLETAR]` | ERROR |
 | Karpathy reference | Project-level >50 LOC menciona "Karpathy", los 4 principios, o `prevencion-sobreingenieria` | WARN |
 | Duplicación reglas globales | Bloque inline parafrasea regla de `~/.claude/rules/` ya cargada globalmente (catálogo en `scripts/lib/reglas-globales-conocidas.json`) | WARN |
@@ -167,7 +171,7 @@ Genera `./CLAUDE.md` raíz del proyecto detectando stack actual.
 2. Ejecutar `detectarStackDetallado(process.cwd())` (de
    `scripts/lib/detectar-stack-detallado.js`).
 3. Generar archivo con secciones pobladas:
-   - **Reglas obligatorias**: `@reglas/usar-sistema-swl.md`
+   - **Reglas obligatorias**: mención de texto de la regla global `usar-sistema-swl.md` (auto-cargada desde `.claude/rules/`). NUNCA `@reglas/usar-sistema-swl.md` — esa ruta no existe en proyectos downstream y queda como @-include roto
    - **Reglas de máxima prioridad** con sub-sección **Cuatro principios de
      implementación (Karpathy)** — bloque exacto definido abajo
    - **Stack**: lenguaje + framework + ORM + package manager detectados

package/hooks/lib/propose-step.js

@@ -354,4 +354,5 @@ module.exports = {
   registrarPropose,
   registrarFeedback,
   categoriasSilenciadasPropose,
+  main,
 };

package/llms.txt

@@ -1,6 +1,6 @@
 # swl-ses (@saulwade/swl-ses)
 
-> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. 60 agentes, 182 habilidades, 44 comandos, 37 reglas base y 48 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 2.1.0.
+> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. 60 agentes, 182 habilidades, 44 comandos, 37 reglas base y 48 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 2.2.0.
 
 Archivo generado por `node scripts/generar-inventario.js` — no editar a mano. Las cifras se sincronizan con INVENTARIO.md en cada regeneración.
 

package/manifiestos/skills-lock.json

@@ -1,8 +1,8 @@
 {
   "lockfileVersion": 1,
-  "generatedAt": "2026-06-12T19:50:44.271Z",
+  "generatedAt": "2026-06-13T23:48:35.239Z",
   "skillsCount": 182,
-  "lockHash": "sha256:db10fd842d21ff25e267d1b7bf2894876450ed4ca3d379f035079501a6d7e9d3",
+  "lockHash": "sha256:9a83648f9615e563db51b1ff72c083526892f9dd1e0a34513dbc104e1caf29ff",
   "skills": [
     {
       "nombre": "accesibilidad-a11y",
@@ -1134,9 +1134,9 @@
     {
       "nombre": "swl-claudemd",
       "path": "habilidades/swl-claudemd/SKILL.md",
-      "hash": "sha256:b270cedba83127c2a45f4a639efce2f349a8645e42336bf44ca93a806dc1e53f",
-      "bytes": 15362,
-      "version": "\"1.2.1\""
+      "hash": "sha256:6e8abe48bacd9059047df2b33bcd4df20e46c88e3df6d6692800896c003050e7",
+      "bytes": 16060,
+      "version": "\"1.3.0\""
     },
     {
       "nombre": "swl-dashboard",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saulwade/swl-ses",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot con 60 agentes, 182 habilidades, 44 comandos, 77 reglas y 48 hooks. Soporta 11 lenguajes y 7 runtimes: Claude Code, OpenClaude, OpenCode, Gemini CLI, Cursor, Codex CLI (soporte completo); GitHub Copilot (soporte parcial). 100% en espanol (Mexico). Multi-target install (--target CSV / --all-runtimes), autoconfig MCP en Cursor/Codex con --with-mcp, agentes Codex en TOML, hooks Cursor (17 eventos) y Codex (6 eventos). Gateway bidireccional con relay Telegram y auditoria profunda Nemesis con loop evaluator-optimizer opt-in (ADR-0021) y 8 tools ejecutables. v1.8.0 unifica los directorios runtime de .planning/ al ingles (evolution/, auto-evolution/, user-profile/, archive/), manteniendo fases/ en espanol, con guard validar-planning-paths y allowlist canonica (ADR-0031). Hereda de v1.7.4: skill calidad-anti-patrones-universales + scripts/lib/pr-analyzer.js + 3 sub-secciones en estilo-sin-ai-isms.",
   "bin": {
     "swl-ses": "bin/swl-ses.js",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "swl-ses",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot. 60 agentes, 182 habilidades, 44 comandos, 77 reglas y 48 hooks. 76 librerias. 11 lenguajes. Soporta Claude Code, Copilot, OpenCode, Codex y Gemini CLI. Loop evaluator-optimizer en /swl:nemesis (ADR-0021). v1.8.0 unifica los directorios runtime de .planning/ al ingles (evolution/, auto-evolution/, user-profile/, archive/), manteniendo fases/ en espanol, con guard validar-planning-paths y allowlist canonica (ADR-0031). Hereda de v1.7.4: skill calidad-anti-patrones-universales + scripts/lib/pr-analyzer.js + 3 sub-secciones en estilo-sin-ai-isms.",
   "author": "Saul Wade Leon",
   "license": "MIT",

package/scripts/auditar-claudemd.js

@@ -86,6 +86,28 @@ function ubicarClaudeMd(dir = process.cwd()) {
   return null;
 }
 
+// Detecta @-includes con path RELATIVO al CLAUDE.md cuyo destino no existe.
+// Solo evalúa rutas relativas al proyecto — omite `~/` y rutas absolutas
+// porque su existencia depende del entorno de instalación, no del repo.
+// Causa raíz del bug downstream: plantillas que emitían `@reglas/...` cuando
+// las reglas se instalan en `.claude/rules/` (no en `reglas/` del proyecto).
+function detectarReferenciasRotas(contenido, rutaClaudeMd) {
+  const baseDir = path.dirname(rutaClaudeMd);
+  // Primer char [A-Za-z0-9_.] excluye `~` y `/` → solo captura rutas relativas.
+  const re = /@([A-Za-z0-9_.][A-Za-z0-9_./\-]*\.md)\b/g;
+  const rotas = [];
+  const vistos = new Set();
+  let m;
+  while ((m = re.exec(contenido)) !== null) {
+    const ref = m[1];
+    if (vistos.has(ref)) continue;
+    vistos.add(ref);
+    if (ref.startsWith('~') || path.isAbsolute(ref)) continue;
+    if (!fs.existsSync(path.resolve(baseDir, ref))) rotas.push(ref);
+  }
+  return rotas;
+}
+
 function auditar(rutaClaudeMd) {
   if (!rutaClaudeMd || !fs.existsSync(rutaClaudeMd)) {
     return {
@@ -150,6 +172,17 @@ function auditar(rutaClaudeMd) {
     }
   }
 
+  // 4b. @references rotos: @-includes con path relativo cuyo destino no existe.
+  const referenciasRotas = detectarReferenciasRotas(contenido, rutaClaudeMd);
+  for (const ref of referenciasRotas) {
+    hallazgos.push({
+      severidad: 'WARN',
+      regla: 'at-reference-rota',
+      mensaje: `@-reference rota: \`@${ref}\` no existe (resuelto relativo al CLAUDE.md)`,
+      sugerencia: 'Corregir la ruta o, si es una regla global auto-cargada (p. ej. usar-sistema-swl), eliminar el @-include y dejar solo mención de texto',
+    });
+  }
+
   // 5. Placeholders sin reemplazar
   const matches = [...contenido.matchAll(PLACEHOLDERS)];
   if (matches.length > 0) {
@@ -237,6 +270,7 @@ function auditar(rutaClaudeMd) {
       secciones_presentes: SECCIONES_CANONICAS.filter(s => s.regex.test(contenido)).map(s => s.nombre),
       secciones_ausentes: seccionesAusentes.map(s => s.nombre),
       tiene_at_references: /@[a-zA-Z][a-zA-Z0-9_\-./]+\.md/.test(contenido),
+      at_references_rotas: referenciasRotas,
       tiene_referencia_karpathy: tieneReferenciaKarpathy,
       es_project_level: esProjectLevel,
       duplicaciones_reglas_globales: {
@@ -375,6 +409,9 @@ function imprimirReporte(resultado) {
       console.log(`  - Secciones ausentes: ${m.secciones_ausentes.join(', ')}`);
     }
     console.log(`  - @references: ${m.tiene_at_references ? 'sí' : 'no'}`);
+    if (m.at_references_rotas && m.at_references_rotas.length > 0) {
+      console.log(`  - @references rotas: ${m.at_references_rotas.length} (${m.at_references_rotas.join(', ')})`);
+    }
     if (m.es_project_level) {
       console.log(`  - Referencia Karpathy: ${m.tiene_referencia_karpathy ? 'sí' : 'no'}`);
     }
@@ -436,6 +473,7 @@ module.exports = {
   ubicarClaudeMd,
   detectarBulletsGigantes,
   detectarReferenciaKarpathy,
+  detectarReferenciasRotas,
   esRutaUserLevel,
   main,
   MAX_LINES,

package/scripts/cli/aprobar-plan.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses aprobar-plan --fase=N` — parte determinista del gate G1.
+ *
+ * Reemplaza los `node -e "require('./scripts/lib/plan-lock')"` y
+ * `require('./hooks/lib/atomic-write')` que el slash command /swl:aprobar-plan
+ * tenía inline — rutas relativas al proyecto que se rompían en instalaciones
+ * downstream (ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Hace: firma el PLAN (SHA256 → .planning/locks/0N-PLAN.md.lock), lo verifica,
+ * y escribe .planning/locks/fase-activa.json (gate G0). El HITL (confirmación,
+ * transición de frontmatter, REQ×T) lo sigue manejando el prompt del comando.
+ *
+ * Uso: swl-ses aprobar-plan --fase=N [--plan=<ruta>] [--aprobado-por="texto"]
+ */
+
+const path = require('node:path');
+const { firmarPlan, verificarPlan } = require('../lib/plan-lock');
+const { atomicWriteJSON } = require('../../hooks/lib/atomic-write');
+const { resolverPlanPath } = require('../lib/resolver-plan-fase');
+
+function aprobarPlan(opciones = {}) {
+  opciones = opciones || {};
+  const planPath = resolverPlanPath(opciones);
+  if (!planPath) {
+    console.error('Uso: swl-ses aprobar-plan --fase=N [--plan=<ruta>] [--aprobado-por="texto"]');
+    process.exit(1);
+  }
+
+  const firmadoPor = opciones['aprobado-por'] || opciones.aprobado_por || 'swl:aprobar-plan';
+  const firma = firmarPlan(planPath, { firmadoPor });
+  if (!firma.ok) {
+    console.error(`[aprobar-plan] no se pudo firmar el PLAN: ${firma.motivo}`);
+    process.exit(1);
+  }
+
+  const ver = verificarPlan(planPath);
+  const numero =
+    opciones.fase != null && opciones.fase !== true ? Number(opciones.fase) : null;
+  const locksDir = path.dirname(firma.lockPath);
+  const faseActivaPath = path.join(locksDir, 'fase-activa.json');
+
+  atomicWriteJSON(faseActivaPath, {
+    numero,
+    planPath,
+    sha256: firma.sha256,
+    aprobadoEn: new Date().toISOString(),
+    aprobadoPor: opciones['aprobado-por'] || opciones.aprobado_por || 'usuario via /swl:aprobar-plan',
+  });
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        planPath,
+        sha256: firma.sha256,
+        lockPath: firma.lockPath,
+        modo: ver.modo,
+        faseActiva: faseActivaPath,
+      },
+      null,
+      2
+    )
+  );
+}
+
+module.exports = aprobarPlan;
+
+if (require.main === module) {
+  const { parsearOpciones } = require('../lib/parsear-opciones');
+  aprobarPlan(parsearOpciones(process.argv.slice(2)));
+}

package/scripts/cli/briefing.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses briefing` — recolecta las señales baratas del briefing
+ * (adr-vencido, deuda-trigger, nudges-pendientes, gate-calibracion,
+ * continue-here) y las imprime sin tope. Reemplaza el inline
+ * `require('./hooks/lib/briefing.js')` relativo al proyecto (roto downstream;
+ * ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses briefing
+ */
+
+const b = require('../../hooks/lib/briefing.js');
+
+function briefingCli() {
+  const items = b.recolectarTodo(process.cwd(), new Date());
+  for (const it of items) {
+    console.log('— [' + it.categoria + '] ' + it.titulo + ' → ' + it.accion);
+  }
+  if (items.length === 0) console.log('(sin señales baratas)');
+}
+
+module.exports = briefingCli;

package/scripts/cli/ciclo-evolucion.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses ciclo-evolucion` — regenera las métricas de evolución
+ * (.planning/evolution/metricas.json) ejecutando la sub-etapa Stop del ciclo.
+ * Reemplaza `echo '{}' | node hooks/ciclo-evolucion.js` relativo al proyecto
+ * (roto downstream; ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses ciclo-evolucion
+ */
+
+const cicloEvolucion = require('../../hooks/lib/ciclo-evolucion');
+
+function cicloEvolucionCli() {
+  try {
+    cicloEvolucion.ejecutarStop('{}');
+    console.log('[ciclo-evolucion] métricas de evolución regeneradas');
+  } catch (e) {
+    // A diferencia del hook (que nunca bloquea el harness), el CLI sí debe
+    // distinguir fallo de éxito para el caller: stderr + exit code != 0.
+    console.error('[ciclo-evolucion] no se pudo regenerar: ' + e.message);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = cicloEvolucionCli;

package/scripts/cli/configurar-ci.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses configurar-ci <op>` — gestiona los workflows CI/CD de SWL
+ * en el proyecto actual. Reemplaza los inline `require('./scripts/lib/configurar-ci')`
+ * relativos al proyecto (rotos downstream; ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Ops (todas imprimen el resultado como JSON para que el comando lo inspeccione):
+ *   init      [--no-security] [--no-ci] [--with-release-please] [--dry-run] [--force]
+ *   status    (default)
+ *   uninstall [--confirmar]
+ */
+
+const ci = require('../lib/configurar-ci');
+
+function configurarCi(opciones = {}) {
+  const op = (opciones._args && opciones._args[0]) || opciones.op || 'status';
+
+  if (op === 'init') {
+    const r = ci.init({
+      withSecurity: !opciones['no-security'],
+      withCi: !opciones['no-ci'],
+      withReleasePlease: !!opciones['with-release-please'],
+      dryRun: !!opciones['dry-run'],
+      force: !!opciones.force,
+    });
+    console.log(JSON.stringify(r, null, 2));
+    return;
+  }
+
+  if (op === 'uninstall') {
+    const r = ci.uninstall({ confirmar: !!opciones.confirmar });
+    console.log(JSON.stringify(r, null, 2));
+    return;
+  }
+
+  console.log(JSON.stringify(ci.status(), null, 2));
+}
+
+module.exports = configurarCi;

package/scripts/cli/derivar-feature-list.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses derivar-feature-list` — genera .planning/feature-list.json
+ * desde HOJA-RUTA.md. Reemplaza `node scripts/derivar-feature-list.js` relativo
+ * al proyecto (roto downstream; ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses derivar-feature-list [--check]   (--check: exit 2 si hay drift)
+ */
+
+const { main } = require('../derivar-feature-list.js');
+
+function derivarFeatureList(opciones = {}) {
+  const args = ['node', 'derivar-feature-list'];
+  if (opciones && opciones.check) args.push('--check');
+  const argvOriginal = process.argv;
+  process.argv = args;
+  try {
+    return main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = derivarFeatureList;

package/scripts/cli/detectar-host.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses detectar-host` — determina si el CWD es el repo host de
+ * SWL o un proyecto consumidor. Reemplaza `node scripts/lib/detectar-host-swl.js`
+ * relativo al proyecto (roto downstream; ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses detectar-host [--json]
+ */
+
+const { detectarHostSwl } = require('../lib/detectar-host-swl');
+
+function detectarHost(opciones = {}) {
+  const r = detectarHostSwl(process.cwd());
+  if (opciones && opciones.json) {
+    console.log(JSON.stringify(r, null, 2));
+    return;
+  }
+  if (r.esHost) {
+    console.log(`[host] ${r.razon}`);
+  } else {
+    console.log(`[consumidor] ${r.razon}`);
+    for (const s of r.sugerencias) console.log(`  - ${s}`);
+  }
+}
+
+module.exports = detectarHost;

package/scripts/cli/diary-entry.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses diary-entry` — construye y persiste una entrada de diario
+ * de sesión en .planning/sessions/diary/<id>.json. Reemplaza el inline
+ * `require('./scripts/lib/diary-entry')` relativo al proyecto (roto downstream;
+ * ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Entrada: objeto JSON por stdin (o --json='{...}') con la forma:
+ *   {
+ *     "sessionId": "...", "agent": "orquestador-swl",
+ *     "accomplishments": ["..."], "decisions": ["..."],
+ *     "learnings": ["..."], "challenges": ["..."],
+ *     "sourceAgents": ["implementador-swl"], "tags": ["..."]
+ *   }
+ *
+ * Imprime la ruta del archivo escrito. Uso:
+ *   echo '{"sessionId":"s1","agent":"orquestador-swl"}' | swl-ses diary-entry
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const diary = require('../lib/diary-entry');
+const { atomicWriteSync } = require('../../hooks/lib/atomic-write');
+
+function diaryEntry(opciones = {}) {
+  let raw = opciones.json;
+  if (!raw && !process.stdin.isTTY) {
+    try {
+      raw = fs.readFileSync(0, 'utf8');
+    } catch (e) {
+      // No degradar en silencio: avisar que stdin fue ilegible antes del fallback.
+      console.error('[diary-entry] aviso: stdin ilegible (' + e.code + ')');
+      raw = '';
+    }
+  }
+  let input;
+  try {
+    input = JSON.parse(raw || '{}');
+  } catch (e) {
+    console.error('Error: JSON inválido: ' + e.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  let entry = diary.createDiary({ sessionId: input.sessionId, agent: input.agent });
+  for (const a of input.accomplishments || []) entry = diary.addAccomplishment(entry, a);
+  for (const d of input.decisions || []) entry = diary.addDecision(entry, d);
+  for (const c of input.challenges || []) entry = diary.addChallenge(entry, c);
+  for (const l of input.learnings || []) entry = diary.addLearning(entry, l);
+  for (const tg of input.tags || []) entry = diary.addTag(entry, tg);
+  for (const sa of input.sourceAgents || []) entry = diary.addSourceAgent(entry, sa);
+  entry = diary.closeDiary(entry);
+
+  const val = diary.validateDiary(entry);
+  if (!val.valid) {
+    console.error('Error de validación: ' + val.errors.join('; '));
+    process.exitCode = 1;
+    return;
+  }
+
+  const dir = path.join(process.cwd(), '.planning', 'sessions', 'diary');
+  fs.mkdirSync(dir, { recursive: true });
+  const dest = path.join(dir, entry.id + '.json');
+  atomicWriteSync(dest, diary.serializeDiary(entry));
+  console.log(dest);
+}
+
+module.exports = diaryEntry;

package/scripts/cli/execution-state.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses execution-state` — imprime el resumen estructurado del
+ * estado de ejecución (.planning/execution-state.json). Reemplaza el inline
+ * `require('./hooks/lib/execution-state')` relativo al proyecto (roto downstream;
+ * ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses execution-state
+ */
+
+const es = require('../../hooks/lib/execution-state');
+
+function executionState() {
+  console.log(es.formatearResumen(process.cwd()));
+}
+
+module.exports = executionState;

package/scripts/cli/gateway-notify.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses gateway-notify` — encola una notificación de vuelta al
+ * canal origen del gateway (Telegram, Discord). Reemplaza el inline
+ * `require('./hooks/lib/gateway-notify')` relativo al proyecto (roto downstream;
+ * ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses gateway-notify --texto="✅ ..." [--tipo=custom] [--to=telegram]
+ *                             [--reply-to=<chatId>]
+ */
+
+const { notificarGateway } = require('../../hooks/lib/gateway-notify');
+
+function gatewayNotify(opciones = {}) {
+  if (!opciones.texto) {
+    console.error('Error: falta --texto="mensaje"');
+    process.exitCode = 1;
+    return;
+  }
+  // --reply-to debe ser un chatId numérico: evita redirigir la notificación a
+  // un chat arbitrario cuando el flag se sintetiza desde input no confiable.
+  if (opciones['reply-to'] !== undefined && !/^-?\d+$/.test(String(opciones['reply-to']))) {
+    console.error('Error: --reply-to debe ser un chatId numérico');
+    process.exitCode = 1;
+    return;
+  }
+  const params = { tipo: opciones.tipo || 'custom', texto: opciones.texto };
+  if (opciones.to) params.to = opciones.to;
+  if (opciones['reply-to'] !== undefined) params.payload = { replyTo: opciones['reply-to'] };
+
+  const r = notificarGateway(params);
+  if (r === false) {
+    console.log(JSON.stringify({ ok: false, motivo: 'gateway deshabilitado o tipo no habilitado' }, null, 2));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(JSON.stringify(r ?? { ok: true }, null, 2));
+}
+
+module.exports = gatewayNotify;

package/scripts/cli/liberar-fase.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses liberar-fase` — cierra el gate G0 borrando
+ * .planning/locks/fase-activa.json. Lo usa /swl:ejecutar-fase al terminar una
+ * fase para que spec-gate.js vuelva a advertir si se reanuda trabajo.
+ *
+ * Reemplaza el `node -e "...unlinkSync('.planning/locks/fase-activa.json')"`
+ * inline (relativo al proyecto). Busca el archivo ascendiendo desde el CWD para
+ * funcionar aunque el comando se ejecute desde un subdirectorio.
+ *
+ * Uso: swl-ses liberar-fase
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function liberarFase(opciones = {}) {
+  let dir = (opciones && opciones.cwd) || process.cwd();
+  let target = null;
+  while (dir !== path.dirname(dir)) {
+    const cand = path.join(dir, '.planning', 'locks', 'fase-activa.json');
+    if (fs.existsSync(cand)) {
+      target = cand;
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+
+  if (target) {
+    fs.unlinkSync(target);
+    console.log(JSON.stringify({ ok: true, liberado: target }));
+  } else {
+    console.log(
+      JSON.stringify({ ok: true, liberado: null, motivo: 'sin fase activa que liberar' })
+    );
+  }
+}
+
+module.exports = liberarFase;
+
+if (require.main === module) liberarFase();