Founding Member: $499/mes de por vida
Micare
Encontrar mi rumbo
Productividad

Pulso de agenda al arrancar

Un hook que, al arrancar una sesión con tu asistente, le inyecta un recordatorio terco: leer la agenda de HOY vía tu MCP de calendario y, si viene vacía y traes pendientes, proponerte poblarla con bloques concretos. No repite el pulso en un resume caliente ni falla callado.

HookPremiumProductividadsesiones y foco

🌱 Empieza aquí · Pulso de agenda al arrancar

¿Te ha pasado que abres el día, te clavas en lo primero que cae, y a media tarde te acuerdas de que ni siquiera miraste tu calendario? Esta semilla le pone a tu asistente un reflejo: cada vez que arrancas una sesión, primero se asoma a tu agenda de hoy. Si ve el día vacío o con huecos y tú traes pendientes importantes sin agendar, en vez de decir "tu agenda está libre" y quedarse callado, te propone cómo llenarla con bloques concretos y horarios realistas. Un empujón para que planear el día deje de ser opcional.

Para instalarla

Abre esta carpeta con Claude Code o Cowork y dile a tu asistente:

"Siembra esta semilla 🌱"

Con eso basta de tu parte. Tu asistente hace todo lo técnico y al final te dice cómo comprobar que quedó funcionando. Vas a ver algunas palabras en inglés en la pantalla; ni caso, él te guía.

¿Otras formas de pedírselo? "instala esta semilla", "pon a funcionar el pulso de agenda", "haz el setup de esto". Te entiende igual.

Para el asistente que siembra 🤖

Instala este hook (gancho de automatización) del evento SessionStart (arranque de sesión). Su trabajo es inyectar un additionalContext que TE recuerda leer la agenda del día vía el MCP de calendario del usuario. No inventes rutas: usa $HOME siempre.

Un detalle de comportamiento: si el arranque es un resume caliente (retomas una sesión que abriste hace pocos minutos), el hook NO repite el pulso, porque ya lo viste al arrancar. Lo detecta leyendo el JSON de entrada del evento (el campo source) y un sello de tiempo propio que él mismo escribe. Ese comportamiento se ajusta con CALPULSE_RESUME_WINDOW (ver paso 3).

0. Requisito previo (verifícalo antes de nada)

Este hook necesita un MCP de calendario conectado para tener algo que leer. El default que verifica es mcp-ical (lectura de Apple Calendar vía EventKit, solo macOS). Si el usuario usa otro MCP de calendario (por ejemplo uno de Google Calendar, que sí es multiplataforma), ajusta las variables CALPULSE_MCP_NAME y CALPULSE_TOOL en el paso 3. Comprueba qué MCP tiene conectado con:

claude mcp list

Si no hay ningún MCP de calendario conectado, avísale al usuario: la semilla se instala igual, pero no inyectará nada (hará un "skip visible") hasta que conecte uno.

1. Copia el script del kernel

mkdir -p "$HOME/.claude/hooks"
cp kernel/calendar-pulse-injector.sh "$HOME/.claude/hooks/calendar-pulse-injector.sh"
chmod +x "$HOME/.claude/hooks/calendar-pulse-injector.sh"

Windows (Git Bash / WSL): misma ruta ~/.claude/hooks/. El script usa bash, date y (opcionalmente) python, que vienen con Git Bash o WSL. Recuerda que el MCP mcp-ical por defecto es solo macOS; en Windows necesitarás un MCP de calendario multiplataforma.

2. Registra el hook en settings.json

Abre $HOME/.claude/settings.json (créalo si no existe) y agrega esta entrada dentro de hooks.SessionStart. Si ya hay hooks de SessionStart, suma este objeto al arreglo hooks existente en lugar de reemplazarlo (fusiona, no sobrescribas):

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "bash $HOME/.claude/hooks/calendar-pulse-injector.sh",
            "timeout": 10
          }
        ]
      }
    ]
  }
}

El "timeout": 10 es de sobra: el hook solo consulta el estado del MCP e imprime un texto corto.

3. (Opcional) Personaliza por variables de entorno

Todo tiene un default sano, así que este paso es opcional. Si el usuario quiere ajustar algo, agrega un bloque env en settings.json o define las variables en su shell:

| Variable | Qué controla | Default | |---|---|---| | CALPULSE_DISABLE | Con cualquier valor, apaga el pulso | (vacío = activo) | | CALPULSE_MCP_NAME | Nombre del MCP de calendario a verificar | mcp-ical | | CALPULSE_TOOL | Herramienta del MCP que lee eventos (aparece en el recordatorio) | mcp__mcp-ical__list_events | | CALPULSE_MSG | Reemplaza por completo el texto del recordatorio | auto | | CALPULSE_WEEKLY_HINT | Texto extra que se añade los lunes; ponlo vacío "" para quitar la pista de lunes | auto | | CALPULSE_RESUME_WINDOW | Segundos que dura un "resume caliente": si retomas la sesión dentro de esa ventana, el pulso no se repite. Ponlo en 0 para que se inyecte también en resume | 3600 (1 hora) |

4. Verificación post-siembra (obligatoria · hazla y muestra el resultado)

a) El script existe y es ejecutable:

ls -l "$HOME/.claude/hooks/calendar-pulse-injector.sh"

Salida esperada: una línea con permisos -rwxr-xr-x (la x = ejecutable).

b) Prueba en caliente — caso "MCP conectado" (simulado): para ver el JSON que se inyecta sin depender del estado real del MCP, engaña la verificación apuntándola a un CLI de mentira que siempre dice "connected". Le pasamos por la entrada un arranque tipo startup. Copia y pega este bloque completo:

tmp="$(mktemp -d)"
cat > "$tmp/claude" <<'FAKE'
#!/usr/bin/env bash
echo "mcp-ical: connected"
FAKE
chmod +x "$tmp/claude"
echo '{"source":"startup"}' | PATH="$tmp:$PATH" bash "$HOME/.claude/hooks/calendar-pulse-injector.sh"; echo "EXIT=$?"
rm -rf "$tmp"

Salida esperada: una línea JSON que empieza con {"hookSpecificOutput": y contiene PULSO DE AGENDA: con la fecha de hoy, terminada en EXIT=0.

c) Prueba del skip visible — caso "MCP no conectado": con un CLI de mentira que dice que NO está conectado, el hook debe salir limpio y avisar por qué (sin inyectar):

tmp="$(mktemp -d)"
cat > "$tmp/claude" <<'FAKE'
#!/usr/bin/env bash
echo "otros-mcps: connected"
FAKE
chmod +x "$tmp/claude"
echo '{"source":"startup"}' | PATH="$tmp:$PATH" bash "$HOME/.claude/hooks/calendar-pulse-injector.sh"; echo "EXIT=$?"
rm -rf "$tmp"

Salida esperada: una línea [calendar-pulse-injector] SKIP visible: ... y EXIT=0 (sin ningún JSON). Así confirmas que nunca falla callado.

d) Prueba del "resume caliente" — no repetir el pulso: simulamos un sello reciente (como si acabaras de arrancar la sesión) y un arranque tipo resume. El hook debe salir limpio SIN inyectar JSON, porque ya viste el pulso hace un rato:

tmp="$(mktemp -d)"
cat > "$tmp/claude" <<'FAKE'
#!/usr/bin/env bash
echo "mcp-ical: connected"
FAKE
chmod +x "$tmp/claude"
mkdir -p "$HOME/.calendar-pulse"; touch "$HOME/.calendar-pulse/last-run"
echo '{"source":"resume"}' | PATH="$tmp:$PATH" bash "$HOME/.claude/hooks/calendar-pulse-injector.sh"; echo "EXIT=$?"
rm -rf "$tmp"

Salida esperada: ningún JSON y EXIT=0. (Si en cambio quisieras que el pulso también salga en un resume, arranca con CALPULSE_RESUME_WINDOW=0.)

e) El hook quedó registrado:

grep -q 'calendar-pulse-injector' "$HOME/.claude/settings.json" && echo 'REGISTRADO'

Salida esperada: REGISTRADO.

Cuando las cinco pruebas den lo esperado, avísale al usuario que ya quedó y explícale en una línea qué gana con esto.

✅ ¿Cómo sé que funcionó?

De ahora en adelante, cuando abras una sesión nueva de trabajo (y tengas tu MCP de calendario conectado), tu asistente va a arrancar mirando tu agenda de hoy. Si el día está flojo y traes pendientes importantes, en vez de dejarlo pasar te va a proponer cómo llenarlo con horarios realistas. Y si el calendario no está disponible, te lo dice claro en lugar de fingir que todo está bien.

No tienes que hacer nada especial en el día a día. Solo vas a notar que tus días arrancan con un plan, no en automático. Eso es todo. 🌱

¿Quieres implementarla con acompañamiento?

Agenda una asesoría directa con JP y aterrízala en tu caso · desde $600 MXN.

Agendar una asesoría