@ekkos/cli 0.2.18 → 1.0.0

package/templates/hooks/stop.sh

@@ -1,15 +1,15 @@
 #!/bin/bash
 # ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: Stop - FULL CONTEXT CAPTURE
-# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
-# EKKOS_MANAGED=1
+# ekkOS_ Hook: Stop - Captures turns to BOTH Working (Redis) and Episodic (Supabase)
+# NO jq dependency - uses Node.js for all JSON parsing
 # ═══════════════════════════════════════════════════════════════════════════
-# Captures FULL turn content to L2 (episodic memory):
-# - Full user query
-# - Full assistant response (no truncation)
-# - Complete file changes with edit content (old_string → new_string)
+# This hook captures every turn to:
+# 1. Working Sessions (Redis) - Fast hot cache for /continue
+# 2. Episodic Memory (Supabase) - Permanent cold storage
 #
-# Per spec v1.2 Addendum: NO jq dependency, NO hardcoded arrays
+# NO compliance checking - skills handle that
+# NO PatternGuard validation - skills handle that
+# NO verbose output - just capture silently
 # ═══════════════════════════════════════════════════════════════════════════
 
 set +e
@@ -18,8 +18,11 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
 STATE_DIR="$PROJECT_ROOT/.claude/state"
 
+mkdir -p "$STATE_DIR" 2>/dev/null
+
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - Per spec v1.2 Addendum
+# CONFIG PATHS - No jq dependency (v1.2 spec)
+# Session words live in ~/.ekkos/ so they work in ANY project
 # ═══════════════════════════════════════════════════════════════════════════
 EKKOS_CONFIG_DIR="${EKKOS_CONFIG_DIR:-$HOME/.ekkos}"
 SESSION_WORDS_JSON="$EKKOS_CONFIG_DIR/session-words.json"
@@ -28,7 +31,7 @@ JSON_PARSE_HELPER="$EKKOS_CONFIG_DIR/.helpers/json-parse.cjs"
 
 INPUT=$(cat)
 
