🌱 Empieza aquí · Chequeo de contexto de sesión (canal humano)

Esta semilla le pone a tu asistente un saludo de arranque para ti: cada vez que abres una sesión de trabajo, te muestra un pequeño tablero con hechos vivos —la fecha de hoy, la salud de tus archivos clave, cuántos pendientes tienes, cualquier aviso—. Calculado al vuelo, así que nunca queda desactualizado.

Lo especial: ese saludo viaja por un canal solo para ti (el mensaje de sistema), separado del canal por donde tu asistente recibe sus instrucciones. Ni el saludo ensucia lo que "piensa" el asistente, ni las instrucciones te ensucian el saludo.

Y trae un detalle amable: si reabres en caliente una sesión que cerraste hace ratito (por defecto, menos de 60 minutos), no te repite el mismo saludo. Solo te recibe con el tablero cuando de verdad estás empezando algo, no cada vez que vuelves de un café.

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 saludo de arranque", "haz el setup de esto". Te entiende igual.

Para el asistente que siembra 🤖

Instala este hook (gancho de automatización) del evento SessionStart (inicio de sesión). Es un wrapper delgado que DELEGA en un generador vecino y emite el mensaje por el canal humano (systemMessage). Sigue estos pasos y no inventes rutas: usa $HOME siempre.

Regla de oro de esta semilla: este hook alimenta SOLO el canal humano (systemMessage). Si la persona además quiere que su asistente reciba instrucciones al arrancar (por ejemplo "activa tal rutina"), eso va en OTRO hook por el canal del agente (additionalContext), en un archivo APARTE. No los mezcles en el mismo script.

1. Copia los dos archivos del kernel

El kernel trae dos piezas que trabajan en pareja:

kernel/session-context-check.sh — el wrapper (el hook que se registra).
kernel/session-context.example.sh — el generador de ejemplo que produce el mensaje (la persona lo reemplaza luego por lo que quiera ver).

Cópialos a la carpeta de hooks y dale permiso de ejecución al wrapper:

Claude Code / Cowork (macOS o Linux):

mkdir -p "$HOME/.claude/hooks"
cp kernel/session-context-check.sh   "$HOME/.claude/hooks/session-context-check.sh"
cp kernel/session-context.example.sh "$HOME/.claude/hooks/session-context.example.sh"
chmod +x "$HOME/.claude/hooks/session-context-check.sh"

El wrapper busca al generador junto a él por defecto, por eso van los dos en la misma carpeta. Si quieres apuntar a otro generador, exporta la variable SESSION_CONTEXT_GENERATOR con la ruta del tuyo.

Windows (Git Bash / WSL): misma ruta ~/.claude/hooks/. El wrapper y el ejemplo usan bash, date y wc, que vienen con Git Bash o WSL. Si la persona quiere un generador con lógica pesada, conviene escribirlo en Python: el wrapper ya prueba python y luego python3 (rápido en Windows, sin romper en Mac/Linux).

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 existente en lugar de reemplazarlo:

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup",
        "hooks": [
          {
            "type": "command",
            "command": "bash $HOME/.claude/hooks/session-context-check.sh",
            "timeout": 5
          }
        ]
      }
    ]
  }
}

El matcher: "startup" hace que salude al abrir una sesión nueva. Si la persona también quiere el saludo al reanudar o al limpiar el contexto, agrega otras entradas con matcher: "resume" y matcher: "clear". La guarda de reanudación reciente (paso 4) es justo lo que evita que, con matcher: "resume" puesto, te vuelva a saludar cada vez que reabres en caliente.

3. (Recomendado) Aterriza el generador a ESTA persona

Abre session-context.example.sh. Trae un par de "hechos vivos" de muestra (fecha + tamaño del archivo de memoria). Reemplázalos por lo que a la persona le sirva ver al arrancar: los pendientes de su lista, si un archivo clave creció de más, si llegaron cambios de otra máquina, un tip del día. La única regla técnica: el generador debe imprimir una línea JSON con la forma {"systemMessage":"...tu texto..."}, y si lo escribes a mano, mantén el texto sin comillas dobles ni barras invertidas (o pásalo a Python y usa json.dumps, que escapa por ti).

