🌱 Empieza aquí · Inyector de contexto al arranque

¿Alguna vez corregiste a tu asistente el lunes y el miércoles volvió a cometer el mismo error? Pasa porque tu asistente guarda esas correcciones en archivos de "lecciones", pero no las relee todas al empezar cada conversación. Esta semilla arregla eso: cada vez que arranca una sesión, le pone enfrente un resumen de tus lecciones más importantes para que las tenga presentes desde la primera respuesta.

Elige las lecciones en tres cubetas:

• Fijas — las que tú marcaste como "esto siempre importa".
• Recientes — las correcciones más frescas (las que le hiciste hace poco).
• Críticas — las que se repiten o fueron un regaño explícito (las detecta por palabras clave).

Y una función extra opcional: si la sesión no es nueva sino una reanudación reciente (la retomaste hace un rato), el hook lo nota y, en vez de volcar todo otra vez, solo avisa "sigues en caliente, usa lo que ya tienes cargado".

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 inyector de contexto", "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). Escrito en Python; requiere python3 en el sistema. Usa siempre $HOME, no inventes rutas ni cables ningún nombre de usuario.

1. Copia el script del kernel

Copia kernel/boot-context-injector.py a la carpeta de hooks del usuario y dale permiso de ejecución.

Claude Code / Cowork (macOS o Linux):

mkdir -p "$HOME/.claude/hooks"
cp kernel/boot-context-injector.py "$HOME/.claude/hooks/boot-context-injector.py"
chmod +x "$HOME/.claude/hooks/boot-context-injector.py"

Windows (Git Bash / WSL): misma ruta ~/.claude/hooks/. Necesita python3 disponible en el PATH. Si el usuario no tiene Python, avísale que este hook lo requiere.

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": "",
        "hooks": [
          {
            "type": "command",
            "command": "python3 $HOME/.claude/hooks/boot-context-injector.py",
            "timeout": 10
          }
        ]
      }
    ]
  }
}

El hook imprime un JSON con hookSpecificOutput.additionalContext. Ese es el mecanismo oficial con el que un hook de SessionStart inyecta texto al contexto del asistente. El evento le pasa al hook, por la entrada estándar (stdin), un JSON con datos como source (por ejemplo startup o resume) y session_id; el hook los lee para la función de reanudación en caliente del paso 5.

3. Prepara las lecciones y (opcional) la configuración

El hook lee tu carpeta de lecciones: los archivos Markdown donde tu asistente guarda correcciones y aprendizajes. Por defecto busca archivos que empiezan con feedback_ en $HOME/.claude/memory/ y, si no, en la carpeta */memory/ más reciente dentro de $HOME/.claude/projects/. Si las lecciones del usuario viven en otro lado o usan otro prefijo, se ajusta con variables de entorno (paso 4).

Para elegir las lecciones fijas y (opcional) los recordatorios, crea una carpeta de configuración y copia las plantillas de ejemplo:

mkdir -p "$HOME/.claude/boot-context"
cp kernel/pinned-lessons.ejemplo.txt "$HOME/.claude/boot-context/pinned-lessons.txt"
cp kernel/reminders.ejemplo.txt      "$HOME/.claude/boot-context/reminders.txt"

Luego edita pinned-lessons.txt y pon, un nombre por línea, los archivos de lección que el usuario quiere siempre presentes (sin la extensión .md si prefieres). En reminders.txt van reglas de conducta cortas (opcional). Ambos archivos aceptan comentarios con #. Si no hay lecciones fijas todavía, no pasa nada: las secciones de recientes y críticas siguen funcionando solas.

4. (Opcional) Ajusta el comportamiento con variables de entorno

Todo es parametrizable. Si no exportas nada, los valores por defecto ya funcionan:

• LESSON_DIR — carpeta de lecciones (por defecto, autodetección).
• LESSON_PREFIX — prefijo de los archivos de lección (por defecto feedback_).
• PINNED_FILE — lista de lecciones fijas (por defecto ~/.claude/boot-context/pinned-lessons.txt).
• REMINDERS_FILE — recordatorios de conducta (por defecto ~/.claude/boot-context/reminders.txt).
• RECENT_COUNT — cuántas lecciones recientes mostrar (por defecto 3).
• CRITICAL_COUNT — cuántas críticas mostrar (por defecto 2).
• CRITICAL_KEYWORDS — palabras clave (regex) que marcan una lección como crítica.
• DESC_LIMIT — tope de caracteres por descripción (por defecto 180).
• CONTEXT_CAP — tope total del bloque inyectado (por defecto 9500).
• RESUME_TTL — ventana de reanudación en caliente, en segundos (por defecto 3600, o sea 60 min).
• RESUME_STATE_DIR — carpeta de los archivos de estado por sesión (por defecto ~/.claude/boot-context/resume-state).

