@saulwade/swl-ses 2.5.3 → 2.6.1

package/scripts/canario-hooks.js

@@ -1,166 +1,166 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * canario-hooks.js — Canario de hooks: prueba que cada hook es viable y visible.
- *
- * Clase que cierra: "hook que funciona perfecto y nadie ve". Dos muertes
- * silenciosas documentadas: (a) check-update requería libs de scripts/lib/ no
- * distribuidas — MODULE_NOT_FOUND tragado por el wrapper en TODA instalación
- * destino desde su creación; (b) avisos emitidos por stderr con exit 0 (canal
- * invisible). La (b) la cubre auditar-clases-conocidas C3; este canario cubre
- * la (a) y la ejecución real.
- *
- * Modo default (rápido — test:all):
- *   Por cada hook ejecutable de hooks/*.js, extrae su grafo de requires
- *   relativos (transitivo) y verifica que todo archivo que EXISTE en el repo
- *   esté registrado en manifiestos/modulos.json — si no, el instalador no lo
- *   distribuye y el hook muere en silencio en el destino. Paths de fallback
- *   que no existen en el repo (patrón de require tolerante) se omiten.
- *
- * Modo --smoke (test:release):
- *   Además EJECUTA cada hook en un sandbox temporal (cwd aislado — las
- *   escrituras de telemetría van al sandbox) con un evento JSON mínimo por
- *   stdin. FALLA si el hook crashea (exit ≠ 0 y ≠ 2). Timeout (5s) es WARN
- *   informativo, no fallo: un hook lento no rompe la sesión (el harness lo
- *   corta), pero un hook que crashea al cargar es la clase (a) viva.
- *   Reporta tabla de visibilidad (bytes stdout/stderr) para auditoría humana.
- *
- * Exit: 0 limpio · 1 con fallas.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const RAIZ = path.resolve(__dirname, '..');
-const SMOKE = process.argv.includes('--smoke');
-const RX_REQUIRE = /require\(\s*['"](\.[^'"]+)['"]\s*\)/g;
-
-function hooksEjecutables() {
-  // Forward slashes SIEMPRE: se comparan contra modulos.json (formato repo).
-  return fs.readdirSync(path.join(RAIZ, 'hooks'))
-    .filter(f => f.endsWith('.js'))
-    .map(f => `hooks/${f}`);
-}
-
-function archivosRegistrados() {
-  const m = JSON.parse(fs.readFileSync(path.join(RAIZ, 'manifiestos', 'modulos.json'), 'utf8'));
-  const set = new Set();
-  for (const mod of Object.values(m.modulos || {})) {
-    for (const a of mod.archivos || []) set.add(a.replace(/\\/g, '/'));
-  }
-  return set;
-}
-
-/** Resuelve un require relativo a .js real (agrega .js / index.js). */
-function resolverRequire(desdeArchivo, spec) {
-  const base = path.resolve(RAIZ, path.dirname(desdeArchivo), spec);
-  for (const cand of [base, `${base}.js`, path.join(base, 'index.js'), `${base}.json`]) {
-    if (fs.existsSync(cand) && fs.statSync(cand).isFile()) {
-      return path.relative(RAIZ, cand).replace(/\\/g, '/');
-    }
-  }
-  return null; // fallback de require tolerante que solo existe en el destino
-}
-
-/** Grafo transitivo de requires relativos que existen en el repo. */
-function grafoRequires(archivoInicial) {
-  const vistos = new Set();
-  const pila = [archivoInicial];
-  while (pila.length > 0) {
-    const actual = pila.pop();
-    if (vistos.has(actual)) continue;
-    vistos.add(actual);
-    let contenido;
-    try { contenido = fs.readFileSync(path.join(RAIZ, actual), 'utf8'); } catch { continue; }
-    for (const m of contenido.matchAll(RX_REQUIRE)) {
-      const resuelto = resolverRequire(actual, m[1]);
-      if (resuelto && !vistos.has(resuelto)) pila.push(resuelto);
-    }
-  }
-  vistos.delete(archivoInicial);
-  return [...vistos];
-}
-
-function verificarDistribucion(hooks, registrados, fallas) {
-  for (const hook of hooks) {
-    if (!registrados.has(hook)) {
-      fallas.push(`${hook} — el hook mismo no está registrado en modulos.json (no se distribuye)`);
-    }
-    for (const dep of grafoRequires(hook)) {
-      if (dep.endsWith('.json')) continue; // datos empaquetados aparte
-      if (!registrados.has(dep)) {
-        fallas.push(`${hook} — requiere ${dep}, que existe en el repo pero NO está en modulos.json: en el destino el require lanza MODULE_NOT_FOUND y el wrapper lo traga (clase check-update)`);
-      }
-    }
-  }
-}
-
-const EVENTO_MINIMO = JSON.stringify({
-  session_id: 'canario-smoke',
-  hook_event_name: 'PostToolUse',
-  tool_name: 'Write',
-  tool_input: { file_path: 'canario.md', content: 'canario' },
-  tool_response: { success: true },
-});
-
-function smokeEjecutar(hooks, fallas) {
-  const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-canario-'));
-  const tabla = [];
-  try {
-    for (const hook of hooks) {
-      const r = spawnSync(process.execPath, [path.join(RAIZ, hook)], {
-        cwd: sandbox,
-        input: EVENTO_MINIMO,
-        encoding: 'utf8',
-        timeout: 5000,
-        env: { ...process.env, SWL_CANARIO_SMOKE: '1' },
-      });
-      const nombre = path.basename(hook);
-      if (r.error && r.error.code === 'ETIMEDOUT') {
-        tabla.push(`  [WARN timeout] ${nombre} — >5s con evento mínimo (no rompe la sesión, pero revisar)`);
-        continue;
-      }
-      const exit = r.status;
-      if (exit !== 0 && exit !== 2) {
-        const stderr = (r.stderr || '').split(/\r?\n/).find(l => l.trim()) || 'sin stderr';
-        fallas.push(`${hook} — crasheó con exit ${exit} ante evento mínimo: ${stderr.slice(0, 140)}`);
-        continue;
-      }
-      const out = (r.stdout || '').length;
-      const err = (r.stderr || '').length;
-      tabla.push(`  [ok exit ${exit}] ${nombre} — stdout:${out}B stderr:${err}B${exit === 0 && out === 0 && err > 0 ? '  ← solo stderr con exit 0: si esto es un aviso al usuario, es invisible (C3-runtime)' : ''}`);
-    }
-  } finally {
-    try { fs.rmSync(sandbox, { recursive: true, force: true }); } catch { /* mejor esfuerzo */ }
-  }
-  return tabla;
-}
-
-function main() {
-  const hooks = hooksEjecutables();
-  const registrados = archivosRegistrados();
-  const fallas = [];
-
-  verificarDistribucion(hooks, registrados, fallas);
-
-  let tabla = [];
-  if (SMOKE) tabla = smokeEjecutar(hooks, fallas);
-
-  if (tabla.length > 0) {
-    console.log('[canario-hooks] Visibilidad por hook (smoke en sandbox):');
-    for (const l of tabla) console.log(l);
-  }
-  if (fallas.length === 0) {
-    console.log(`[canario-hooks] OK — ${hooks.length} hooks: grafo de requires distribuido completo${SMOKE ? ' + smoke sin crashes' : ''}`);
-    return;
-  }
-  console.error(`[canario-hooks] ${fallas.length} falla(s):`);
-  for (const f of fallas) console.error('  - ' + f);
-  process.exitCode = 1;
-}
-
-module.exports = { grafoRequires, resolverRequire };
-if (require.main === module) main();
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * canario-hooks.js — Canario de hooks: prueba que cada hook es viable y visible.
+ *
+ * Clase que cierra: "hook que funciona perfecto y nadie ve". Dos muertes
+ * silenciosas documentadas: (a) check-update requería libs de scripts/lib/ no
+ * distribuidas — MODULE_NOT_FOUND tragado por el wrapper en TODA instalación
+ * destino desde su creación; (b) avisos emitidos por stderr con exit 0 (canal
+ * invisible). La (b) la cubre auditar-clases-conocidas C3; este canario cubre
+ * la (a) y la ejecución real.
+ *
+ * Modo default (rápido — test:all):
+ *   Por cada hook ejecutable de hooks/*.js, extrae su grafo de requires
+ *   relativos (transitivo) y verifica que todo archivo que EXISTE en el repo
+ *   esté registrado en manifiestos/modulos.json — si no, el instalador no lo
+ *   distribuye y el hook muere en silencio en el destino. Paths de fallback
+ *   que no existen en el repo (patrón de require tolerante) se omiten.
+ *
+ * Modo --smoke (test:release):
+ *   Además EJECUTA cada hook en un sandbox temporal (cwd aislado — las
+ *   escrituras de telemetría van al sandbox) con un evento JSON mínimo por
+ *   stdin. FALLA si el hook crashea (exit ≠ 0 y ≠ 2). Timeout (5s) es WARN
+ *   informativo, no fallo: un hook lento no rompe la sesión (el harness lo
+ *   corta), pero un hook que crashea al cargar es la clase (a) viva.
+ *   Reporta tabla de visibilidad (bytes stdout/stderr) para auditoría humana.
+ *
+ * Exit: 0 limpio · 1 con fallas.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const RAIZ = path.resolve(__dirname, '..');
+const SMOKE = process.argv.includes('--smoke');
+const RX_REQUIRE = /require\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+
+function hooksEjecutables() {
+  // Forward slashes SIEMPRE: se comparan contra modulos.json (formato repo).
+  return fs.readdirSync(path.join(RAIZ, 'hooks'))
+    .filter(f => f.endsWith('.js'))
+    .map(f => `hooks/${f}`);
+}
+
+function archivosRegistrados() {
+  const m = JSON.parse(fs.readFileSync(path.join(RAIZ, 'manifiestos', 'modulos.json'), 'utf8'));
+  const set = new Set();
+  for (const mod of Object.values(m.modulos || {})) {
+    for (const a of mod.archivos || []) set.add(a.replace(/\\/g, '/'));
+  }
+  return set;
+}
+
+/** Resuelve un require relativo a .js real (agrega .js / index.js). */
+function resolverRequire(desdeArchivo, spec) {
+  const base = path.resolve(RAIZ, path.dirname(desdeArchivo), spec);
+  for (const cand of [base, `${base}.js`, path.join(base, 'index.js'), `${base}.json`]) {
+    if (fs.existsSync(cand) && fs.statSync(cand).isFile()) {
+      return path.relative(RAIZ, cand).replace(/\\/g, '/');
+    }
+  }
+  return null; // fallback de require tolerante que solo existe en el destino
+}
+
+/** Grafo transitivo de requires relativos que existen en el repo. */
+function grafoRequires(archivoInicial) {
+  const vistos = new Set();
+  const pila = [archivoInicial];
+  while (pila.length > 0) {
+    const actual = pila.pop();
+    if (vistos.has(actual)) continue;
+    vistos.add(actual);
+    let contenido;
+    try { contenido = fs.readFileSync(path.join(RAIZ, actual), 'utf8'); } catch { continue; }
+    for (const m of contenido.matchAll(RX_REQUIRE)) {
+      const resuelto = resolverRequire(actual, m[1]);
+      if (resuelto && !vistos.has(resuelto)) pila.push(resuelto);
+    }
+  }
+  vistos.delete(archivoInicial);
+  return [...vistos];
+}
+
+function verificarDistribucion(hooks, registrados, fallas) {
+  for (const hook of hooks) {
+    if (!registrados.has(hook)) {
+      fallas.push(`${hook} — el hook mismo no está registrado en modulos.json (no se distribuye)`);
+    }
+    for (const dep of grafoRequires(hook)) {
+      if (dep.endsWith('.json')) continue; // datos empaquetados aparte
+      if (!registrados.has(dep)) {
+        fallas.push(`${hook} — requiere ${dep}, que existe en el repo pero NO está en modulos.json: en el destino el require lanza MODULE_NOT_FOUND y el wrapper lo traga (clase check-update)`);
+      }
+    }
+  }
+}
+
+const EVENTO_MINIMO = JSON.stringify({
+  session_id: 'canario-smoke',
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Write',
+  tool_input: { file_path: 'canario.md', content: 'canario' },
+  tool_response: { success: true },
+});
+
+function smokeEjecutar(hooks, fallas) {
+  const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-canario-'));
+  const tabla = [];
+  try {
+    for (const hook of hooks) {
+      const r = spawnSync(process.execPath, [path.join(RAIZ, hook)], {
+        cwd: sandbox,
+        input: EVENTO_MINIMO,
+        encoding: 'utf8',
+        timeout: 5000,
+        env: { ...process.env, SWL_CANARIO_SMOKE: '1' },
+      });
+      const nombre = path.basename(hook);
+      if (r.error && r.error.code === 'ETIMEDOUT') {
+        tabla.push(`  [WARN timeout] ${nombre} — >5s con evento mínimo (no rompe la sesión, pero revisar)`);
+        continue;
+      }
+      const exit = r.status;
+      if (exit !== 0 && exit !== 2) {
+        const stderr = (r.stderr || '').split(/\r?\n/).find(l => l.trim()) || 'sin stderr';
+        fallas.push(`${hook} — crasheó con exit ${exit} ante evento mínimo: ${stderr.slice(0, 140)}`);
+        continue;
+      }
+      const out = (r.stdout || '').length;
+      const err = (r.stderr || '').length;
+      tabla.push(`  [ok exit ${exit}] ${nombre} — stdout:${out}B stderr:${err}B${exit === 0 && out === 0 && err > 0 ? '  ← solo stderr con exit 0: si esto es un aviso al usuario, es invisible (C3-runtime)' : ''}`);
+    }
+  } finally {
+    try { fs.rmSync(sandbox, { recursive: true, force: true }); } catch { /* mejor esfuerzo */ }
+  }
+  return tabla;
+}
+
+function main() {
+  const hooks = hooksEjecutables();
+  const registrados = archivosRegistrados();
+  const fallas = [];
+
+  verificarDistribucion(hooks, registrados, fallas);
+
+  let tabla = [];
+  if (SMOKE) tabla = smokeEjecutar(hooks, fallas);
+
+  if (tabla.length > 0) {
+    console.log('[canario-hooks] Visibilidad por hook (smoke en sandbox):');
+    for (const l of tabla) console.log(l);
+  }
+  if (fallas.length === 0) {
+    console.log(`[canario-hooks] OK — ${hooks.length} hooks: grafo de requires distribuido completo${SMOKE ? ' + smoke sin crashes' : ''}`);
+    return;
+  }
+  console.error(`[canario-hooks] ${fallas.length} falla(s):`);
+  for (const f of fallas) console.error('  - ' + f);
+  process.exitCode = 1;
+}
+
+module.exports = { grafoRequires, resolverRequire };
+if (require.main === module) main();

