axel-setup 0.2.0

package/hooks/session-auto-title.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+# Auto-name session based on user's first prompt.
+# Uses hookSpecificOutput.sessionTitle (Claude Code v2.1.94+).
+#
+# Strategy:
+#   1st prompt: regex fallback immediately + launch LLM synthesis in background
+#   2nd+ prompt: if LLM result ready, replace title with synthesized version
+#   Final flag set once synthesized title is applied.
+#
+# Requires: jq, claude CLI in PATH.
+# Guard env var: CLAUDE_HOOK_RUNNING (prevents recursion when background
+# `claude -p` re-enters UserPromptSubmit).
+
+[ -n "$CLAUDE_HOOK_RUNNING" ] && exit 0
+
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+PROMPT=$(echo "$INPUT" | jq -r '.prompt // empty')
+
+[ -z "$PROMPT" ] || [ -z "$SESSION_ID" ] && exit 0
+
+STATE_DIR="$HOME/.claude/session-env"
+mkdir -p "$STATE_DIR" 2>/dev/null
+
+FINAL_FLAG="$STATE_DIR/titled-${SESSION_ID}.flag"
+LAUNCHED_FLAG="$STATE_DIR/title-launched-${SESSION_ID}.flag"
+TITLE_FILE="$STATE_DIR/title-${SESSION_ID}.txt"
+
+[ -f "$FINAL_FLAG" ] && exit 0
+
+# Language of the synthesized title. Override via AXEL_TITLE_LANGUAGE env var.
+# Default injected at install time; leave as placeholder when editing directly.
+TITLE_LANGUAGE="${AXEL_TITLE_LANGUAGE:-{{ASSISTANT_LANGUAGE}}}"
+case "$TITLE_LANGUAGE" in "{{"*"}}"|"") TITLE_LANGUAGE="english" ;; esac
+
+# --- Helpers ---
+
+emit_title() {
+  local t="$1"
+  t=$(printf '%s' "$t" | sed 's/"/\\"/g')
+  cat <<EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "UserPromptSubmit",
+    "sessionTitle": "$t"
+  }
+}
+EOF
+}
+
+regex_title() {
+  local p="$1"
+  local CLEAN
+  CLEAN=$(printf '%s' "$p" | tr '\n' ' ' | sed 's/[[:space:]]\{2,\}/ /g' | sed 's/^[[:space:]]*//')
+  local ASSISTANT_RE='^(axel|claude|assistant|asistente|bot)[,.:;!? ]+'
+  CLEAN=$(printf '%s' "$CLEAN" | sed -E "s/$ASSISTANT_RE//I" | sed 's/^[[:space:]]*//')
+  local FILLER_RE='^(hola|hey|oye|dale|ok|bueno|bien|mira|vamos a|quiero que|necesito que|por favor|please|hi|hello|can you|could you|I need you to|I want you to)[,.:;!? ]*'
+  CLEAN=$(printf '%s' "$CLEAN" | sed -E "s/$FILLER_RE//I" | sed 's/^[[:space:]]*//' | sed -E "s/$FILLER_RE//I" | sed 's/^[[:space:]]*//')
+  local GREETING_Q_RE='^[¿?]*(cómo estás|como estas|qué tal|que tal|cómo va|como va|how are you|hows it going)[?!.,;: ]*'
+  CLEAN=$(printf '%s' "$CLEAN" | sed -E "s/$GREETING_Q_RE//I" | sed 's/^[[:space:]]*//')
+  CLEAN=$(printf '%s' "$CLEAN" | sed -E "s/$FILLER_RE//I" | sed 's/^[[:space:]]*//' | sed -E "s/$FILLER_RE//I" | sed 's/^[[:space:]]*//')
+  CLEAN=$(printf '%s' "$CLEAN" | sed -E 's/^\/[a-zA-Z0-9_:-]+[[:space:]]*//')
+  local FIRST
+  FIRST=$(printf '%s' "$CLEAN" | sed -E 's/[.?!].*//' | head -1)
+  if [ ${#FIRST} -gt 55 ]; then
+    local SHORT
+    SHORT=$(printf '%s' "$FIRST" | cut -c1-55 | sed -E 's/(.*[,;:—–-]).*/\1/' | sed 's/[,;:—–-]$//')
+    [ ${#SHORT} -gt 15 ] && FIRST="$SHORT"
+  fi
+  if [ ${#FIRST} -gt 55 ]; then
+    FIRST=$(printf '%s' "$FIRST" | cut -c1-55 | sed 's/[[:space:]][^[:space:]]*$//')
+  fi
+  local TITLE
+  TITLE=$(printf '%s' "$FIRST" | awk '{print toupper(substr($0,1,1)) substr($0,2)}' | sed 's/[[:space:]]*$//')
+  if [ ${#TITLE} -lt 5 ]; then
+    TITLE=$(printf '%s' "$CLEAN" | cut -c1-40 | sed 's/[[:space:]][^[:space:]]*$//')
+  fi
+  printf '%s' "$TITLE"
+}
+
+launch_synthesis_bg() {
+  local prompt="$1"
+  local outfile="$2"
+  local lang="$3"
+
+  (
+    export CLAUDE_HOOK_RUNNING=1
+    local HOOK_TMP
+    HOOK_TMP=$(mktemp -d 2>/dev/null) || exit 0
+    local HOOK_TMP_REAL
+    HOOK_TMP_REAL=$(cd "$HOOK_TMP" 2>/dev/null && pwd -P)
+
+    local SYSTEM_PROMPT="You extract session titles for coding sessions. Read the user's first message and synthesize a brief title that summarizes the TOPIC of the conversation, not the requested action.
+
+RULES:
+- Max 55 characters
+- Language: ${lang}
+- No emojis, no quotes, no trailing period
+- Summarize the concrete TOPIC (product, feature, file, bug), not the leading verb
+- Plain text, single line
+
+Respond with ONLY the title, nothing else."
+
+    local SYNTHESIS_PROMPT="User's first message:
+
+${prompt:0:1500}"
+
+    local TITLE
+    TITLE=$( \
+      cd "$HOOK_TMP" 2>/dev/null && \
+      printf '%s' "$SYNTHESIS_PROMPT" | \
+      timeout 45 claude -p \
+        --model sonnet \
+        --append-system-prompt "$SYSTEM_PROMPT" \
+        2>/dev/null \
+    )
+
+    # Ghost JSONL cleanup: claude -p writes under ~/.claude/projects/<slug>
+    # even with --no-session-persistence (bug in v2.1.x).
+    if [ -n "$HOOK_TMP_REAL" ]; then
+      local GHOST_SLUG
+      GHOST_SLUG=$(printf '%s' "$HOOK_TMP_REAL" | sed 's|[^a-zA-Z0-9]|-|g')
+      rm -rf "$HOOK_TMP" "$HOME/.claude/projects/${GHOST_SLUG}" 2>/dev/null
+    fi
+
+    TITLE=$(printf '%s' "$TITLE" | head -1 | sed 's/^[[:space:]]*//' | sed 's/[[:space:]]*$//' | sed 's/^["'"'"']//' | sed 's/["'"'"']$//')
+    TITLE="${TITLE:0:55}"
+
+    if [ -n "$TITLE" ] && [ ${#TITLE} -ge 5 ]; then
+      printf '%s\n' "$TITLE" > "$outfile"
+    fi
+  ) &
+
+  disown
+}
+
+cleanup_session_state() {
+  rm -f "$TITLE_FILE" "$LAUNCHED_FLAG" 2>/dev/null
+}
+
+# --- Main logic ---
+
+# Case 1: synthesized title ready -> apply + mark final + cleanup
+if [ -f "$TITLE_FILE" ]; then
+  SYNTH_TITLE=$(head -1 "$TITLE_FILE" 2>/dev/null)
+  if [ -n "$SYNTH_TITLE" ] && [ ${#SYNTH_TITLE} -ge 5 ]; then
+    touch "$FINAL_FLAG"
+    cleanup_session_state
+    emit_title "$SYNTH_TITLE"
+    exit 0
+  fi
+fi
+
+# Case 2: first prompt -> regex fallback + launch bg synthesis
+if [ ! -f "$LAUNCHED_FLAG" ]; then
+  touch "$LAUNCHED_FLAG"
+  TITLE=$(regex_title "$PROMPT")
+  [ -z "$TITLE" ] && exit 0
+  launch_synthesis_bg "$PROMPT" "$TITLE_FILE" "$TITLE_LANGUAGE"
+  emit_title "$TITLE"
+  exit 0
+fi
+
+# Case 3: synthesis launched but not ready yet -> exit silently (regex title stays)
+exit 0

package/hooks/session-checkpoint.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# Periodic session checkpoint: every ~40 tool calls, summarize what's happened
+# since the last checkpoint. Uses Sonnet for quality. Runs async — non-blocking.
+#
+# Ghost-session cleanup: Claude Code v2.1.x has a bug where
+# --no-session-persistence does NOT prevent the JSONL from being written to
+# ~/.claude/projects/. The workaround is to run the subprocess from a temporary
+# cwd (so its JSONL lands in a bucket unique to this hook) and rm -rf both the
+# tmp cwd and its projects/ bucket when done. This leaves zero residue in the
+# /resume history while keeping checkpoint output intact in ~/.claude/sessions/.
+
+PROJECT_NAME=$(basename "$(pwd)")
+COUNTER_FILE="/tmp/claude-checkpoint-counter-${PROJECT_NAME}"
+CHECKPOINT_DIR="$HOME/.claude/sessions/checkpoints"
+LAST_CHECKPOINT="/tmp/claude-last-checkpoint-${PROJECT_NAME}"
+SESSION_LOG="/tmp/claude-session-log-${PROJECT_NAME}.md"
+
+mkdir -p "$CHECKPOINT_DIR"
+
+# Increment counter
+COUNT=0
+if [ -f "$COUNTER_FILE" ]; then
+  COUNT=$(cat "$COUNTER_FILE")
+fi
+COUNT=$((COUNT + 1))
+echo "$COUNT" > "$COUNTER_FILE"
+
+# Checkpoint every 40 tool calls
+if [ $((COUNT % 40)) -ne 0 ]; then
+  exit 0
+fi
+
+CHECKPOINT_NUM=$((COUNT / 40))
+TIMESTAMP=$(date +%Y-%m-%d_%H%M)
+
+# Gather recent actions from the session log (since last checkpoint)
+LAST_LINE=0
+if [ -f "$LAST_CHECKPOINT" ]; then
+  LAST_LINE=$(cat "$LAST_CHECKPOINT")
+fi
+
+RECENT_ACTIONS=""
+if [ -f "$SESSION_LOG" ]; then
+  TOTAL_LINES=$(wc -l < "$SESSION_LOG")
+  if [ "$TOTAL_LINES" -gt "$LAST_LINE" ]; then
+    RECENT_ACTIONS=$(tail -n +"$((LAST_LINE + 1))" "$SESSION_LOG" | head -c 8000)
+  fi
+  echo "$TOTAL_LINES" > "$LAST_CHECKPOINT"
+fi
+
+# Git state since last checkpoint
+GIT_DIFF=""
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  BRANCH=$(git branch --show-current 2>/dev/null)
+  GIT_DIFF="Branch: $BRANCH | Recent: $(git log --oneline -5 2>/dev/null | tr '\n' ' ') | Modified: $(git diff --name-only 2>/dev/null | head -15 | tr '\n' ', ')"
+fi
+
+# Skip if nothing meaningful happened
+if [ -z "$RECENT_ACTIONS" ] && [ -z "$GIT_DIFF" ]; then
+  exit 0
+fi
+
+# Summarize this chunk with Sonnet in background (cwd-isolated — see header comment)
+{
+  HOOK_TMP=$(mktemp -d 2>/dev/null)
+  HOOK_TMP_REAL=$(cd "$HOOK_TMP" 2>/dev/null && pwd -P)
+  SUMMARY=$(cd "$HOOK_TMP" 2>/dev/null && printf "Resume este checkpoint de trabajo (#%s) en español. Máximo 15 líneas. Sé conciso pero completo.\n\nIncluye: qué se hizo, decisiones tomadas, archivos clave, contexto importante.\n\nAcciones recientes:\n%s\n\nGit:\n%s" "$CHECKPOINT_NUM" "$RECENT_ACTIONS" "$GIT_DIFF" | claude -p --model sonnet 2>/dev/null)
+
+  # Cleanup the ghost session JSONL bucket that claude -p created.
+  # Claude slugifies the cwd by replacing any non-alphanumeric char with '-',
+  # so use pwd -P (resolved physical path) and the same regex to reconstruct it.
+  if [ -n "$HOOK_TMP_REAL" ]; then
+    GHOST_SLUG=$(echo "$HOOK_TMP_REAL" | sed 's|[^a-zA-Z0-9]|-|g')
+    rm -rf "$HOOK_TMP" "$HOME/.claude/projects/${GHOST_SLUG}" 2>/dev/null
+  fi
+
+  if [ -n "$SUMMARY" ]; then
+    CHECKPOINT_FILE="$CHECKPOINT_DIR/${PROJECT_NAME}_${TIMESTAMP}_cp${CHECKPOINT_NUM}.md"
+    cat > "$CHECKPOINT_FILE" << ENDOFFILE
+---
+project: $PROJECT_NAME
+checkpoint: $CHECKPOINT_NUM
+tool_calls: $COUNT
+date: $(date +%Y-%m-%d)
+time: $(date +%H:%M)
+---
+
+$SUMMARY
+ENDOFFILE
+  fi
+
+  # Cleanup: keep last 50 checkpoints per project
+  ls -t "$CHECKPOINT_DIR"/${PROJECT_NAME}_*.md 2>/dev/null | tail -n +51 | xargs rm -f 2>/dev/null
+
+} &
+
+exit 0

package/hooks/session-cost-log.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# session-cost-log.sh
+# Runs from Stop hook (fires after EVERY response, not just session close).
+# Uses UPSERT by session_id — one row per session, always updated to latest stats.
+# CSV columns:
+#   date,time,session_id,project,cost_usd,input_tokens,output_tokens,ctx_used_pct,five_h_end_pct,five_h_session_pct,model
+
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
+LOG_FILE="$HOME/.claude/session-costs.log"
+STATS_FILE="$HOME/.claude/session-stats-${SESSION_ID}.json"
+START_FILE="$HOME/.claude/session-stats-${SESSION_ID}-start.json"
+
+[ -z "$SESSION_ID" ] && exit 0
+
+# Bootstrap log file with header if it doesn't exist
+if [ ! -f "$LOG_FILE" ]; then
+  echo "date,time,session_id,project,cost_usd,input_tokens,output_tokens,ctx_used_pct,five_h_end_pct,five_h_session_pct,model" > "$LOG_FILE"
+fi
+
+# Read persisted stats (written by statusline on each update)
+[ ! -f "$STATS_FILE" ] && exit 0
+STATS=$(cat "$STATS_FILE")
+
+# Skip if cost is zero (no real work done)
+COST=$(echo "$STATS" | jq -r '.cost_usd // 0')
+if [ "$COST" = "0" ] || [ "$COST" = "0.0" ]; then
+  exit 0
+fi
+
+# Extract fields
+SHORT_ID="${SESSION_ID:0:8}"
+PROJECT=$(basename "${CWD:-$(pwd)}")
+INPUT_TOK=$(echo "$STATS" | jq -r '.total_input_tokens // 0')
+OUTPUT_TOK=$(echo "$STATS" | jq -r '.total_output_tokens // 0')
+CTX_PCT=$(echo "$STATS" | jq -r '.ctx_used_pct // 0' | xargs printf "%.1f")
+FIVE_H_END=$(echo "$STATS" | jq -r '.five_h_pct // 0')
+MODEL=$(echo "$STATS" | jq -r '.model // ""' | sed 's/Claude //')
+DATE=$(date +%Y-%m-%d)
+TIME=$(date +%H:%M)
+
+# Calculate per-session 5h% delta using the PRESERVED start file
+# (start file is NOT deleted here — it lives for the whole session)
+FIVE_H_START=0
+if [ -f "$START_FILE" ]; then
+  FIVE_H_START=$(jq -r '.five_h_pct_start // 0' "$START_FILE" 2>/dev/null || echo 0)
+fi
+FIVE_H_DELTA=$(awk "BEGIN {
+  d = $FIVE_H_END - $FIVE_H_START
+  if (d < 0) d = 0
+  printf \"%.1f\", d
+}" 2>/dev/null)
+
+FIVE_H_END_FMT=$(printf "%.1f" "$FIVE_H_END")
+NEW_LINE="${DATE},${TIME},${SHORT_ID},${PROJECT},${COST},${INPUT_TOK},${OUTPUT_TOK},${CTX_PCT},${FIVE_H_END_FMT},${FIVE_H_DELTA},${MODEL}"
+
+# UPSERT: replace existing row for this session_id, or append if new
+if grep -q "^[^,]*,[^,]*,${SHORT_ID}," "$LOG_FILE" 2>/dev/null; then
+  # Session already has a row — update it in place
+  awk -F',' -v sid="$SHORT_ID" -v newline="$NEW_LINE" '
+    NR == 1 { print; next }          # keep header
+    $3 == sid { print newline; next } # replace matching session row
+    { print }
+  ' "$LOG_FILE" > "${LOG_FILE}.tmp" && mv "${LOG_FILE}.tmp" "$LOG_FILE"
+else
+  # New session — append
+  echo "$NEW_LINE" >> "$LOG_FILE"
+fi
+
+# Clean up stale start files from sessions older than 12 hours
+# (keeps start file alive during the session, removes after enough time)
+find "$HOME/.claude" -maxdepth 1 -name "session-stats-*-start.json" -mmin +720 -delete 2>/dev/null
+# Also clean up stale stats files (session ended long ago)
+find "$HOME/.claude" -maxdepth 1 -name "session-stats-*.json" ! -name "*-start.json" -mmin +720 -delete 2>/dev/null
+
+exit 0

package/hooks/session-log-action.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Log significant tool actions during session for context persistence
+# Captures: file edits, bash commands, agent launches — the "what was done"
+
+PROJECT_NAME=$(basename "$(pwd)")
+SESSION_LOG="/tmp/claude-session-log-${PROJECT_NAME}.md"
+TIMESTAMP=$(date +%H:%M)
+
+TOOL_NAME_VAR="${TOOL_NAME:-unknown}"
+
+# Parse tool input for meaningful context
+case "$TOOL_NAME_VAR" in
+  Edit|Write)
+    FILE_PATH=$(echo "$TOOL_INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('file_path',''))" 2>/dev/null)
+    if [ -n "$FILE_PATH" ]; then
+      echo "- [$TIMESTAMP] **$TOOL_NAME_VAR**: \`$(basename "$FILE_PATH")\`" >> "$SESSION_LOG"
+    fi
+    ;;
+  Bash)
+    CMD=$(echo "$TOOL_INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('command','')[:120])" 2>/dev/null)
+    if [ -n "$CMD" ]; then
+      echo "- [$TIMESTAMP] **Bash**: \`$CMD\`" >> "$SESSION_LOG"
+    fi
+    ;;
+  Agent)
+    DESC=$(echo "$TOOL_INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('description',''))" 2>/dev/null)
+    if [ -n "$DESC" ]; then
+      echo "- [$TIMESTAMP] **Agent**: $DESC" >> "$SESSION_LOG"
+    fi
+    ;;
+  *)
+    # Skip less important tools (Read, Glob, Grep, etc.) to keep log concise
+    ;;
+esac
+
+exit 0

package/hooks/session-log-prompt.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Log each user prompt during the session for context persistence
+# Appends to a temp file that session-save.sh reads at the end
+
+PROJECT_NAME=$(basename "$(pwd)")
+SESSION_LOG="/tmp/claude-session-log-${PROJECT_NAME}.md"
+
+# Read user prompt from stdin (Claude Code passes it as JSON via $PROMPT)
+USER_TEXT="$PROMPT"
+
+if [ -z "$USER_TEXT" ]; then
+  # Try reading from hook input
+  USER_TEXT=$(echo "$TOOL_INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('prompt',''))" 2>/dev/null)
+fi
+
+if [ -n "$USER_TEXT" ]; then
+  TIMESTAMP=$(date +%H:%M)
+  # Truncate long prompts to keep log manageable
+  TRUNCATED=$(echo "$USER_TEXT" | head -c 500)
+  echo "### [$TIMESTAMP] Usuario" >> "$SESSION_LOG"
+  echo "$TRUNCATED" >> "$SESSION_LOG"
+  echo "" >> "$SESSION_LOG"
+fi
+
+exit 0

package/hooks/session-restore.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# Restore recent session context on SessionStart
+# Shows what was discussed, what was done, and current git state
+
+SESSION_DIR="$HOME/.claude/sessions"
+PROJECT_DIR=$(pwd)
+PROJECT_NAME=$(basename "$PROJECT_DIR")
+
+# Find the 3 most recent sessions for this project (for broader context)
+SESSIONS=$(ls -t "$SESSION_DIR"/${PROJECT_NAME}_*.md 2>/dev/null | head -3)
+
+if [ -z "$SESSIONS" ]; then
+  exit 0
+fi
+
+LATEST=$(echo "$SESSIONS" | head -1)
+SESSION_DATE=$(grep "^date:" "$LATEST" 2>/dev/null | cut -d' ' -f2)
+SESSION_TIME=$(grep "^time:" "$LATEST" 2>/dev/null | cut -d' ' -f2)
+
+echo "=== Contexto de sesiones anteriores ($PROJECT_NAME) ==="
+echo ""
+
+# Show the latest session in full
+echo "### Última sesión: $SESSION_DATE $SESSION_TIME"
+# Skip frontmatter, show content
+sed -n '/^---$/,/^---$/!p' "$LATEST" | head -80
+echo ""
+
+# Show previous sessions as one-liners
+OTHERS=$(echo "$SESSIONS" | tail -n +2)
+if [ -n "$OTHERS" ]; then
+  echo "### Sesiones anteriores:"
+  for f in $OTHERS; do
+    DATE=$(grep "^date:" "$f" 2>/dev/null | cut -d' ' -f2)
+    TIME=$(grep "^time:" "$f" 2>/dev/null | cut -d' ' -f2)
+    # Extract first user prompt as summary
+    SUMMARY=$(grep -A1 "Usuario" "$f" 2>/dev/null | grep -v "Usuario" | grep -v "^--$" | head -1 | head -c 100)
+    echo "- **$DATE $TIME**: $SUMMARY"
+  done
+fi
+
+echo ""
+echo "=== Fin contexto previo ==="
+
+exit 0

package/hooks/session-save.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+# Compile full session context on Stop for persistence between sessions
+# Combines: user prompts + actions taken + git state → structured session file
+
+SESSION_DIR="$HOME/.claude/sessions"
+mkdir -p "$SESSION_DIR"
+
+PROJECT_DIR=$(pwd)
+PROJECT_NAME=$(basename "$PROJECT_DIR")
+TIMESTAMP=$(date +%Y-%m-%d_%H%M)
+SESSION_FILE="$SESSION_DIR/${PROJECT_NAME}_${TIMESTAMP}.md"
+SESSION_LOG="/tmp/claude-session-log-${PROJECT_NAME}.md"
+
+# --- Git State ---
+GIT_INFO=""
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  BRANCH=$(git branch --show-current 2>/dev/null)
+  LAST_COMMITS=$(git log --oneline -5 2>/dev/null)
+  MODIFIED=$(git diff --name-only 2>/dev/null | head -20)
+  STAGED=$(git diff --cached --name-only 2>/dev/null | head -20)
+  GIT_INFO="## Estado Git
+- **Branch:** $BRANCH
+
+**Últimos commits:**
+\`\`\`
+$LAST_COMMITS
+\`\`\`"
+
+  if [ -n "$MODIFIED" ]; then
+    GIT_INFO="$GIT_INFO
+
+**Archivos modificados (sin commit):**
+\`\`\`
+$MODIFIED
+\`\`\`"
+  fi
+
+  if [ -n "$STAGED" ]; then
+    GIT_INFO="$GIT_INFO
+
+**Archivos staged:**
+\`\`\`
+$STAGED
+\`\`\`"
+  fi
+fi
+
+# --- Conversation Log ---
+CONVERSATION=""
+if [ -f "$SESSION_LOG" ]; then
+  CONVERSATION="## Conversación y Acciones
+
+$(cat "$SESSION_LOG")"
+fi
+
+# --- Write session file ---
+cat > "$SESSION_FILE" << ENDOFFILE
+---
+project: $PROJECT_NAME
+directory: $PROJECT_DIR
+date: $(date +%Y-%m-%d)
+time: $(date +%H:%M)
+---
+
+# Sesión: $PROJECT_NAME — $(date +%Y-%m-%d) $(date +%H:%M)
+
+$CONVERSATION
+
+$GIT_INFO
+
+## Directorio
+$PROJECT_DIR
+ENDOFFILE
+
+# Cleanup: keep last 20 session files per project
+ls -t "$SESSION_DIR"/${PROJECT_NAME}_*.md 2>/dev/null | tail -n +21 | xargs rm -f 2>/dev/null
+
+# Clear the temp log for next session
+rm -f "$SESSION_LOG"
+
+exit 0

package/hooks/session-summarize.sh

@@ -0,0 +1,154 @@
+#!/bin/bash
+# Final session summarizer: compiles checkpoints + conversation into
+# one coherent session summary. Uses Sonnet for quality. Runs async from Stop hook.
+#
+# Ghost-session cleanup: Claude Code v2.1.x has a bug where
+# --no-session-persistence does NOT prevent the JSONL from being written to
+# ~/.claude/projects/. The workaround is to run the subprocess from a temporary
+# cwd (so its JSONL lands in a bucket unique to this hook) and rm -rf both the
+# tmp cwd and its projects/ bucket when done. The summary output still lands in
+# ~/.claude/sessions/, which is what session-restore reads on the next startup.
+
+set -e
+INPUT=$(cat)
+
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+TRANSCRIPT=$(echo "$INPUT" | jq -r '.transcript_path // empty')
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
+
+PROJECT_NAME=$(basename "${CWD:-$(pwd)}")
+SESSION_DIR="$HOME/.claude/sessions"
+CHECKPOINT_DIR="$SESSION_DIR/checkpoints"
+TIMESTAMP=$(date +%Y-%m-%d_%H%M)
+SESSION_FILE="$SESSION_DIR/${PROJECT_NAME}_${TIMESTAMP}.md"
+
+# Bootstrap substitutes these placeholders at install time via --user-name,
+# --user-context and --language flags. The `case` fallback kicks in when the
+# script runs without bootstrap: sed never replaced the token, so it still
+# starts with `{{` and ends with `}}`. (We cannot compare against the literal
+# token here — bootstrap's sed would rewrite both sides of the comparison.)
+USER_NAME="{{USER_NAME}}"
+case "$USER_NAME" in "{{"*"}}"|"") USER_NAME=$(whoami) ;; esac
+USER_CONTEXT="{{USER_CONTEXT}}"
+case "$USER_CONTEXT" in "{{"*"}}"|"") USER_CONTEXT="a software engineer" ;; esac
+ASSISTANT_LANGUAGE="{{ASSISTANT_LANGUAGE}}"
+case "$ASSISTANT_LANGUAGE" in "{{"*"}}"|"") ASSISTANT_LANGUAGE="english" ;; esac
+
+mkdir -p "$SESSION_DIR"
+
+# 1. Gather checkpoint summaries from this session
+CHECKPOINTS=""
+TODAY=$(date +%Y-%m-%d)
+if [ -d "$CHECKPOINT_DIR" ]; then
+  for f in $(ls -t "$CHECKPOINT_DIR"/${PROJECT_NAME}_${TODAY}*.md 2>/dev/null | head -10); do
+    CP_CONTENT=$(sed -n '/^---$/,/^---$/!p' "$f" 2>/dev/null)
+    if [ -n "$CP_CONTENT" ]; then
+      CHECKPOINTS="$CHECKPOINTS
+--- Checkpoint ---
+$CP_CONTENT
+"
+    fi
+  done
+fi
+
+# 2. Extract conversation from transcript
+CONVERSATION=""
+if [ -n "$TRANSCRIPT" ] && [ -f "$TRANSCRIPT" ]; then
+  CONVERSATION=$(cat "$TRANSCRIPT" | \
+    jq -r 'select(.type == "human" or .type == "assistant") |
+      if .type == "human" then "USER: " + (.message // .content // "" | tostring)[:500]
+      elif .type == "assistant" then "CLAUDE: " + (.message // .content // "" | tostring)[:500]
+      else empty end' 2>/dev/null | tail -80 | head -c 30000)
+fi
+
+# 3. Git state
+GIT_INFO=""
+if cd "$CWD" 2>/dev/null && git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  BRANCH=$(git branch --show-current 2>/dev/null)
+  COMMITS=$(git log --oneline -10 2>/dev/null)
+  MODIFIED=$(git diff --name-only 2>/dev/null | head -20)
+  GIT_INFO="Branch: $BRANCH
+Commits: $COMMITS
+Modified: $MODIFIED"
+fi
+
+# Skip if nothing to summarize
+if [ -z "$CHECKPOINTS" ] && [ -z "$CONVERSATION" ] && [ -z "$GIT_INFO" ]; then
+  exit 0
+fi
+
+# 4. Compile final summary with Sonnet (cwd-isolated — see header comment)
+{
+  HOOK_TMP=$(mktemp -d 2>/dev/null)
+  HOOK_TMP_REAL=$(cd "$HOOK_TMP" 2>/dev/null && pwd -P)
+  SUMMARY=$(cd "$HOOK_TMP" 2>/dev/null && printf "You are an assistant that summarizes programming work sessions for %s (%s). Compile a coherent final summary. Respond in %s.
+
+You have 2 sources:
+- Checkpoints (partial summaries made during the session)
+- Recent conversation (user and assistant messages)
+
+Generate a structured summary with:
+1. **Session objective** — what the user wanted to accomplish
+2. **What was done** — concrete actions, modified files, tools used
+3. **Key decisions** — technical and architecture decisions, and why
+4. **Status at close** — how things ended, what's left to do
+5. **Important context** — anything the next session needs to know
+6. **User feedback** — if the user corrected or confirmed an approach
+
+Maximum 30 lines. No intro, straight to content. If checkpoints cover everything, synthesize and add what's missing from the conversation.
+
+Checkpoints:
+%s
+
+Recent conversation:
+%s
+
+Git:
+%s" "$USER_NAME" "$USER_CONTEXT" "$ASSISTANT_LANGUAGE" "$CHECKPOINTS" "$CONVERSATION" "$GIT_INFO" | claude -p --model sonnet 2>/dev/null)
+
+  # Cleanup the ghost session JSONL bucket that claude -p created.
+  # Claude slugifies the cwd by replacing any non-alphanumeric char with '-',
+  # so use pwd -P (resolved physical path) and the same regex to reconstruct it.
+  if [ -n "$HOOK_TMP_REAL" ]; then
+    GHOST_SLUG=$(echo "$HOOK_TMP_REAL" | sed 's|[^a-zA-Z0-9]|-|g')
+    rm -rf "$HOOK_TMP" "$HOME/.claude/projects/${GHOST_SLUG}" 2>/dev/null
+  fi
+
+  if [ -z "$SUMMARY" ]; then
+    SUMMARY="## Checkpoints
+$CHECKPOINTS
+
+## Recent conversation
+$(echo "$CONVERSATION" | head -c 5000)"
+  fi
+
+  cat > "$SESSION_FILE" << ENDOFFILE
+---
+project: $PROJECT_NAME
+directory: $CWD
+date: $(date +%Y-%m-%d)
+time: $(date +%H:%M)
+session_id: $SESSION_ID
+---
+
+# Session: $PROJECT_NAME — $(date +%Y-%m-%d) $(date +%H:%M)
+
+$SUMMARY
+
+## Git
+- **Branch:** $(cd "$CWD" 2>/dev/null && git branch --show-current 2>/dev/null || echo "N/A")
+$(cd "$CWD" 2>/dev/null && git log --oneline -5 2>/dev/null | sed 's/^/- /' || echo "- N/A")
+ENDOFFILE
+
+  # Cleanup sessions (keep 30) and old checkpoints
+  ls -t "$SESSION_DIR"/${PROJECT_NAME}_*.md 2>/dev/null | tail -n +31 | xargs rm -f 2>/dev/null
+  find "$CHECKPOINT_DIR" -name "${PROJECT_NAME}_*.md" -mtime +7 -delete 2>/dev/null
+
+  # Reset counters for next session
+  rm -f "/tmp/claude-checkpoint-counter-${PROJECT_NAME}"
+  rm -f "/tmp/claude-last-checkpoint-${PROJECT_NAME}"
+  rm -f "/tmp/claude-session-log-${PROJECT_NAME}.md"
+
+} &
+
+exit 0