5. (Opcional) Reanudación en caliente

El hook trae una función extra: si la sesión no es nueva sino una reanudación (source == "resume" en el payload del evento) y la sesión anterior cerró hace poco (menos de RESUME_TTL segundos), en vez de volcar el resumen completo inyecta solo un aviso corto ("sigues en caliente, usa lo ya cargado") y sale.

Para que esto se active hace falta un ingrediente que esta semilla no incluye: un archivo de estado por sesión en RESUME_STATE_DIR/<session_id>.json con un campo last_stop_time (fecha-hora en formato ISO 8601, en UTC) que registre cuándo cerró la sesión anterior. Ese archivo lo escribe un hook companion de tipo Stop (un componente aparte). Si el usuario no tiene ese companion, no pasa nada: el archivo nunca existe, la función nunca se dispara, y el hook se comporta exactamente como el inyector base. No necesitas configurar nada para que la instalación quede correcta.

6. Verificación post-siembra (obligatoria)

a) El hook corre y produce JSON válido, con una carpeta de lecciones de prueba. Fíjate en el < /dev/null del final: le pasa una entrada vacía para que el hook no se quede esperando stdin cuando lo corres a mano.

TDIR="$(mktemp -d)"; mkdir -p "$TDIR/mem"
printf 'description: no inventes datos, marca TBD cuando no sepas\n' > "$TDIR/mem/feedback_no_inventar.md"
printf '# Responde corto: una idea por linea\n' > "$TDIR/mem/feedback_corto.md"
printf 'feedback_no_inventar\n' > "$TDIR/pinned.txt"
LESSON_DIR="$TDIR/mem" PINNED_FILE="$TDIR/pinned.txt" \
  python3 "$HOME/.claude/hooks/boot-context-injector.py" < /dev/null; echo "EXIT=$?"

Salida esperada: una sola línea de JSON con "hookEventName": "SessionStart" y un additionalContext que menciona las lecciones FIJAS y RECIENTES, terminada en EXIT=0.

b) El hook quedó registrado en settings.json:

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

Salida esperada: REGISTRADO.

c) La reanudación en caliente responde (prueba del extra opcional). Simula el payload de una sesión reanudada y un archivo de estado con un cierre reciente:

SID="test-resume-123"
SDIR="$(mktemp -d)"
NOW="$(python3 -c 'import datetime;print(datetime.datetime.now(datetime.timezone.utc).isoformat())')"
printf '{"last_stop_time": "%s"}\n' "$NOW" > "$SDIR/$SID.json"
printf '{"source":"resume","session_id":"%s"}' "$SID" | \
  RESUME_STATE_DIR="$SDIR" python3 "$HOME/.claude/hooks/boot-context-injector.py"; echo "EXIT=$?"

Salida esperada: un JSON cuyo additionalContext empieza con 🌱 REANUDACIÓN EN CALIENTE, terminado en EXIT=0. (Si el usuario no piensa usar un hook companion, esta prueba solo confirma que la función existe; en el día a día no se disparará hasta que haya un archivo de estado real.)

d) Prueba de comportamiento (la de verdad, en una sesión nueva): pídele al usuario que abra una conversación nueva. Al arrancar, tu asistente debe recibir el bloque 🌱 BOOT CONTEXT INJECTOR con sus lecciones. Una forma simple de confirmarlo: al inicio de esa sesión, tú (el asistente) puedes mencionar en una línea cuáles lecciones te llegaron inyectadas.

Cuando las pruebas pasen, 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, cada vez que empieces una conversación nueva, tu asistente arranca ya "briefeado" con tus lecciones más importantes: las que marcaste como fijas, las correcciones recientes y las que más se repetían. En la práctica vas a notar que deja de tropezar con los mismos errores y que no tienes que recordarle lo mismo cada semana.

No tienes que hacer nada en el día a día. Cuando le enseñes una lección nueva importante, solo agrégala a tu lista de fijas (o deja que él lo haga) y el inyector la surfacea sola en los siguientes arranques. Eso es todo. 🌱