package/scripts/cli/autonomia.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses autonomia` — registro de auto-checkpoints según el
+ * dial de autonomía (instintos/autonomia.yaml). Reemplaza el
+ * `node hooks/lib/autonomia.js --accion "..."` relativo al proyecto que
+ * ejecutar-fase instruía — roto downstream (ver
+ * docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses autonomia --accion="<descripción de la acción>"
+ */
+
+const { main } = require('../../hooks/lib/autonomia');
+
+function autonomia(opciones = {}) {
+  const argv = ['node', 'autonomia.js'];
+  if (opciones.accion != null && opciones.accion !== true) {
+    argv.push('--accion', String(opciones.accion));
+  }
+  process.exitCode = main(argv);
+}
+
+module.exports = autonomia;

package/scripts/cli/benchmark-memoria.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses benchmark-memoria` — benchmark de retrieval de la
+ * memoria del proyecto (scripts/benchmark-memoria.js). Reemplaza el
+ * `node scripts/benchmark-memoria.js` relativo al proyecto que
+ * benchmark-memoria (skill) instruía — roto downstream (ver
+ * docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses benchmark-memoria [--dataset=ruta] [--limit=N] [--json] [--verbose]
+ * (SWL_BENCHMARK_PERSIST=1 en el entorno para tracking histórico.)
+ *
+ * ADVERTENCIA (nemesis iter-1 S3-6): el main() envuelto llama process.exit()
+ * en todas sus ramas — este wrapper TERMINA el proceso host. Correcto vía
+ * `bin/swl-ses.js` (proceso fresco por invocación); NO invocar in-process.
+ */
+
+const { main } = require('../benchmark-memoria.js');
+
+function benchmarkMemoria(opciones = {}) {
+  // parseArgs del script espera flags de dos tokens (--dataset <ruta>).
+  const args = [];
+  if (opciones.dataset != null && opciones.dataset !== true) args.push('--dataset', String(opciones.dataset));
+  if (opciones.limit != null && opciones.limit !== true) args.push('--limit', String(opciones.limit));
+  if (opciones.json) args.push('--json');
+  if (opciones.verbose) args.push('--verbose');
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'benchmark-memoria.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = benchmarkMemoria;

package/scripts/cli/ciclo-autonomo.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses ciclo-autonomo [on|off|status]` — motor determinista de
+ * aprendizaje (Fase A del ciclo autónomo, ADR-0041).
+ *
+ * Sin positional: ejecuta la Fase A (writer de instintos → puente de
+ * degradación → drenador de feedback). Opt-out estricto (nace encendido):
+ * con `habilitado:false` en el config o `SWL_CICLO_AUTONOMO=0` retorna sin
+ * efecto ni escritura — el off es sagrado.
+ *
+ *   on     → habilita el motor (escribe evolution/ciclo-config.json)
+ *   off    → lo deshabilita
+ *   status → reporta last_run y conteos de la última corrida
+ *
+ * Uso: swl-ses ciclo-autonomo [on|off|status] [--forzar]
+ */
+
+const { correrFaseA } = require('../lib/ciclo-autonomo');
+const { leerConfig, escribirConfig, estaHabilitado } = require('../lib/ciclo-autonomo/config');
+
+function cicloAutonomo(opciones = {}) {
+  const accion = (opciones._args || [])[0];
+  const baseDir = opciones.dir || process.cwd();
+
+  if (accion === 'on' || accion === 'off') {
+    const habilitado = accion === 'on';
+    escribirConfig(baseDir, { habilitado });
+    console.log(`[ciclo-autonomo] motor ${habilitado ? 'HABILITADO' : 'deshabilitado'} (${baseDir})`);
+    if (habilitado) {
+      console.log('[ciclo-autonomo] la Fase A correrá vía cron/briefing; corrida manual: swl-ses ciclo-autonomo');
+    }
+    return leerConfig(baseDir);
+  }
+
+  if (accion === 'status') {
+    const config = leerConfig(baseDir);
+    const estado = {
+      habilitado: estaHabilitado(baseDir),
+      credencial: config.credencial,
+      last_run: config.last_run,
+      ultima_corrida: config.ultima_corrida,
+    };
+    console.log(`[ciclo-autonomo] habilitado: ${estado.habilitado} · credencial: ${estado.credencial}`);
+    console.log(`[ciclo-autonomo] last_run: ${estado.last_run || 'nunca'}`);
+    if (estado.ultima_corrida) {
+      const u = estado.ultima_corrida;
+      console.log(`[ciclo-autonomo] última corrida — promovidos: ${u.promovidos}, degradados: ${u.degradados}, drenados: ${u.drenados}, archivados: ${u.archivados}, bajados: ${u.bajados}`);
+    }
+    return estado;
+  }
+
+  if (accion !== undefined) {
+    console.error(`[ciclo-autonomo] acción desconocida: "${accion}". Uso: swl-ses ciclo-autonomo [on|off|status] [--forzar]`);
+    process.exitCode = 1;
+    return null;
+  }
+
+  const resultado = correrFaseA(baseDir, { forzar: opciones.forzar === true });
+  if (!resultado.ejecutado) {
+    console.log(`[ciclo-autonomo] sin corrida: ${resultado.razon}`);
+  } else if (resultado.acciones === 0) {
+    console.log('[ciclo-autonomo] corrida no-op: sin señales que crucen umbral');
+  } else {
+    console.log(`[ciclo-autonomo] corrida completada — acciones: ${resultado.acciones}`);
+    if (resultado.errores && resultado.errores.length > 0) {
+      console.error(`[ciclo-autonomo] sub-fases con error: ${resultado.errores.join(', ')}`);
+    }
+  }
+  return resultado;
+}
+
+module.exports = cicloAutonomo;

package/scripts/cli/ciclo-fase-b.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses ciclo-fase-b [status] [--dry-run]` — CLI headless de la
+ * Fase B del ciclo autónomo (Fase 22, T-07, ADR-0042 gate G-B, REQ-22-07).
+ *
+ * Espeja el patrón de `scripts/cli/ciclo-autonomo.js` (contrato del bin: cada
+ * subcomando exporta UNA función(opciones) sin efectos al require).
+ *
+ *   (nada) | --dry-run → corre `runner-fase-b.correrFaseB` con `dryRun:true`
+ *     SIEMPRE, se pase o no el flag. En Fase 22 el runner NUNCA invoca LLM ni
+ *     gasta bajo ninguna combinación de argumentos — el modo real
+ *     (`dryRun:false` + `invocador` cableado) llega en Fase 24; hasta
+ *     entonces `--dry-run` es un no-op explícito frente al default.
+ *   status → reporta `fase_b_habilitada`, `last_run_fase_b`, candidatos
+ *     pendientes (conteo tolerante de `evolution/candidatos-fase-b.jsonl` —
+ *     NUNCA `candidatos.detectar`, que tiene efecto de escritura; `status`
+ *     jamás muta disco) y el estado de presupuesto (`gasto_mes`,
+ *     `presupuesto_usd_mes`, `pausado_por_presupuesto`) vía
+ *     `presupuesto.estado`.
+ *
+ * Uso: swl-ses ciclo-fase-b [status] [--dry-run]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { correrFaseB } = require('../lib/ciclo-autonomo/runner-fase-b');
+const config = require('../lib/ciclo-autonomo/config');
+const presupuesto = require('../lib/ciclo-autonomo/presupuesto');
+
+const RUTA_CANDIDATOS_RELATIVA = path.join('.planning', 'evolution', 'candidatos-fase-b.jsonl');
+
+/**
+ * Conteo tolerante de líneas JSON válidas en `candidatos-fase-b.jsonl`.
+ * `status` es de solo lectura: nunca invoca `candidatos.detectar` (que
+ * persiste candidatos nuevos) — solo cuenta lo que YA quedó registrado por
+ * una corrida previa de la Fase A o del runner.
+ *
+ * @param {string} baseDir - Directorio raíz del proyecto.
+ * @returns {number}
+ */
+function contarCandidatosPendientes(baseDir) {
+  let crudo;
+  try {
+    crudo = fs.readFileSync(path.join(baseDir, RUTA_CANDIDATOS_RELATIVA), 'utf8');
+  } catch (_) {
+    return 0;
+  }
+  return crudo.split(/\r\n|\n/)
+    .filter((linea) => linea.trim() !== '')
+    .filter((linea) => {
+      try {
+        JSON.parse(linea);
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }).length;
+}
+
+function cicloFaseB(opciones = {}) {
+  const accion = (opciones._args || [])[0];
+  const baseDir = opciones.dir || process.cwd();
+
+  if (accion === 'status') {
+    const cfg = config.leerConfig(baseDir);
+    const presu = presupuesto.estado(baseDir);
+    const estado = {
+      fase_b_habilitada: config.estaFaseBHabilitada(baseDir),
+      last_run_fase_b: cfg.last_run_fase_b,
+      candidatos_pendientes: contarCandidatosPendientes(baseDir),
+      gasto_mes: presu.gasto_mes,
+      presupuesto_usd_mes: presu.tope,
+      pausado_por_presupuesto: presu.pausado_por_presupuesto,
+    };
+    console.log(`[ciclo-fase-b] fase_b_habilitada: ${estado.fase_b_habilitada}`);
+    console.log(`[ciclo-fase-b] last_run_fase_b: ${estado.last_run_fase_b || 'nunca'}`);
+    console.log(`[ciclo-fase-b] candidatos_pendientes: ${estado.candidatos_pendientes}`);
+    console.log(`[ciclo-fase-b] gasto_mes: $${estado.gasto_mes} / $${estado.presupuesto_usd_mes} · pausado_por_presupuesto: ${estado.pausado_por_presupuesto}`);
+    return estado;
+  }
+
+  if (accion !== undefined && accion !== '--dry-run') {
+    console.error(`[ciclo-fase-b] acción desconocida: "${accion}". Uso: swl-ses ciclo-fase-b [status] [--dry-run]`);
+    process.exitCode = 1;
+    return null;
+  }
+
+  // Fase 22: dryRun forzado a true sin importar el flag — el runner valida
+  // toda la tubería (lock, catch-up, guard, credencial, presupuesto) y
+  // registra la corrida SIN invocar LLM. El modo real llega en Fase 24.
+  const resultado = correrFaseB(baseDir, { dryRun: true });
+  if (!resultado.ejecutado) {
+    console.log(`[ciclo-fase-b] sin corrida: ${resultado.razon}`);
+  } else {
+    console.log(`[ciclo-fase-b] corrida dry-run completada — candidatos: ${resultado.candidatos}`);
+  }
+  return resultado;
+}
+
+module.exports = cicloFaseB;

package/scripts/cli/guardrail-metrics.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses guardrail-metrics` — métricas y diagnóstico de los
+ * guardrails de la sesión (bridge en tmpdir por sessionId). Reemplaza el
+ * `node -e "require('./hooks/lib/guardrail-metrics')..."` relativo al
+ * proyecto que swl-dashboard instruía — roto downstream (ver
+ * docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses guardrail-metrics [--session=ID] [--json]
+ *   --session  default: env CLAUDE_SESSION_ID o "default"
+ *   --json     imprime {metricas, advertencias} crudo
+ */
+
+const { getMetrics, formatearResumen, diagnosticar } = require('../../hooks/lib/guardrail-metrics');
+
+function guardrailMetrics(opciones = {}) {
+  const sessionId = (opciones.session != null && opciones.session !== true)
+    ? String(opciones.session)
+    : (process.env.CLAUDE_SESSION_ID || 'default');
+
+  const metricas = getMetrics(sessionId);
+  const advertencias = diagnosticar(metricas);
+
+  if (opciones.json) {
+    console.log(JSON.stringify({ metricas, advertencias }, null, 2));
+    return;
+  }
+
+  console.log(formatearResumen(metricas));
+  if (advertencias.length > 0) {
+    console.log('\n⚠ Diagnóstico:');
+    for (const a of advertencias) console.log('  - ' + a);
+  } else {
+    console.log('\n✓ Guardrails sin anomalías detectadas.');
+  }
+}
+
+module.exports = guardrailMetrics;

package/scripts/cli/loop-telemetry.js

@@ -16,6 +16,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const lt = require('../../hooks/lib/loop-telemetry');
+const { raizProyecto } = require('../../hooks/lib/raiz-proyecto');
 
 // Parseo no degradante: si el flag está presente pero su JSON es inválido,
 // reporta y devuelve {ok:false} en vez de silenciar a fallback (anti-fallback
@@ -89,8 +90,9 @@ function loopTelemetry(opciones = {}) {
     return;
   }
 
-  // listar (default)
-  const base = path.join(process.cwd(), lt.DIR_LOOPS);
+  // listar (default) — misma ancla que iniciar/registrar (raíz del proyecto),
+  // o listaría un .planning/loops/ distinto al que las corridas escriben.
+  const base = path.join(raizProyecto(process.cwd()), lt.DIR_LOOPS);
   let dirs = [];
   try {
     dirs = fs