-# Parse JSON using Node (no jq)
+# JSON parsing helper (no jq)
 parse_json_value() {
     local json="$1"
     local path="$2"
@@ -46,57 +49,28 @@ if (result !== undefined && result !== null) console.log(result);
 
 RAW_SESSION_ID=$(parse_json_value "$INPUT" '.session_id')
 [ -z "$RAW_SESSION_ID" ] && RAW_SESSION_ID="unknown"
-
 TRANSCRIPT_PATH=$(parse_json_value "$INPUT" '.transcript_path')
 MODEL_USED=$(parse_json_value "$INPUT" '.model')
 [ -z "$MODEL_USED" ] && MODEL_USED="claude-sonnet-4-5"
 
-# DEBUG: Log hook input
-echo "[ekkOS DEBUG] $(date -u +%H:%M:%S) stop.sh: session=$RAW_SESSION_ID, transcript_path=$TRANSCRIPT_PATH" >> "$HOME/.ekkos/capture-debug.log" 2>/dev/null
-
 # ═══════════════════════════════════════════════════════════════════════════
-# Session ID - Try Claude's input first, fallback to state file
+# Session ID
 # ═══════════════════════════════════════════════════════════════════════════
 SESSION_ID="$RAW_SESSION_ID"
 
-# Fallback: Read from state file if input doesn't have valid session_id
 if [ -z "$SESSION_ID" ] || [ "$SESSION_ID" = "unknown" ] || [ "$SESSION_ID" = "null" ]; then
-    STATE_FILE="$HOME/.claude/state/current-session.json"
-    if [ -f "$STATE_FILE" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-        SESSION_ID=$(node "$JSON_PARSE_HELPER" "$STATE_FILE" '.session_id' 2>/dev/null || echo "")
-    fi
-fi
-
-# Skip if still no valid session ID
-if [ -z "$SESSION_ID" ] || [ "$SESSION_ID" = "unknown" ] || [ "$SESSION_ID" = "null" ]; then
-    exit 0
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Load auth
-# ═══════════════════════════════════════════════════════════════════════════
-EKKOS_CONFIG="$HOME/.ekkos/config.json"
-AUTH_TOKEN=""
-USER_ID=""
-
-if [ -f "$EKKOS_CONFIG" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-    AUTH_TOKEN=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.hookApiKey' 2>/dev/null || echo "")
-    if [ -z "$AUTH_TOKEN" ]; then
-        AUTH_TOKEN=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.apiKey' 2>/dev/null || echo "")
-    fi
-    USER_ID=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.userId' 2>/dev/null || echo "")
+  exit 0
 fi
 
-if [ -z "$AUTH_TOKEN" ] && [ -f "$PROJECT_ROOT/.env.local" ]; then
-    AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" | cut -d'=' -f2- | tr -d '"' | tr -d "'" | tr -d '\r')
+# Check if SESSION_ID is a UUID (8-4-4-4-12 format)
+UUID_REGEX='^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+IS_UUID=false
+if [[ "$SESSION_ID" =~ $UUID_REGEX ]]; then
+  IS_UUID=true
 fi
 
-[ -z "$AUTH_TOKEN" ] && exit 0
-
-MEMORY_API_URL="https://mcp.ekkos.dev"
-
 # ═══════════════════════════════════════════════════════════════════════════
-# WORD-BASED SESSION NAMES - Uses external session-words.json (NO hardcoded arrays)
+# WORD-BASED SESSION NAMES - No jq, uses ~/.ekkos/ config (works in ANY project)
 # ═══════════════════════════════════════════════════════════════════════════
 declare -a ADJECTIVES
 declare -a NOUNS
@@ -104,16 +78,13 @@ declare -a VERBS
 SESSION_WORDS_LOADED=false
 
 load_session_words() {
-    if [ "$SESSION_WORDS_LOADED" = "true" ]; then
-        return 0
-    fi
+    if [ "$SESSION_WORDS_LOADED" = "true" ]; then return 0; fi
 
     local words_file="$SESSION_WORDS_JSON"
-    if [ ! -f "$words_file" ]; then
-        words_file="$SESSION_WORDS_DEFAULT"
-    fi
+    [ ! -f "$words_file" ] && words_file="$SESSION_WORDS_DEFAULT"
 
     if [ ! -f "$words_file" ] || [ ! -f "$JSON_PARSE_HELPER" ]; then
+        ADJECTIVES=("unknown"); NOUNS=("session"); VERBS=("starts")
         return 1
     fi
 
@@ -130,93 +101,97 @@ load_session_words() {
             i=0
             while IFS= read -r line; do VERBS[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.verbs' 2>/dev/null)
         fi
-
-        if [ ${#ADJECTIVES[@]} -gt 0 ] && [ ${#NOUNS[@]} -gt 0 ] && [ ${#VERBS[@]} -gt 0 ]; then
-            SESSION_WORDS_LOADED=true
-            return 0
-        fi
+        [ ${#ADJECTIVES[@]} -eq 0 ] && ADJECTIVES=("unknown")
+        [ ${#NOUNS[@]} -eq 0 ] && NOUNS=("session")
+        [ ${#VERBS[@]} -eq 0 ] && VERBS=("starts")
+        SESSION_WORDS_LOADED=true
+        return 0
     fi
+    ADJECTIVES=("unknown"); NOUNS=("session"); VERBS=("starts")
     return 1
 }
 
 uuid_to_words() {
     local uuid="$1"
-
-    load_session_words || {
-        echo "unknown-session-starts"
-        return
-    }
+    load_session_words
 
     local hex="${uuid//-/}"
     hex="${hex:0:12}"
-
-    if [[ ! "$hex" =~ ^[0-9a-fA-F]+$ ]]; then
-        echo "unknown-session-starts"
-        return
-    fi
+    [[ ! "$hex" =~ ^[0-9a-fA-F]+$ ]] && echo "unknown-session-starts" && return
 
     local adj_seed=$((16#${hex:0:4}))
     local noun_seed=$((16#${hex:4:4}))
     local verb_seed=$((16#${hex:8:4}))
-
     local adj_idx=$((adj_seed % ${#ADJECTIVES[@]}))
     local noun_idx=$((noun_seed % ${#NOUNS[@]}))
     local verb_idx=$((verb_seed % ${#VERBS[@]}))
-
     echo "${ADJECTIVES[$adj_idx]}-${NOUNS[$noun_idx]}-${VERBS[$verb_idx]}"
 }
 
-# Generate session name from UUID
-SESSION_NAME=""
-if [ -n "$SESSION_ID" ] && [ "$SESSION_ID" != "unknown" ] && [ "$SESSION_ID" != "null" ]; then
+if [ "$IS_UUID" = true ]; then
     SESSION_NAME=$(uuid_to_words "$SESSION_ID")
+else
+    SESSION_NAME="$SESSION_ID"
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Get turn number from local counter
+# Turn Number - read from turn file written by user-prompt-submit.sh
 # ═══════════════════════════════════════════════════════════════════════════
-PROJECT_SESSION_DIR="$STATE_DIR/sessions"
-TURN_COUNTER_FILE="$PROJECT_SESSION_DIR/${SESSION_ID}.turn"
+TURN_FILE="$STATE_DIR/sessions/${SESSION_ID}.turn"
+mkdir -p "$STATE_DIR/sessions" 2>/dev/null
 TURN_NUMBER=1
-[ -f "$TURN_COUNTER_FILE" ] && TURN_NUMBER=$(cat "$TURN_COUNTER_FILE" 2>/dev/null || echo "1")
+[ -f "$TURN_FILE" ] && TURN_NUMBER=$(cat "$TURN_FILE" 2>/dev/null || echo "1")
 
 # ═══════════════════════════════════════════════════════════════════════════
-# AUTO-CLEAR DETECTION (EARLY): Must run BEFORE any early exits
+# Load auth - No jq
 # ═══════════════════════════════════════════════════════════════════════════
-if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-    MAX_TOKENS=200000
+EKKOS_CONFIG="$HOME/.ekkos/config.json"
+AUTH_TOKEN=""
+USER_ID=""
 
-    if stat -f%z "$TRANSCRIPT_PATH" >/dev/null 2>&1; then
-        FILE_SIZE=$(stat -f%z "$TRANSCRIPT_PATH")
-    else
-        FILE_SIZE=$(stat -c%s "$TRANSCRIPT_PATH" 2>/dev/null || echo "0")
-    fi
-    ROUGH_TOKENS=$((FILE_SIZE / 4))
-    TOKEN_PERCENT=$((ROUGH_TOKENS * 100 / MAX_TOKENS))
+if [ -f "$EKKOS_CONFIG" ] && [ -f "$JSON_PARSE_HELPER" ]; then
+    AUTH_TOKEN=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.hookApiKey' 2>/dev/null || echo "")
+    [ -z "$AUTH_TOKEN" ] && AUTH_TOKEN=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.apiKey' 2>/dev/null || echo "")
+    USER_ID=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.userId' 2>/dev/null || echo "")
+fi
 
-    if [ "$TOKEN_PERCENT" -gt 50 ]; then
-        WORD_COUNT=$(wc -w < "$TRANSCRIPT_PATH" 2>/dev/null | tr -d ' ' || echo "0")
-        TOKEN_PERCENT=$((WORD_COUNT * 13 / 10 * 100 / MAX_TOKENS))
-    fi
+if [ -z "$AUTH_TOKEN" ] && [ -f "$PROJECT_ROOT/.env.local" ]; then
+    AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" | cut -d'=' -f2- | tr -d '"' | tr -d "'" | tr -d '\r')
+fi
 
-    if [ "$TOKEN_PERCENT" -ge 92 ]; then
-        AUTO_CLEAR_FLAG="$HOME/.ekkos/auto-clear.flag"
-        TIMESTAMP_EPOCH=$(date +%s)
-        echo "${TOKEN_PERCENT}:${SESSION_NAME}:${TIMESTAMP_EPOCH}" > "$AUTO_CLEAR_FLAG"
-        echo "[ekkOS] Context at ${TOKEN_PERCENT}% - auto-clear flag written (session: $SESSION_NAME)" >> "$HOME/.ekkos/capture-debug.log" 2>/dev/null
-    fi
+[ -z "$AUTH_TOKEN" ] && exit 0
+
+MEMORY_API_URL="https://mcp.ekkos.dev"
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SESSION BINDING: Bridge _pending → real session name for proxy eviction
+# The CLI may be in spawn pass-through mode (no PTY = blind to TUI output),
+# so the stop hook (which IS sighted) must bind the session.
+# ═══════════════════════════════════════════════════════════════════════════
+if [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "unknown-session-starts" ] && [ -n "$USER_ID" ]; then
+    PROJECT_PATH_FOR_BIND=$(pwd)
+    PENDING_SESSION_FOR_BIND="${EKKOS_PENDING_SESSION:-_pending}"
+    curl -s -X POST "$MEMORY_API_URL/proxy/session/bind" \
+        -H "Content-Type: application/json" \
+        -d "{\"userId\":\"$USER_ID\",\"realSession\":\"$SESSION_NAME\",\"projectPath\":\"$PROJECT_PATH_FOR_BIND\",\"pendingSession\":\"$PENDING_SESSION_FOR_BIND\"}" \
+        --connect-timeout 1 \
+        --max-time 2 >/dev/null 2>&1 &
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Check for interruption - skip capture if request was interrupted
+# EVICTION: Handled by IPC (In-Place Progressive Compression) in the proxy.
+# No hook-side eviction needed — passthrough is default for cache stability.
+# ═══════════════════════════════════════════════════════════════════════════
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Check for interruption - No jq
 # ═══════════════════════════════════════════════════════════════════════════
 IS_INTERRUPTED=$(parse_json_value "$INPUT" '.interrupted')
 [ -z "$IS_INTERRUPTED" ] && IS_INTERRUPTED="false"
-
 STOP_REASON=$(parse_json_value "$INPUT" '.stop_reason')
 
 if [ "$IS_INTERRUPTED" = "true" ] || [ "$STOP_REASON" = "user_cancelled" ] || [ "$STOP_REASON" = "interrupted" ]; then
-    exit 0
+  exit 0
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -227,75 +202,53 @@ LAST_ASSISTANT=""
 FILE_CHANGES="[]"
 
 if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-    # Extract using Node - handles complex JSON reliably
     EXTRACTION=$(node -e "
 const fs = require('fs');
-const lines = fs.readFileSync('$TRANSCRIPT_PATH', 'utf8').split('\\n').filter(Boolean);
+const lines = fs.readFileSync('$TRANSCRIPT_PATH', 'utf8').split('\n').filter(Boolean);
 const entries = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
 
-// Get last user message (not starting with <)
-let lastUser = '';
-let lastUserTime = '';
+let lastUser = '', lastUserTime = '';
 for (let i = entries.length - 1; i >= 0; i--) {
     const e = entries[i];
     if (e.type === 'user') {
         const content = e.message?.content;
         if (typeof content === 'string' && !content.startsWith('<')) {
-            lastUser = content;
-            lastUserTime = e.timestamp || '';
-            break;
+            lastUser = content; lastUserTime = e.timestamp || ''; break;
         } else if (Array.isArray(content)) {
             const textPart = content.find(c => c.type === 'text' && !c.text?.startsWith('<'));
-            if (textPart) {
-                lastUser = textPart.text;
-                lastUserTime = e.timestamp || '';
-                break;
-            }
+            if (textPart) { lastUser = textPart.text; lastUserTime = e.timestamp || ''; break; }
         }
     }
 }
 
-// Get last assistant message (after the user message)
 let lastAssistant = '';
 for (let i = entries.length - 1; i >= 0; i--) {
     const e = entries[i];
     if (e.type === 'assistant' && (!lastUserTime || e.timestamp >= lastUserTime)) {
         const content = e.message?.content;
-        if (typeof content === 'string') {
-            lastAssistant = content;
-            break;
-        } else if (Array.isArray(content)) {
+        if (typeof content === 'string') { lastAssistant = content; break; }
+        else if (Array.isArray(content)) {
             const parts = content.map(c => {
                 if (c.type === 'text') return c.text;
                 if (c.type === 'tool_use') return '[TOOL: ' + c.name + ']';
                 if (c.type === 'thinking') return '[THINKING]' + (c.thinking || c.text || '') + '[/THINKING]';
                 return '';
             }).filter(Boolean);
-            lastAssistant = parts.join('\\n');
-            break;
+            lastAssistant = parts.join('\n'); break;
         }
     }
 }
 
-// Extract file changes
 const fileChanges = [];
 entries.filter(e => e.type === 'assistant').forEach(e => {
     const content = e.message?.content;
     if (Array.isArray(content)) {
         content.filter(c => c.type === 'tool_use' && ['Edit', 'Write', 'Read'].includes(c.name)).forEach(c => {
-            fileChanges.push({
-                tool: c.name,
-                path: c.input?.file_path || c.input?.path,
-                action: c.name.toLowerCase(),
-                old_string: c.name === 'Edit' ? (c.input?.old_string || '').substring(0, 200) : null,
-                new_string: c.name === 'Edit' ? (c.input?.new_string || '').substring(0, 200) : null,
-                content: c.name === 'Write' ? (c.input?.content || '').substring(0, 500) : null
-            });
+            fileChanges.push({tool: c.name, path: c.input?.file_path || c.input?.path, action: c.name.toLowerCase()});
         });
     }
 });
 
-// Output as JSON
 console.log(JSON.stringify({
     user: lastUser,
     assistant: lastAssistant.substring(0, 50000),
@@ -308,113 +261,45 @@ console.log(JSON.stringify({
     FILE_CHANGES=$(echo "$EXTRACTION" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(JSON.stringify(d.fileChanges||[]))" 2>/dev/null || echo "[]")
 fi
 
-# Check for interruption markers
-if [[ "$LAST_USER" == *"[Request interrupted"* ]] || [[ "$LAST_USER" == *"interrupted by user"* ]]; then
-    echo "[ekkOS] Turn $TURN_NUMBER skipped: interruption marker (session: $SESSION_NAME)" >> "$HOME/.ekkos/capture-debug.log" 2>/dev/null
+if [ -z "$LAST_USER" ] || [[ "$LAST_USER" == *"[Request interrupted"* ]]; then
     exit 0
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Capture to L2 (episodic memory) - SYNCHRONOUS for reliability
+# Capture to BOTH Working Sessions (Redis) AND Episodic (Supabase) - No jq
 # ═══════════════════════════════════════════════════════════════════════════
-if [ -z "$LAST_ASSISTANT" ]; then
-    echo "[ekkOS] Turn $TURN_NUMBER skipped: LAST_ASSISTANT empty (session: $SESSION_NAME)" >> "$HOME/.ekkos/capture-debug.log" 2>/dev/null
-fi
-
 if [ -n "$LAST_USER" ] && [ -n "$LAST_ASSISTANT" ]; then
-    PAYLOAD_FILE=$(mktemp /tmp/ekkos-capture.XXXXXX.json)
+  (
     TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 
-    # Build payload using Node (no jq)
-    node -e "
-const fs = require('fs');
-const payload = {
-    user_query: process.argv[1],
-    assistant_response: process.argv[2],
-    session_id: process.argv[3],
-    user_id: process.argv[4] || 'system',
-    file_changes: JSON.parse(process.argv[5] || '[]'),
-    metadata: {
-        source: 'claude-code',
-        model_used: process.argv[6],
-        captured_at: process.argv[7],
-        minimal_hook: true
-    }
-};
-fs.writeFileSync('$PAYLOAD_FILE', JSON.stringify(payload));
-" "$LAST_USER" "$LAST_ASSISTANT" "$SESSION_ID" "${USER_ID:-system}" "$FILE_CHANGES" "$MODEL_USED" "$TIMESTAMP" 2>/dev/null
-
-    # Validate and send
-    if node -e "JSON.parse(require('fs').readFileSync('$PAYLOAD_FILE','utf8'))" 2>/dev/null; then
-        for RETRY in 1 2 3; do
-            CAPTURE_RESULT=$(curl -s -w "\n%{http_code}" -X POST "$MEMORY_API_URL/api/v1/memory/capture" \
-                -H "Authorization: Bearer $AUTH_TOKEN" \
-                -H "Content-Type: application/json" \
-                -d "@$PAYLOAD_FILE" \
-                --connect-timeout 3 \
-                --max-time 5 2>/dev/null || echo -e "\n000")
-
-            HTTP_CODE=$(echo "$CAPTURE_RESULT" | tail -1)
-
-            if [ "$HTTP_CODE" = "200" ] || [ "$HTTP_CODE" = "201" ]; then
-                break
-            fi
-            [ $RETRY -lt 3 ] && sleep 0.5
-        done
-
-        if [ "$HTTP_CODE" != "200" ] && [ "$HTTP_CODE" != "201" ]; then
-            echo "[ekkOS] L2 capture failed after 3 attempts: HTTP $HTTP_CODE" >&2
-            mkdir -p "$HOME/.ekkos/wal" 2>/dev/null
-            cp "$PAYLOAD_FILE" "$HOME/.ekkos/wal/l2-$(date +%s)-$$.json" 2>/dev/null
-        fi
-    fi
-
-    rm -f "$PAYLOAD_FILE" 2>/dev/null
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# REDIS WORKING MEMORY: Store verbatim turn in multi-session hot cache
-# ═══════════════════════════════════════════════════════════════════════════
-if [ -n "$LAST_USER" ] && [ -n "$LAST_ASSISTANT" ] && [ -n "$SESSION_NAME" ]; then
-    REDIS_PAYLOAD_FILE=$(mktemp /tmp/ekkos-redis.XXXXXX.json)
-
-    # Extract tools used
-    TOOLS_USED=$(echo "$LAST_ASSISTANT" | grep -oE '\[TOOL: [^\]]+\]' | sed 's/\[TOOL: //g; s/\]//g' | sort -u | node -e "
-const lines = require('fs').readFileSync('/dev/stdin','utf8').split('\\n').filter(Boolean);
-console.log(JSON.stringify(lines));
+    TOOLS_USED=$(echo "$FILE_CHANGES" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8') || '[]');
+console.log(JSON.stringify([...new Set(d.map(f => f.tool).filter(Boolean))]));
 " 2>/dev/null || echo "[]")
 
-    # Extract files referenced
-    FILES_REFERENCED=$(echo "$FILE_CHANGES" | node -e "
+    FILES_REF=$(echo "$FILE_CHANGES" | node -e "
 const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8') || '[]');
 console.log(JSON.stringify([...new Set(d.map(f => f.path).filter(Boolean))]));
 " 2>/dev/null || echo "[]")
 
-    # Get token counts from transcript
-    TOTAL_CONTEXT_TOKENS=0
+    # Token breakdown from tokenizer script
+    TOTAL_TOKENS=0
     INPUT_TOKENS=0
-    OUTPUT_TOKENS=0
-
-    if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-        TOKEN_DATA=$(grep '"usage"' "$TRANSCRIPT_PATH" 2>/dev/null | tail -1 | node -e "
-const line = require('fs').readFileSync('/dev/stdin','utf8');
-try {
-    const d = JSON.parse(line);
-    const u = d.message?.usage || {};
-    const input = (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0);
-    const output = u.output_tokens || 0;
-    console.log(input + ':' + output);
-} catch { console.log('0:0'); }
-" 2>/dev/null || echo "0:0")
-        INPUT_TOKENS=$(echo "$TOKEN_DATA" | cut -d: -f1)
-        OUTPUT_TOKENS=$(echo "$TOKEN_DATA" | cut -d: -f2)
-        TOTAL_CONTEXT_TOKENS=$((INPUT_TOKENS + OUTPUT_TOKENS))
+    CACHE_READ_TOKENS=0
+    CACHE_CREATION_TOKENS=0
+    TOKENIZER_SCRIPT="$SCRIPT_DIR/lib/count-tokens.cjs"
+    if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ] && [ -f "$TOKENIZER_SCRIPT" ]; then
+      TOKEN_JSON=$(node "$TOKENIZER_SCRIPT" "$TRANSCRIPT_PATH" --json 2>/dev/null || echo '{}')
+      TOTAL_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.total_tokens||0)" 2>/dev/null || echo "0")
+      INPUT_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.input_tokens||0)" 2>/dev/null || echo "0")
+      CACHE_READ_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.cache_read_tokens||0)" 2>/dev/null || echo "0")
+      CACHE_CREATION_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.cache_creation_tokens||0)" 2>/dev/null || echo "0")
+      [[ ! "$TOTAL_TOKENS" =~ ^[0-9]+$ ]] && TOTAL_TOKENS=0
     fi
 
-    # Build Redis payload
-    node -e "
-const fs = require('fs');
-const payload = {
+    # 1. WORKING SESSIONS (Redis) - No jq payload building
+    WORKING_PAYLOAD=$(node -e "
+console.log(JSON.stringify({
     session_name: process.argv[1],
     turn_number: parseInt(process.argv[2]),
     user_query: process.argv[3],
@@ -422,187 +307,64 @@ const payload = {
     model: process.argv[5],
     tools_used: JSON.parse(process.argv[6] || '[]'),
     files_referenced: JSON.parse(process.argv[7] || '[]'),
-    edits: [],
-    patterns_used: [],
     total_context_tokens: parseInt(process.argv[8]) || 0,
-    input_tokens: parseInt(process.argv[9]) || 0,
-    output_tokens: parseInt(process.argv[10]) || 0
-};
-fs.writeFileSync('$REDIS_PAYLOAD_FILE', JSON.stringify(payload));
-" "$SESSION_NAME" "$TURN_NUMBER" "$LAST_USER" "$LAST_ASSISTANT" "$MODEL_USED" "$TOOLS_USED" "$FILES_REFERENCED" "$TOTAL_CONTEXT_TOKENS" "$INPUT_TOKENS" "$OUTPUT_TOKENS" 2>/dev/null
-
-    if node -e "JSON.parse(require('fs').readFileSync('$REDIS_PAYLOAD_FILE','utf8'))" 2>/dev/null; then
-        MAX_RETRIES=3
-        RETRY=0
-        REDIS_SUCCESS=false
-
-        while [ $RETRY -lt $MAX_RETRIES ] && [ "$REDIS_SUCCESS" = "false" ]; do
-            REDIS_RESULT=$(curl -s -w "\n%{http_code}" -X POST "$MEMORY_API_URL/api/v1/working/turn" \
-                -H "Authorization: Bearer $AUTH_TOKEN" \
-                -H "Content-Type: application/json" \
-                -d "@$REDIS_PAYLOAD_FILE" \
-                --connect-timeout 3 \
-                --max-time 5 2>/dev/null || echo -e "\n000")
-
-            REDIS_HTTP_CODE=$(echo "$REDIS_RESULT" | tail -1)
-
-            if [ "$REDIS_HTTP_CODE" = "200" ] || [ "$REDIS_HTTP_CODE" = "201" ]; then
-                REDIS_SUCCESS=true
-            else
-                RETRY=$((RETRY + 1))
-                [ $RETRY -lt $MAX_RETRIES ] && sleep 0.3
-            fi
-        done
-
-        if [ "$REDIS_SUCCESS" = "false" ]; then
-            echo "[ekkOS] Redis capture failed after $MAX_RETRIES attempts: HTTP $REDIS_HTTP_CODE (session: $SESSION_NAME, turn: $TURN_NUMBER)" >&2
-            WAL_DIR="$HOME/.ekkos/wal"
-            mkdir -p "$WAL_DIR" 2>/dev/null
-            cp "$REDIS_PAYLOAD_FILE" "$WAL_DIR/redis-$(date +%s)-$$.json" 2>/dev/null
-        else
-            # ACK: Update local cache cursor
-            # Per ekkOS Onboarding Spec v1.2 ADDENDUM: Pass instanceId for namespacing
-            if command -v ekkos-capture &>/dev/null && [ -n "$SESSION_ID" ]; then
-                INSTANCE_ID="${EKKOS_INSTANCE_ID:-default}"
-                (ekkos-capture ack "$SESSION_ID" "$TURN_NUMBER" --instance="$INSTANCE_ID" >/dev/null 2>&1) &
-            fi
-        fi
+    token_breakdown: {
+        input_tokens: parseInt(process.argv[9]) || 0,
+        cache_read_tokens: parseInt(process.argv[10]) || 0,
+        cache_creation_tokens: parseInt(process.argv[11]) || 0
+    }
+}));
+" "$SESSION_NAME" "$TURN_NUMBER" "$LAST_USER" "$LAST_ASSISTANT" "$MODEL_USED" "$TOOLS_USED" "$FILES_REF" "$TOTAL_TOKENS" "$INPUT_TOKENS" "$CACHE_READ_TOKENS" "$CACHE_CREATION_TOKENS" 2>/dev/null)
+
+    if [ -n "$WORKING_PAYLOAD" ]; then
+      curl -s -X POST "$MEMORY_API_URL/api/v1/working/turn" \
+        -H "Authorization: Bearer $AUTH_TOKEN" \
+        -H "Content-Type: application/json" \
+        -d "$WORKING_PAYLOAD" \
+        --connect-timeout 3 \
+        --max-time 5 >/dev/null 2>&1 || true
     fi
 
-    rm -f "$REDIS_PAYLOAD_FILE" 2>/dev/null
-
-    # ═══════════════════════════════════════════════════════════════════════════
-    # FAST CAPTURE: Structured context for instant /continue
-    # ═══════════════════════════════════════════════════════════════════════════
-    USER_DECISION=$(echo "$LAST_USER" | grep -oiE "^(yes|no|ok|do it|go ahead|approved|confirmed|use .{1,30} instead)" | head -1 || echo "")
-    USER_CORRECTION=$(echo "$LAST_USER" | grep -oiE "(actually|no,? I meant|not that|wrong|instead)" | head -1 || echo "")
-    USER_PREFERENCE=$(echo "$LAST_USER" | grep -oiE "(always|never|I prefer|don.t|avoid) .{1,50}" | head -1 || echo "")
-
-    ERRORS_FOUND=$(echo "$LAST_ASSISTANT" | grep -oiE "(error|failed|cannot|exception|not found).{0,80}" | head -3 | node -e "
-const lines = require('fs').readFileSync('/dev/stdin','utf8').split('\\n').filter(Boolean);
-console.log(JSON.stringify(lines));
-" 2>/dev/null || echo "[]")
-
-    GIT_CHANGED=$(git diff --name-only 2>/dev/null | head -10 | node -e "
-const lines = require('fs').readFileSync('/dev/stdin','utf8').split('\\n').filter(Boolean);
-console.log(JSON.stringify(lines));
-" 2>/dev/null || echo "[]")
-
-    GIT_STAT=$(git diff --stat 2>/dev/null | tail -1 | tr -d '\n' || echo "")
-
-    COMMANDS_RUN=$(echo "$LAST_ASSISTANT" | grep -oE '\$ [^\n]{1,50}' | head -5 | sed 's/^\$ //' | node -e "
-const lines = require('fs').readFileSync('/dev/stdin','utf8').split('\\n').filter(Boolean);
-console.log(JSON.stringify(lines));
-" 2>/dev/null || echo "[]")
-
-    # Build and send fast-capture
-    FAST_PAYLOAD=$(node -e "
+    # 2. EPISODIC MEMORY (Supabase) - No jq payload building
+    EPISODIC_PAYLOAD=$(node -e "
 console.log(JSON.stringify({
-    session_name: process.argv[1],
-    turn_number: parseInt(process.argv[2]),
-    user_intent: process.argv[3].substring(0, 200),
-    user_decision: process.argv[4] || null,
-    user_correction: process.argv[5] || null,
-    user_preference: process.argv[6] || null,
-    tools_used: JSON.parse(process.argv[7] || '[]'),
-    files_modified: JSON.parse(process.argv[8] || '[]'),
-    commands_run: JSON.parse(process.argv[9] || '[]'),
-    errors: JSON.parse(process.argv[10] || '[]'),
-    git_files_changed: JSON.parse(process.argv[11] || '[]'),
-    git_diff_stat: process.argv[12] || null,
-    outcome: 'success'
+    user_query: process.argv[1],
+    assistant_response: process.argv[2],
+    session_id: process.argv[3],
+    user_id: process.argv[4] || 'system',
+    file_changes: JSON.parse(process.argv[5] || '[]'),
+    metadata: {
+        source: 'claude-code',
+        model_used: process.argv[6],
+        captured_at: process.argv[7],
+        turn_number: parseInt(process.argv[8]) || 1,
+        session_name: process.argv[9],
+        minimal_hook: true
+    }
 }));
-" "$SESSION_NAME" "$TURN_NUMBER" "$LAST_USER" "$USER_DECISION" "$USER_CORRECTION" "$USER_PREFERENCE" "$TOOLS_USED" "$FILES_REFERENCED" "$COMMANDS_RUN" "$ERRORS_FOUND" "$GIT_CHANGED" "$GIT_STAT" 2>/dev/null)
-
-    if [ -n "$FAST_PAYLOAD" ]; then
-        curl -s -X POST "$MEMORY_API_URL/api/v1/working/fast-capture" \
-            -H "Authorization: Bearer $AUTH_TOKEN" \
-            -H "Content-Type: application/json" \
-            -d "$FAST_PAYLOAD" \
-            --connect-timeout 1 \
-            --max-time 2 >/dev/null 2>&1 &
+" "$LAST_USER" "$LAST_ASSISTANT" "$SESSION_ID" "${USER_ID:-system}" "$FILE_CHANGES" "$MODEL_USED" "$TIMESTAMP" "$TURN_NUMBER" "$SESSION_NAME" 2>/dev/null)
+
+    if [ -n "$EPISODIC_PAYLOAD" ]; then
+      curl -s -X POST "$MEMORY_API_URL/api/v1/memory/capture" \
+        -H "Authorization: Bearer $AUTH_TOKEN" \
+        -H "Content-Type: application/json" \
+        -d "$EPISODIC_PAYLOAD" \
+        --connect-timeout 3 \
+        --max-time 5 >/dev/null 2>&1 || true
     fi
-
-    # ═══════════════════════════════════════════════════════════════════════════
-    # LOCAL CACHE: Tier 0 - Update turn with assistant response
-    # Per ekkOS Onboarding Spec v1.2 ADDENDUM: Pass instanceId for namespacing
-    # ═══════════════════════════════════════════════════════════════════════════
-    if command -v ekkos-capture &>/dev/null && [ -n "$SESSION_ID" ]; then
-        RESPONSE_B64=$(echo "$LAST_ASSISTANT" | base64 2>/dev/null || echo "")
-        if [ -n "$RESPONSE_B64" ]; then
-            DECODED_RESPONSE=$(echo "$RESPONSE_B64" | base64 -d 2>/dev/null || echo "")
-            if [ -n "$DECODED_RESPONSE" ]; then
-                # NEW format: ekkos-capture response <instance_id> <session_id> <turn_id> <response> [tools] [files]
-                INSTANCE_ID="${EKKOS_INSTANCE_ID:-default}"
-                (ekkos-capture response "$INSTANCE_ID" "$SESSION_ID" "$TURN_NUMBER" "$DECODED_RESPONSE" "$TOOLS_USED" "$FILES_REFERENCED" \
-                    >/dev/null 2>&1) &
-            fi
-        fi
-    fi
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# FALLBACK LOCAL CACHE UPDATE
-# Per ekkOS Onboarding Spec v1.2 ADDENDUM: Pass instanceId for namespacing
-# ═══════════════════════════════════════════════════════════════════════════
-if [ -n "$LAST_ASSISTANT" ] && command -v ekkos-capture &>/dev/null && [ -n "$SESSION_ID" ]; then
-    if [ -z "$LAST_USER" ]; then
-        echo "[ekkOS DEBUG] Fallback local cache update: LAST_ASSISTANT available, updating turn $TURN_NUMBER" >> "$HOME/.ekkos/capture-debug.log" 2>/dev/null
-        RESPONSE_B64=$(echo "$LAST_ASSISTANT" | base64 2>/dev/null || echo "")
-        if [ -n "$RESPONSE_B64" ]; then
-            DECODED_RESPONSE=$(echo "$RESPONSE_B64" | base64 -d 2>/dev/null || echo "")
-            if [ -n "$DECODED_RESPONSE" ]; then
-                TOOLS_USED=$(echo "$LAST_ASSISTANT" | grep -oE '\[TOOL: [^\]]+\]' | sed 's/\[TOOL: //g; s/\]//g' | sort -u | node -e "
-const lines = require('fs').readFileSync('/dev/stdin','utf8').split('\\n').filter(Boolean);
-console.log(JSON.stringify(lines));
-" 2>/dev/null || echo "[]")
-                # NEW format: ekkos-capture response <instance_id> <session_id> <turn_id> <response> [tools] [files]
-                INSTANCE_ID="${EKKOS_INSTANCE_ID:-default}"
-                (ekkos-capture response "$INSTANCE_ID" "$SESSION_ID" "$TURN_NUMBER" "$DECODED_RESPONSE" "$TOOLS_USED" "[]" \
-                    >/dev/null 2>&1) &
-            fi
-        fi
-    fi
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: DETECT PHASES FROM RESPONSE
-# ═══════════════════════════════════════════════════════════════════════════
-GOLDEN_LOOP_FILE="$PROJECT_ROOT/.ekkos/golden-loop-current.json"
-
-if [ -n "$LAST_ASSISTANT" ] && [ -f "$GOLDEN_LOOP_FILE" ]; then
-    RETRIEVED=$(echo "$LAST_ASSISTANT" | grep -c "ekkOS_Search" 2>/dev/null || echo "0")
-    APPLIED=$(echo "$LAST_ASSISTANT" | grep -c "\[ekkOS_SELECT\]" 2>/dev/null || echo "0")
-    FORGED=$(echo "$LAST_ASSISTANT" | grep -c "ekkOS_Forge" 2>/dev/null || echo "0")
-
-    CURRENT_PHASE="complete"
-    [ "$FORGED" -gt 0 ] && CURRENT_PHASE="measure"
-    [ "$APPLIED" -gt 0 ] && CURRENT_PHASE="inject"
-    [ "$RETRIEVED" -gt 0 ] && CURRENT_PHASE="retrieve"
-
-    node -e "
-const fs = require('fs');
-const data = {
-    phase: '$CURRENT_PHASE',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_NAME',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: $RETRIEVED, applied: $APPLIED, forged: $FORGED }
-};
-fs.writeFileSync('$GOLDEN_LOOP_FILE', JSON.stringify(data, null, 2));
-" 2>/dev/null || true
+  ) &
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Update local .ekkos/current-focus.md
+# Update local .ekkos/current-focus.md (if exists) - SILENT
 # ═══════════════════════════════════════════════════════════════════════════
 EKKOS_LOCAL_DIR="$PROJECT_ROOT/.ekkos"
 if [ -d "$EKKOS_LOCAL_DIR" ] && [ -n "$LAST_USER" ]; then
-    FOCUS_FILE="$EKKOS_LOCAL_DIR/current-focus.md"
-    TASK_SUMMARY="${LAST_USER:0:100}"
-    [ ${#LAST_USER} -gt 100 ] && TASK_SUMMARY="${TASK_SUMMARY}..."
+  FOCUS_FILE="$EKKOS_LOCAL_DIR/current-focus.md"
+  TASK_SUMMARY="${LAST_USER:0:100}"
+  [ ${#LAST_USER} -gt 100 ] && TASK_SUMMARY="${TASK_SUMMARY}..."
 
-    cat > "$FOCUS_FILE" << EOF
+  cat > "$FOCUS_FILE" << EOF
 ---
 last_updated: $(date -u +%Y-%m-%dT%H:%M:%SZ)
 session_id: ${SESSION_ID}