@saulwade/swl-ses 2.3.0 → 2.4.1

package/hooks/registro-turnos.js

@@ -1,209 +1,210 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: registro-turnos.js
- * Tipo: PostToolUse (todas las herramientas)
- *
- * Persiste cada tool call (turno) en .planning/sessions/{session_id}/turns.jsonl
- * para auditoría granular y futuro replay/fork de sesiones.
- *
- * Patrón inspirado en `temp/claudian-main/src/core/bootstrap/SessionStorage.ts`
- * (plugin Obsidian Claudian, Yishen Tu, MIT). Diferencias respecto al
- * original:
- *   - Claudian persiste SessionMetadata + transcripts en JSONL del provider.
- *     SWL persiste turn-by-turn en formato propio compatible con
- *     .planning/sessions/.
- *   - Sanitización agresiva de entrada/salida antes de persistir
- *     (riesgo PII/secretos en argumentos de tools).
- *
- * Estado: OPT-IN. Inactivo por defecto. Activar con SWL_REGISTRO_TURNOS=1.
- *
- * Razones del default OFF:
- *   - Volumen alto: cada tool call genera entrada (decenas por sesión).
- *   - Riesgo PII: tool_input de Bash/Write/Edit puede contener tokens,
- *     contraseñas pegadas accidentalmente, paths privados.
- *   - El usuario debe decidir explícitamente activarlo en su entorno.
- *
- * Schema de cada turno (JSONL append-only):
- *   {
- *     ts: ISO timestamp,
- *     session_id: string,
- *     tool: string,
- *     input_resumen: string,         // preview ≤ 200 chars, secrets sanitizados
- *     output_resumen: string,        // preview ≤ 500 chars, secrets sanitizados
- *     duracion_ms?: number,
- *     agente?: string,               // si tool=Agent, subagent_type
- *     error?: boolean
- *   }
- *
- * NUNCA persiste:
- *   - tool_input completo (truncado a 200 chars)
- *   - tool_response completo (truncado a 500 chars)
- *   - Patrones que parezcan tokens/secretos (sanitizados a [REDACTED])
- *
- * Variables de entorno:
- *   SWL_REGISTRO_TURNOS=1     - activa el hook (default: OFF)
- *   SWL_REGISTRO_TURNOS_LIMITE - máximo turns por sesión (default: 1000)
- *
- * Helper de inspección:
- *   /swl:sesiones --turnos=<session_id>
- *
- * @see hooks/lib/atomic-write.js
- * @see hooks/lib/privacy-filter.js (si existe; fallback inline si no)
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const LIMITE_TURNOS = parseInt(process.env.SWL_REGISTRO_TURNOS_LIMITE || '1000', 10);
-const MAX_INPUT_CHARS = 200;
-const MAX_OUTPUT_CHARS = 500;
-const DIR_BASE = path.join(process.cwd(), '.planning', 'sessions');
-
-// Patrones de sanitización conservadores: tokens largos, llaves API, JWT,
-// password en URLs, paths con .env. Si aparece un match, se reemplaza con
-// [REDACTED].
-const PATRONES_REDACT = [
-  /\b[A-Za-z0-9_-]{32,}\b/g,                    // tokens largos
-  /(?:sk|pk|key|token|secret|password|pwd|api[_-]?key)["':\s=]+[A-Za-z0-9_\-./]{8,}/gi,
-  /\bey[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\b/g, // JWT
-  /https?:\/\/[^:]+:[^@\s]+@/g,                 // basic auth en URL
-  /-----BEGIN [A-Z ]+-----[\s\S]*?-----END [A-Z ]+-----/g, // PEM blocks
-];
-
-function sanitizar(texto) {
-  if (!texto) return '';
-  let r = String(texto);
-  for (const re of PATRONES_REDACT) {
-    r = r.replace(re, '[REDACTED]');
-  }
-  return r;
-}
-
-function truncar(texto, max) {
-  const s = sanitizar(texto);
-  if (s.length <= max) return s;
-  return s.slice(0, max - 3) + '...';
-}
-
-function ensureDir(dir) {
-  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
-}
-
-function contarTurnos(rutaArchivo) {
-  try {
-    if (!fs.existsSync(rutaArchivo)) return 0;
-    const contenido = fs.readFileSync(rutaArchivo, 'utf8');
-    return contenido.split(/\r?\n/).filter(Boolean).length;
-  } catch {
-    return 0;
-  }
-}
-
-function extraerInfoTurno(data) {
-  const toolName = String(data.tool_name || data.tool?.name || '');
-  if (!toolName) return null;
-
-  const sessionId = String(data.session_id || 'default').slice(0, 64);
-
-  const toolInput = data.tool_input || data.tool?.input || {};
-  const toolResponse = data.tool_response || data.tool_result || {};
-
-  // Resumen de input: serializar y truncar
-  let inputStr = '';
-  try {
-    inputStr = typeof toolInput === 'string'
-      ? toolInput
-      : JSON.stringify(toolInput);
-  } catch { inputStr = '[unserializable]'; }
-
-  // Resumen de output: extraer campos comunes
-  let outputStr = '';
-  try {
-    if (typeof toolResponse === 'string') {
-      outputStr = toolResponse;
-    } else if (toolResponse && typeof toolResponse === 'object') {
-      const campos = ['output', 'content', 'stdout', 'text', 'result', 'message', 'error'];
-      for (const c of campos) {
-        if (typeof toolResponse[c] === 'string') {
-          outputStr = toolResponse[c];
-          break;
-        }
-      }
-      if (!outputStr) outputStr = JSON.stringify(toolResponse);
-    }
-  } catch { outputStr = '[unserializable]'; }
-
-  const esError = !!(toolResponse && (toolResponse.is_error || toolResponse.status === 'failed'));
-
-  const turno = {
-    ts: new Date().toISOString(),
-    session_id: sessionId,
-    tool: toolName,
-    input_resumen: truncar(inputStr, MAX_INPUT_CHARS),
-    output_resumen: truncar(outputStr, MAX_OUTPUT_CHARS),
-  };
-
-  if (data.duration_ms || toolResponse.duration_ms) {
-    turno.duracion_ms = data.duration_ms || toolResponse.duration_ms;
-  }
-
-  if (toolName === 'Agent') {
-    const subType = toolInput.subagent_type || toolInput.type;
-    if (subType) turno.agente = String(subType).slice(0, 60);
-  }
-
-  if (esError) turno.error = true;
-
-  return turno;
-}
-
-// Solo registrar listeners de stdin en modo CLI. Cuando se importa como
-// módulo (tests), registrar listeners mantiene el event loop vivo
-// indefinidamente porque stdin nunca emite 'end' en ese contexto, lo que
-// hace que la suite de tests cuelgue hasta el timeout. El hook real
-// invocado por Claude Code siempre se ejecuta como require.main.
-//
-// El opt-in via SWL_REGISTRO_TURNOS también se evalúa aquí adentro: si
-// estuviera en el top-level del archivo, importar el módulo desde un
-// test sin la env var mataría al test runner via process.exit(0).
-if (require.main === module) {
-  if (process.env.SWL_REGISTRO_TURNOS !== '1') {
-    // OPT-IN: hook inactivo por default. Salir silencioso sin leer stdin.
-    process.exit(0);
-  }
-  let inputRaw = '';
-  process.stdin.on('data', chunk => { inputRaw += chunk; });
-
-  process.stdin.on('end', () => {
-    try {
-      const data = JSON.parse(inputRaw);
-      const turno = extraerInfoTurno(data);
-      if (!turno) return;
-
-      const dirSesion = path.join(DIR_BASE, turno.session_id);
-      ensureDir(dirSesion);
-      const rutaArchivo = path.join(dirSesion, 'turns.jsonl');
-
-      if (contarTurnos(rutaArchivo) >= LIMITE_TURNOS) {
-        // Hard cap: no seguir creciendo. El usuario decide rotar/limpiar.
-        return;
-      }
-
-      fs.appendFileSync(rutaArchivo, JSON.stringify(turno) + '\n', 'utf8');
-    } catch (err) {
-      // Hook nunca bloquea Claude Code, pero deja una traza diagnóstica
-      // para no perder regresiones silenciosas (ver feedback memoria
-      // sobre errores silenciados).
-      process.stderr.write(`[registro-turnos] error interno: ${String(err.message || err).slice(0, 120)}\n`);
-    }
-  });
-} else {
-  module.exports = {
-    extraerInfoTurno,
-    sanitizar,
-    truncar,
-    _internals: { PATRONES_REDACT, MAX_INPUT_CHARS, MAX_OUTPUT_CHARS, LIMITE_TURNOS },
-  };
-}
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: registro-turnos.js
+ * Tipo: PostToolUse (todas las herramientas)
+ *
+ * Persiste cada tool call (turno) en .planning/sessions/{session_id}/turns.jsonl
+ * para auditoría granular y futuro replay/fork de sesiones.
+ *
+ * Patrón inspirado en `temp/claudian-main/src/core/bootstrap/SessionStorage.ts`
+ * (plugin Obsidian Claudian, Yishen Tu, MIT). Diferencias respecto al
+ * original:
+ *   - Claudian persiste SessionMetadata + transcripts en JSONL del provider.
+ *     SWL persiste turn-by-turn en formato propio compatible con
+ *     .planning/sessions/.
+ *   - Sanitización agresiva de entrada/salida antes de persistir
+ *     (riesgo PII/secretos en argumentos de tools).
+ *
+ * Estado: OPT-IN. Inactivo por defecto. Activar con SWL_REGISTRO_TURNOS=1.
+ *
+ * Razones del default OFF:
+ *   - Volumen alto: cada tool call genera entrada (decenas por sesión).
+ *   - Riesgo PII: tool_input de Bash/Write/Edit puede contener tokens,
+ *     contraseñas pegadas accidentalmente, paths privados.
+ *   - El usuario debe decidir explícitamente activarlo en su entorno.
+ *
+ * Schema de cada turno (JSONL append-only):
+ *   {
+ *     ts: ISO timestamp,
+ *     session_id: string,
+ *     tool: string,
+ *     input_resumen: string,         // preview ≤ 200 chars, secrets sanitizados
+ *     output_resumen: string,        // preview ≤ 500 chars, secrets sanitizados
+ *     duracion_ms?: number,
+ *     agente?: string,               // si tool=Agent, subagent_type
+ *     error?: boolean
+ *   }
+ *
+ * NUNCA persiste:
+ *   - tool_input completo (truncado a 200 chars)
+ *   - tool_response completo (truncado a 500 chars)
+ *   - Patrones que parezcan tokens/secretos (sanitizados a [REDACTED])
+ *
+ * Variables de entorno:
+ *   SWL_REGISTRO_TURNOS=1     - activa el hook (default: OFF)
+ *   SWL_REGISTRO_TURNOS_LIMITE - máximo turns por sesión (default: 1000)
+ *
+ * Helper de inspección:
+ *   /swl:sesiones --turnos=<session_id>
+ *
+ * @see hooks/lib/atomic-write.js
+ * @see hooks/lib/privacy-filter.js (si existe; fallback inline si no)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const LIMITE_TURNOS = parseInt(process.env.SWL_REGISTRO_TURNOS_LIMITE || '1000', 10);
+const MAX_INPUT_CHARS = 200;
+const MAX_OUTPUT_CHARS = 500;
+const DIR_BASE = path.join(process.cwd(), '.planning', 'sessions');
+
+// Patrones de sanitización conservadores: tokens largos, llaves API, JWT,
+// password en URLs, paths con .env. Si aparece un match, se reemplaza con
+// [REDACTED].
+const PATRONES_REDACT = [
+  /\b[A-Za-z0-9_-]{32,}\b/g,                    // tokens largos
+  /(?:sk|pk|key|token|secret|password|pwd|api[_-]?key)["':\s=]+[A-Za-z0-9_\-./]{8,}/gi,
+  /\bey[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\b/g, // JWT
+  /https?:\/\/[^:]+:[^@\s]+@/g,                 // basic auth en URL
+  /-----BEGIN [A-Z ]+-----[\s\S]*?-----END [A-Z ]+-----/g, // PEM blocks
+];
+
+function sanitizar(texto) {
+  if (!texto) return '';
+  let r = String(texto);
+  for (const re of PATRONES_REDACT) {
+    r = r.replace(re, '[REDACTED]');
+  }
+  return r;
+}
+
+function truncar(texto, max) {
+  const s = sanitizar(texto);
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + '...';
+}
+
+function ensureDir(dir) {
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
+}
+
+function contarTurnos(rutaArchivo) {
+  try {
+    if (!fs.existsSync(rutaArchivo)) return 0;
+    const contenido = fs.readFileSync(rutaArchivo, 'utf8');
+    return contenido.split(/\r?\n/).filter(Boolean).length;
+  } catch {
+    return 0;
+  }
+}
+
+function extraerInfoTurno(data) {
+  const toolName = String(data.tool_name || data.tool?.name || '');
+  if (!toolName) return null;
+
+  const sessionId = String(data.session_id || 'default').slice(0, 64);
+
+  const toolInput = data.tool_input || data.tool?.input || {};
+  const toolResponse = data.tool_response || data.tool_result || {};
+
+  // Resumen de input: serializar y truncar
+  let inputStr = '';
+  try {
+    inputStr = typeof toolInput === 'string'
+      ? toolInput
+      : JSON.stringify(toolInput);
+  } catch { inputStr = '[unserializable]'; }
+
+  // Resumen de output: extraer campos comunes
+  let outputStr = '';
+  try {
+    if (typeof toolResponse === 'string') {
+      outputStr = toolResponse;
+    } else if (toolResponse && typeof toolResponse === 'object') {
+      const campos = ['output', 'content', 'stdout', 'text', 'result', 'message', 'error'];
+      for (const c of campos) {
+        if (typeof toolResponse[c] === 'string') {
+          outputStr = toolResponse[c];
+          break;
+        }
+      }
+      if (!outputStr) outputStr = JSON.stringify(toolResponse);
+    }
+  } catch { outputStr = '[unserializable]'; }
+
+  const esError = !!(toolResponse && (toolResponse.is_error || toolResponse.status === 'failed'));
+
+  const turno = {
+    ts: new Date().toISOString(),
+    session_id: sessionId,
+    tool: toolName,
+    input_resumen: truncar(inputStr, MAX_INPUT_CHARS),
+    output_resumen: truncar(outputStr, MAX_OUTPUT_CHARS),
+  };
+
+  if (data.duration_ms || toolResponse.duration_ms) {
+    turno.duracion_ms = data.duration_ms || toolResponse.duration_ms;
+  }
+
+  if (toolName === 'Agent') {
+    const subType = toolInput.subagent_type || toolInput.type;
+    if (subType) turno.agente = String(subType).slice(0, 60);
+  }
+
+  if (esError) turno.error = true;
+
+  return turno;
+}
+
+// Solo registrar listeners de stdin en modo entrypoint. Cuando se importa como
+// módulo (tests), registrar listeners mantiene el event loop vivo
+// indefinidamente porque stdin nunca emite 'end' en ese contexto, lo que
+// hace que la suite de tests cuelgue hasta el timeout. El hook real invocado
+// por Claude Code corre vía el wrapper `node -e "require(...)"` donde
+// require.main es undefined (NO como require.main del proceso).
+//
+// El opt-in via SWL_REGISTRO_TURNOS también se evalúa aquí adentro: si
+// estuviera en el top-level del archivo, importar el módulo desde un
+// test sin la env var mataría al test runner via process.exit(0).
+if (!require.main || require.main === module) {
+  if (process.env.SWL_REGISTRO_TURNOS !== '1') {
+    // OPT-IN: hook inactivo por default. Salir silencioso sin leer stdin.
+    process.exit(0);
+  }
+  let inputRaw = '';
+  process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(inputRaw);
+      const turno = extraerInfoTurno(data);
+      if (!turno) return;
+
+      const dirSesion = path.join(DIR_BASE, turno.session_id);
+      ensureDir(dirSesion);
+      const rutaArchivo = path.join(dirSesion, 'turns.jsonl');
+
+      if (contarTurnos(rutaArchivo) >= LIMITE_TURNOS) {
+        // Hard cap: no seguir creciendo. El usuario decide rotar/limpiar.
+        return;
+      }
+
+      fs.appendFileSync(rutaArchivo, JSON.stringify(turno) + '\n', 'utf8');
+    } catch (err) {
+      // Hook nunca bloquea Claude Code, pero deja una traza diagnóstica
+      // para no perder regresiones silenciosas (ver feedback memoria
+      // sobre errores silenciados).
+      process.stderr.write(`[registro-turnos] error interno: ${String(err.message || err).slice(0, 120)}\n`);
+    }
+  });
+} else {
+  module.exports = {
+    extraerInfoTurno,
+    sanitizar,
+    truncar,
+    _internals: { PATRONES_REDACT, MAX_INPUT_CHARS, MAX_OUTPUT_CHARS, LIMITE_TURNOS },
+  };
+}

package/hooks/session-briefing.js

@@ -1,98 +1,98 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: session-briefing.js
- * Tipo: SessionStart
- *
- * Briefing proactivo de inicio de sesión (Fase 12, ADR-0036). Al abrir sesión
- * en un proyecto con `.planning/`, presenta un digest no solicitado de señales
- * accionables que el usuario no sabía que tenía que preguntar: ADRs Propuestos
- * con reevaluación vencida, deuda con trigger por fecha cumplido, nudges sin
- * accionar, gates en calibración con ventana cumplida, y trabajo de retoma
- * pendiente. Silencio total cuando no hay señales nuevas.
- *
- * Solo lecturas de filesystem ya computado: cero LLM, cero red, presupuesto
- * <200ms (REQ-12-02). Las señales caras viven en `/swl:briefing`. SIEMPRE sale 0.
- *
- * Zero-deps. Opt-out: SWL_BRIEFING=0. Zero-config: sin `.planning/` → silencio.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Require con fallback dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`
-// en el destino, pero en el repo madre vive en `lib/`. Cubre ambos layouts (D-17).
-function requireDual(nombre) {
-  try {
-    return require(`./lib/${nombre}`);
-  } catch (e1) {
-    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
-    return require(`./${nombre}`);
-  }
-}
-
-let briefing;
-let atomicWriteJSON;
-try {
-  briefing = requireDual('briefing');
-} catch (_) {
-  briefing = null;
-}
-try {
-  ({ atomicWriteJSON } = requireDual('atomic-write'));
-} catch (_) {
-  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
-}
-
-let inputRaw = '';
-process.stdin.on('data', (c) => { inputRaw += c; });
-
-process.stdin.on('end', () => {
-  try {
-    if (process.env.SWL_BRIEFING === '0') return; // opt-out
-    if (!briefing) return;                          // lib ausente: degradar a silencio
-
-    const cwd = process.cwd();
-    if (!fs.existsSync(path.join(cwd, '.planning'))) return; // zero-config
-
-    const hoy = new Date();
-    const items = briefing.recolectarTodo(cwd, hoy);
-    const estadoPrevio = briefing.leerEstadoBriefing(cwd);
-    const dia = hoy.toISOString().slice(0, 10);
-
-    // Telemetría de aceptación (D-18, REQ-12-05): se actualiza SIEMPRE que el
-    // hook corre, comparando lo visto antes con lo presente ahora — independiente
-    // del dedupe de display. Alimenta a perfilador-usuario-swl para callar
-    // categorías que el usuario ignora consistentemente.
-    let silenciadas = new Set();
-    try {
-      const telePrev = briefing.leerTelemetria(cwd);
-      const teleNueva = briefing.actualizarTelemetria(telePrev, items, hoy.toISOString());
-      silenciadas = briefing.categoriasSilenciadas(teleNueva);
-      const dir = path.join(cwd, '.planning', 'user-profile');
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      atomicWriteJSON(path.join(dir, 'briefing-telemetria.json'), teleNueva);
-    } catch (_) { /* telemetría best-effort */ }
-
-    const digest = briefing.armarDigest(items, estadoPrevio, dia, {
-      categoriasSilenciadas: silenciadas,
-    });
-    if (!digest) return; // silencio total: sin señales nuevas
-
-    // Persistir el estado de dedupe (best-effort).
-    try {
-      const dir = path.join(cwd, '.planning', 'user-profile');
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      atomicWriteJSON(path.join(dir, 'briefing-estado.json'), digest.estado);
-    } catch (_) { /* persistir es best-effort; no romper el digest */ }
-
-    const output = {
-      hookSpecificOutput: {
-        hookEventName: 'SessionStart',
-        additionalContext: digest.texto,
-      },
-    };
-    process.stdout.write(JSON.stringify(output));
-  } catch (_) { /* silencioso: el hook nunca bloquea la sesión */ }
-});
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: session-briefing.js
+ * Tipo: SessionStart
+ *
+ * Briefing proactivo de inicio de sesión (Fase 12, ADR-0036). Al abrir sesión
+ * en un proyecto con `.planning/`, presenta un digest no solicitado de señales
+ * accionables que el usuario no sabía que tenía que preguntar: ADRs Propuestos
+ * con reevaluación vencida, deuda con trigger por fecha cumplido, nudges sin
+ * accionar, gates en calibración con ventana cumplida, y trabajo de retoma
+ * pendiente. Silencio total cuando no hay señales nuevas.
+ *
+ * Solo lecturas de filesystem ya computado: cero LLM, cero red, presupuesto
+ * <200ms (REQ-12-02). Las señales caras viven en `/swl:briefing`. SIEMPRE sale 0.
+ *
+ * Zero-deps. Opt-out: SWL_BRIEFING=0. Zero-config: sin `.planning/` → silencio.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Require con fallback dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`
+// en el destino, pero en el repo madre vive en `lib/`. Cubre ambos layouts (D-17).
+function requireDual(nombre) {
+  try {
+    return require(`./lib/${nombre}`);
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    return require(`./${nombre}`);
+  }
+}
+
+let briefing;
+let atomicWriteJSON;
+try {
+  briefing = requireDual('briefing');
+} catch (_) {
+  briefing = null;
+}
+try {
+  ({ atomicWriteJSON } = requireDual('atomic-write'));
+} catch (_) {
+  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
+}
+
+let inputRaw = '';
+process.stdin.on('data', (c) => { inputRaw += c; });
+
+process.stdin.on('end', () => {
+  try {
+    if (process.env.SWL_BRIEFING === '0') return; // opt-out
+    if (!briefing) return;                          // lib ausente: degradar a silencio
+
+    const cwd = process.cwd();
+    if (!fs.existsSync(path.join(cwd, '.planning'))) return; // zero-config
+
+    const hoy = new Date();
+    const items = briefing.recolectarTodo(cwd, hoy);
+    const estadoPrevio = briefing.leerEstadoBriefing(cwd);
+    const dia = hoy.toISOString().slice(0, 10);
+
+    // Telemetría de aceptación (D-18, REQ-12-05): se actualiza SIEMPRE que el
+    // hook corre, comparando lo visto antes con lo presente ahora — independiente
+    // del dedupe de display. Alimenta a perfilador-usuario-swl para callar
+    // categorías que el usuario ignora consistentemente.
+    let silenciadas = new Set();
+    try {
+      const telePrev = briefing.leerTelemetria(cwd);
+      const teleNueva = briefing.actualizarTelemetria(telePrev, items, hoy.toISOString());
+      silenciadas = briefing.categoriasSilenciadas(teleNueva);
+      const dir = path.join(cwd, '.planning', 'user-profile');
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      atomicWriteJSON(path.join(dir, 'briefing-telemetria.json'), teleNueva);
+    } catch (_) { /* telemetría best-effort */ }
+
+    const digest = briefing.armarDigest(items, estadoPrevio, dia, {
+      categoriasSilenciadas: silenciadas,
+    });
+    if (!digest) return; // silencio total: sin señales nuevas
+
+    // Persistir el estado de dedupe (best-effort).
+    try {
+      const dir = path.join(cwd, '.planning', 'user-profile');
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      atomicWriteJSON(path.join(dir, 'briefing-estado.json'), digest.estado);
+    } catch (_) { /* persistir es best-effort; no romper el digest */ }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: digest.texto,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+  } catch (_) { /* silencioso: el hook nunca bloquea la sesión */ }
+});