4. (Opcional) Activa la guarda de reanudación reciente

El wrapper ya trae lista la lógica para no re-saludar cuando reabres en caliente. Funciona así: al arrancar, lee el dato source del evento; si es resume, busca un archivo de estado con la hora del último cierre y, si ese cierre fue reciente (por defecto, menos de 60 minutos), se salta el saludo.

Esa guarda solo se enciende si algo escribe la hora del último cierre. El wrapper únicamente la lee; no la escribe (así se mantiene delgado y neutral). Para aprovecharla, la persona necesita un mecanismo aparte —típicamente un hook del evento de cierre (Stop)— que deje un archivo por sesión con este contenido:

{ "last_stop_time": "2026-07-19T18:30:00+00:00" }

Ubicación por defecto: $HOME/.cache/session-context/<session_id>.json (un archivo por sesión). Cámbiala exportando SESSION_STATE_DIR.
Ventana de "reciente": 3600 segundos (60 min) por defecto. Ajústala con SESSION_HOTRESUME_WINDOW.

Si la persona no monta ese escritor, no pasa nada: la guarda nunca se dispara y siempre te saluda. Es una mejora opcional, jamás un requisito.

5. Verificación post-siembra (obligatoria)

a) El saludo se genera y es JSON válido del canal humano (arranque normal). Le pasamos por la entrada estándar un payload de arranque de muestra:

printf '{"source":"startup"}' | bash "$HOME/.claude/hooks/session-context-check.sh"; echo "EXIT=$?"

Salida esperada: una sola línea que empieza con {"systemMessage":"Chequeo de contexto de sesión\n ... y EXIT=0. Si sale vacío, revisa que el generador quedó copiado junto al wrapper.

b) La puerta de salida silencia el saludo (no bloquea el arranque):

printf '{"source":"startup"}' | SESSION_CHECK_SKIP=1 bash "$HOME/.claude/hooks/session-context-check.sh"; echo "EXIT=$?"

Salida esperada: sin ninguna línea y EXIT=0.

c) El hook quedó registrado:

grep -q 'session-context-check' "$HOME/.claude/settings.json" && echo 'REGISTRADO'

Salida esperada: REGISTRADO.

d) (Opcional) La guarda de reanudación reciente calla el saludo. Simulamos un cierre "de hace un segundo" y reabrimos esa sesión:

mkdir -p "$HOME/.cache/session-context"
AHORA="$(python3 -c 'import datetime;print(datetime.datetime.now(datetime.timezone.utc).isoformat())')"
printf '{"last_stop_time":"%s"}' "$AHORA" > "$HOME/.cache/session-context/pruebahot.json"
printf '{"source":"resume","session_id":"pruebahot"}' | bash "$HOME/.claude/hooks/session-context-check.sh"; echo "EXIT=$?"

Salida esperada: sin ninguna línea y EXIT=0 (reabrió en caliente, no re-saluda). Si en cambio pones una fecha vieja (por ejemplo 2000-01-01T00:00:00+00:00), el mismo comando sí saluda. Puedes borrar el archivo de prueba al terminar.

Cuando las pruebas obligatorias (a, b, c) den lo esperado, avísale a la persona que ya quedó y explícale en una línea qué gana con esto.

✅ ¿Cómo sé que funcionó?

A partir de ahora, cada vez que abras una sesión de trabajo, tu asistente te va a recibir con un pequeño tablero de hechos frescos: qué día es, cómo andan tus archivos, qué tienes pendiente. Es un vistazo de un segundo para saber "dónde estoy parado" antes de arrancar. Y si solo reabres una sesión que cerraste hace ratito, no te repite el saludo: te deja seguir donde ibas.

Como ese saludo vive en su propio canal, aparte del canal por donde tu asistente recibe instrucciones, ninguno le estorba al otro. No tienes que hacer nada especial en el día a día: solo vas a notar que cada sesión abre con contexto, no en frío. 🌱