@ekkos/cli 0.3.3 → 1.0.1

package/templates/hooks/user-prompt-submit.sh

@@ -1,8 +1,6 @@
 #!/bin/bash
 # ═══════════════════════════════════════════════════════════════════════════
 # ekkOS_ Hook: UserPromptSubmit - SEAMLESS CONTEXT CONTINUITY
-# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
-# EKKOS_MANAGED=1
 # ═══════════════════════════════════════════════════════════════════════════
 # ZERO USER ACTION NEEDED:
 # 1. Tracks turn number and context size
@@ -12,8 +10,12 @@
 
 set +e
 
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
+
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays 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"
@@ -21,115 +23,13 @@ SESSION_WORDS_DEFAULT="$EKKOS_CONFIG_DIR/.defaults/session-words.json"
 JSON_PARSE_HELPER="$EKKOS_CONFIG_DIR/.helpers/json-parse.cjs"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# SESSION NAME GENERATION - Uses external session-words.json (NO jq)
-# Format: adj-noun-verb (e.g., "cosmic-penguin-runs")
+# JSON PARSING HELPER - No jq required
 # ═══════════════════════════════════════════════════════════════════════════
-
-# Arrays loaded from JSON - NOT hardcoded
-declare -a ADJECTIVES
-declare -a NOUNS
-declare -a VERBS
-SESSION_WORDS_LOADED=false
-
-load_session_words() {
-    if [ "$SESSION_WORDS_LOADED" = "true" ]; then
-        return 0
-    fi
-
-    local words_file="$SESSION_WORDS_JSON"
-
-    # Fallback to managed defaults if user file missing/invalid
-    if [ ! -f "$words_file" ]; then
-        words_file="$SESSION_WORDS_DEFAULT"
-    fi
-
-    if [ ! -f "$words_file" ]; then
-        echo "ERROR: No session-words.json found. Run 'ekkos hooks install --global' to fix." >&2
-        return 1
-    fi
-
-    # Check for json-parse helper
-    if [ ! -f "$JSON_PARSE_HELPER" ]; then
-        echo "ERROR: json-parse.cjs helper not found. Run 'ekkos hooks install --global' to fix." >&2
-        return 1
-    fi
-
-    # Parse using Node helper (no jq dependency)
-    if command -v node &>/dev/null; then
-        # Use readarray if available (bash 4+), otherwise use while loop
-        if [ "${BASH_VERSINFO[0]}" -ge 4 ]; then
-            readarray -t ADJECTIVES < <(node "$JSON_PARSE_HELPER" "$words_file" '.adjectives' 2>/dev/null)
-            readarray -t NOUNS < <(node "$JSON_PARSE_HELPER" "$words_file" '.nouns' 2>/dev/null)
-            readarray -t VERBS < <(node "$JSON_PARSE_HELPER" "$words_file" '.verbs' 2>/dev/null)
-        else
-            # Bash 3 fallback (macOS default)
-            local i=0
-            while IFS= read -r line; do
-                ADJECTIVES[i]="$line"
-                ((i++))
-            done < <(node "$JSON_PARSE_HELPER" "$words_file" '.adjectives' 2>/dev/null)
-            i=0
-            while IFS= read -r line; do
-                NOUNS[i]="$line"
-                ((i++))
-            done < <(node "$JSON_PARSE_HELPER" "$words_file" '.nouns' 2>/dev/null)
-            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[@]} -eq 0 ] || [ ${#NOUNS[@]} -eq 0 ] || [ ${#VERBS[@]} -eq 0 ]; then
-            echo "ERROR: Failed to parse $words_file. Check JSON syntax." >&2
-            return 1
-        fi
-
-        SESSION_WORDS_LOADED=true
-        return 0
-    else
-        echo "ERROR: Node.js not found. Install Node.js 18+ to use ekkOS hooks." >&2
-        return 1
-    fi
-}
-
-uuid_to_words() {
-    local uuid="$1"
-
-    # Load session words if not already loaded
-    if [ "$SESSION_WORDS_LOADED" != "true" ]; then
-        load_session_words || {
-            echo "unknown-session-starts"
-            return
-        }
-    fi
-
-    local hex="${uuid//-/}"
-    hex="${hex:0:12}"
-    if [[ ! "$hex" =~ ^[0-9a-fA-F]+$ ]]; then
-        echo "unknown-session-starts"
-        return
-    fi
-    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]}"
-}
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
-
-INPUT=$(cat)
-
-# Parse input using json-parse helper (no jq)
 parse_json_value() {
     local json="$1"
     local path="$2"
     echo "$json" | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8'));
+const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
 const path = '$path'.replace(/^\./,'').split('.').filter(Boolean);
 let result = data;
 for (const p of path) {
@@ -140,100 +40,63 @@ if (result !== undefined && result !== null) console.log(result);
 " 2>/dev/null || echo ""
 }
 
+INPUT=$(cat)
 USER_QUERY=$(parse_json_value "$INPUT" '.query')
-if [ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ]; then
-    USER_QUERY=$(parse_json_value "$INPUT" '.message')
-fi
-if [ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ]; then
-    USER_QUERY=$(parse_json_value "$INPUT" '.prompt')
-fi
-
+[ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ] && USER_QUERY=$(parse_json_value "$INPUT" '.message')
+[ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ] && USER_QUERY=$(parse_json_value "$INPUT" '.prompt')
 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')
 
 [ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ] && exit 0
 
 # Fallback: read session_id from saved state if not in INPUT
-if [ -z "$RAW_SESSION_ID" ] || [ "$RAW_SESSION_ID" = "unknown" ] || [ "$RAW_SESSION_ID" = "null" ]; then
-    STATE_FILE="$HOME/.claude/state/current-session.json"
-    if [ -f "$STATE_FILE" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-        RAW_SESSION_ID=$(node "$JSON_PARSE_HELPER" "$STATE_FILE" '.session_id' 2>/dev/null || echo "unknown")
-    fi
-
-    # VSCode extension fallback: Extract session ID from transcript path
-    # Path format: ~/.claude/projects/<project>/<session-uuid>.jsonl
-    if [ "$RAW_SESSION_ID" = "unknown" ] && [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-        RAW_SESSION_ID=$(basename "$TRANSCRIPT_PATH" .jsonl)
-    fi
+if [ "$RAW_SESSION_ID" = "unknown" ] || [ "$RAW_SESSION_ID" = "null" ] || [ -z "$RAW_SESSION_ID" ]; then
+  STATE_FILE="$HOME/.claude/state/current-session.json"
+  if [ -f "$STATE_FILE" ] && [ -f "$JSON_PARSE_HELPER" ]; then
+    RAW_SESSION_ID=$(node "$JSON_PARSE_HELPER" "$STATE_FILE" '.session_id' 2>/dev/null || echo "unknown")
+  fi
+
+  # VSCode extension fallback: Extract session ID from transcript path
+  # Path format: ~/.claude/projects/<project>/<session-uuid>.jsonl
+  if [ "$RAW_SESSION_ID" = "unknown" ] && [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+    RAW_SESSION_ID=$(basename "$TRANSCRIPT_PATH" .jsonl)
+  fi
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# INTELLIGENT TOOL ROUTER: Multi-trigger skill detection
-# Detects ALL applicable skills/tools and injects as system reminder
+# SKILL AUTO-FIRE: Detect keywords and inject skill reminders
 # ═══════════════════════════════════════════════════════════════════════════
-SKILL_REMINDERS=()
+SKILL_REMINDER=""
 QUERY_LOWER=$(echo "$USER_QUERY" | tr '[:upper:]' '[:lower:]')
 
-# Memory First - Debug/Error/Problem solving
-if echo "$QUERY_LOWER" | grep -qE '(how do i|debug|error|bug|fix|not working|broken|fails|issue|problem|wrong|crash)'; then
-    SKILL_REMINDERS+=("SKILL REQUIRED: Call Skill(skill: \"ekkOS_Memory_First\") FIRST before debugging")
-fi
-
-# Recall Triggers - Time-based memory
-if echo "$QUERY_LOWER" | grep -qE '(yesterday|last week|last month|remember when|what did we|where did we leave|before|earlier|previous|ago)'; then
-    SKILL_REMINDERS+=("SKILL REQUIRED: Call Skill(skill: \"ekkOS_Deep_Recall\") for time-based memory")
-fi
-
-# Directive Triggers - User preferences
-if echo "$QUERY_LOWER" | grep -qE '(always |never |i prefer|i like |dont |don.t |avoid |remember that |from now on)'; then
-    SKILL_REMINDERS+=("SKILL REQUIRED: Call Skill(skill: \"ekkOS_Preferences\") to capture directive")
-fi
-
-# Safety Triggers - Destructive actions
-if echo "$QUERY_LOWER" | grep -qE '(delete|drop |rm -rf|deploy|push.*main|push.*master|production|migrate|rollback)'; then
-    SKILL_REMINDERS+=("SAFETY REQUIRED: Call ekkOS_Conflict before this destructive action")
+# Memory First triggers
+if echo "$QUERY_LOWER" | grep -qE '(how do i|debug|error|bug|fix|not working|broken|fails|issue)'; then
+  SKILL_REMINDER="🔧 SKILL REQUIRED: Call Skill(skill: \"ekkOS_Memory_First\") FIRST before debugging"
 fi
 
-# Schema Triggers - Database operations
-if echo "$QUERY_LOWER" | grep -qE '(sql|query|supabase|prisma|database|table|column|select |insert |update |where )'; then
-    SKILL_REMINDERS+=("SCHEMA REQUIRED: Call ekkOS_GetSchema for correct field names")
+# Recall triggers
+if echo "$QUERY_LOWER" | grep -qE '(yesterday|last week|remember when|what did we|where did we leave)'; then
+  SKILL_REMINDER="📅 SKILL REQUIRED: Call Skill(skill: \"ekkOS_Recall\") for time-based memory"
 fi
 
-# Secret Triggers - API keys, credentials
-if echo "$QUERY_LOWER" | grep -qE '(api key|token|password|credential|secret|my.*key|store.*key)'; then
-    SKILL_REMINDERS+=("SECRETS: Use ekkOS_StoreSecret to securely save credentials")
+# Preferences triggers
+if echo "$QUERY_LOWER" | grep -qE '(always |never |i prefer|dont |don.t |avoid )'; then
+  SKILL_REMINDER="⚙️ SKILL REQUIRED: Call Skill(skill: \"ekkOS_Preferences\") to capture directive"
 fi
 
-# Plan Triggers - Complex multi-step tasks
-if echo "$QUERY_LOWER" | grep -qE '(implement|build|create.*feature|refactor|migrate|set up|architecture)'; then
-    SKILL_REMINDERS+=("PLAN REQUIRED: Call ekkOS_Plan for complex multi-step tasks")
+# Safety triggers
+if echo "$QUERY_LOWER" | grep -qE '(delete|drop |rm -rf|deploy|push.*main|push.*master)'; then
+  SKILL_REMINDER="⚠️ SKILL REQUIRED: Call Skill(skill: \"ekkOS_Safety\") before destructive action"
 fi
 
-# Learn Triggers - User expressing success/failure
-if echo "$QUERY_LOWER" | grep -qE '(that worked|thanks|perfect|great|awesome|nailed it|solved|fixed it)'; then
-    SKILL_REMINDERS+=("LEARN: Consider calling ekkOS_Forge to capture this solution as a pattern")
-fi
-
-# Codebase Triggers - Project-specific code search
-if echo "$QUERY_LOWER" | grep -qE '(where is|find.*file|search.*code|in this project|in the codebase)'; then
-    SKILL_REMINDERS+=("CODEBASE: Use ekkOS_Codebase for project-specific code search")
-fi
-
-# Combine skill reminders (only take first 3 to avoid noise)
-SKILL_REMINDER=""
-REMINDER_COUNT=${#SKILL_REMINDERS[@]}
-if [ "$REMINDER_COUNT" -gt 0 ]; then
-    MAX_REMINDERS=3
-    [ "$REMINDER_COUNT" -lt "$MAX_REMINDERS" ] && MAX_REMINDERS="$REMINDER_COUNT"
-    for i in $(seq 0 $((MAX_REMINDERS - 1))); do
-        [ -n "$SKILL_REMINDER" ] && SKILL_REMINDER="$SKILL_REMINDER
-"
-        SKILL_REMINDER="$SKILL_REMINDER${SKILL_REMINDERS[$i]}"
-    done
+# Schema triggers
+if echo "$QUERY_LOWER" | grep -qE '(sql|query|supabase|prisma|database|table|column)'; then
+  SKILL_REMINDER="🗄️ SKILL REQUIRED: Call Skill(skill: \"ekkOS_Schema\") for correct field names"
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load auth using json-parse helper (no jq)
+# Load auth - No jq
 # ═══════════════════════════════════════════════════════════════════════════
 EKKOS_CONFIG="$HOME/.ekkos/config.json"
 AUTH_TOKEN=""
@@ -248,7 +111,7 @@ fi
 MEMORY_API_URL="https://mcp.ekkos.dev"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Session ID - NEW ID per conversation (not persisted 24h anymore)
+# Session ID
 # ═══════════════════════════════════════════════════════════════════════════
 STATE_DIR="$PROJECT_ROOT/.claude/state"
 mkdir -p "$STATE_DIR" 2>/dev/null || true
@@ -257,7 +120,14 @@ SESSION_FILE="$STATE_DIR/current-session.json"
 SESSION_ID="$RAW_SESSION_ID"
 
 if [ -z "$SESSION_ID" ] || [ "$SESSION_ID" = "unknown" ] || [ "$SESSION_ID" = "null" ]; then
-    exit 0
+  exit 0
+fi
+
+# 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
 
 echo "{\"session_id\": \"$SESSION_ID\", \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" > "$SESSION_FILE"
@@ -268,336 +138,376 @@ echo "{\"session_id\": \"$SESSION_ID\", \"timestamp\": \"$(date -u +%Y-%m-%dT%H:
 PROJECT_SESSION_DIR="$STATE_DIR/sessions"
 mkdir -p "$PROJECT_SESSION_DIR" 2>/dev/null || true
 TURN_COUNTER_FILE="$PROJECT_SESSION_DIR/${SESSION_ID}.turn"
+CONTEXT_SIZE_FILE="$PROJECT_SESSION_DIR/${SESSION_ID}.context"
 
+# Count API round-trips from transcript to match TUI turn counter
 TURN_NUMBER=1
 if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-    TURN_NUMBER=$(grep -c '"type":"user"' "$TRANSCRIPT_PATH" 2>/dev/null || echo "1")
-    [ "$TURN_NUMBER" -eq 0 ] && TURN_NUMBER=1
+  TURN_NUMBER=$(grep -c '"type":"user"' "$TRANSCRIPT_PATH" 2>/dev/null || echo "1")
+  [ "$TURN_NUMBER" -eq 0 ] && TURN_NUMBER=1
 fi
 
+# Detect post-clear: saved count higher than transcript means /clear happened
 SAVED_TURN_COUNT=0
 [ -f "$TURN_COUNTER_FILE" ] && SAVED_TURN_COUNT=$(cat "$TURN_COUNTER_FILE" 2>/dev/null || echo "0")
-TRANSCRIPT_TURN_COUNT=$TURN_NUMBER
 POST_CLEAR_DETECTED=false
+
 if [ "$SAVED_TURN_COUNT" -gt "$TURN_NUMBER" ]; then
-    TURN_NUMBER=$((SAVED_TURN_COUNT + 1))
-    POST_CLEAR_DETECTED=true
+  POST_CLEAR_DETECTED=true
+  TURN_NUMBER=$((SAVED_TURN_COUNT + 1))
 fi
+
 echo "$TURN_NUMBER" > "$TURN_COUNTER_FILE"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORKING MEMORY: Fast capture each turn (async, non-blocking)
+# Context size tracking - Uses tokenizer script (single source)
 # ═══════════════════════════════════════════════════════════════════════════
-MEMORY_API_URL="https://mcp.ekkos.dev"
-if [ -f "$HOME/.ekkos/config.json" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-    CAPTURE_TOKEN=$(node "$JSON_PARSE_HELPER" "$HOME/.ekkos/config.json" '.hookApiKey' 2>/dev/null || echo "")
-    if [ -z "$CAPTURE_TOKEN" ]; then
-        CAPTURE_TOKEN=$(node "$JSON_PARSE_HELPER" "$HOME/.ekkos/config.json" '.apiKey' 2>/dev/null || echo "")
-    fi
-    if [ -n "$CAPTURE_TOKEN" ] && [ "$CAPTURE_TOKEN" != "null" ]; then
-        # Async capture to Redis/Supabase - doesn't block hook execution
-        # Build JSON safely using node
-        (node -e "
-const body = JSON.stringify({
-    session_id: process.argv[1],
-    turn: parseInt(process.argv[2]),
-    query: process.argv[3]
-});
-const https = require('https');
-const req = https.request({
-    hostname: 'mcp.ekkos.dev',
-    path: '/api/v1/working/fast-capture',
-    method: 'POST',
-    headers: {
-        'Authorization': 'Bearer ' + process.argv[4],
-        'Content-Type': 'application/json'
-    }
-}, () => {});
-req.on('error', () => {});
-req.write(body);
-req.end();
-" "$RAW_SESSION_ID" "$TURN_NUMBER" "$USER_QUERY" "$CAPTURE_TOKEN" >/dev/null 2>&1) &
-    fi
+PREV_CONTEXT_PERCENT=0
+[ -f "$CONTEXT_SIZE_FILE" ] && PREV_CONTEXT_PERCENT=$(cat "$CONTEXT_SIZE_FILE" 2>/dev/null || echo "0")
+
+TOKEN_PERCENT=0
+MAX_TOKENS=200000
+TOKENIZER_SCRIPT="$SCRIPT_DIR/lib/count-tokens.cjs"
+
+if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ] && [ -f "$TOKENIZER_SCRIPT" ]; then
+  TOKEN_COUNT=$(node "$TOKENIZER_SCRIPT" "$TRANSCRIPT_PATH" 2>/dev/null || echo "0")
+  if [[ "$TOKEN_COUNT" =~ ^[0-9]+$ ]] && [ "$TOKEN_COUNT" -gt 0 ]; then
+    TOKEN_PERCENT=$((TOKEN_COUNT * 100 / MAX_TOKENS))
+    [ "$TOKEN_PERCENT" -gt 100 ] && TOKEN_PERCENT=100
+    # In proxy mode, IPC compresses ~65-70% — show estimated post-compression %
+    IPC_PERCENT=$((TOKEN_PERCENT * 30 / 100))
+    [ "$IPC_PERCENT" -lt 1 ] && IPC_PERCENT=1
+  fi
 fi
 
-# ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Tier 0 capture for instant /continue (async, non-blocking)
-# Per ekkOS Onboarding Spec v1.2 ADDENDUM: Pass instanceId for namespacing
-# ═══════════════════════════════════════════════════════════════════════════
-if command -v ekkos-capture &>/dev/null; then
-    if [ -z "$SESSION_NAME" ] || [ "$SESSION_NAME" = "unknown-session-starts" ]; then
-        SESSION_NAME=$(uuid_to_words "$RAW_SESSION_ID" 2>/dev/null || echo "unknown-session")
-    fi
-    # NEW format: ekkos-capture user <instance_id> <session_id> <session_name> <turn_id> <query> [project_path]
-    INSTANCE_ID="${EKKOS_INSTANCE_ID:-default}"
-    (ekkos-capture user "$INSTANCE_ID" "$RAW_SESSION_ID" "$SESSION_NAME" "$TURN_NUMBER" "$USER_QUERY" "$PROJECT_ROOT" \
-        >/dev/null 2>&1) &
-fi
+echo "$TOKEN_PERCENT" > "$CONTEXT_SIZE_FILE"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: CAPTURE PHASE - Track turn start
+# COLORS
 # ═══════════════════════════════════════════════════════════════════════════
-GOLDEN_LOOP_FILE="$PROJECT_ROOT/.ekkos/golden-loop-current.json"
-mkdir -p "$PROJECT_ROOT/.ekkos" 2>/dev/null || true
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+MAGENTA='\033[0;35m'
+DIM='\033[2m'
+BOLD='\033[1m'
+RESET='\033[0m'
 
-# Write current phase to file using node (no jq)
-node -e "
-const fs = require('fs');
-const data = {
-    phase: 'capture',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: 0, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$GOLDEN_LOOP_FILE', JSON.stringify(data, null, 2));
-" 2>/dev/null || true
+CURRENT_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
 
 # ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: RETRIEVE PHASE - Auto-retrieve patterns from ekkOS
+# WORD-BASED SESSION NAMES - No jq, uses ~/.ekkos/ config (works in ANY project)
 # ═══════════════════════════════════════════════════════════════════════════
-EKKOS_API_KEY=""
-if [ -f "$HOME/.ekkos/.hookApiKey" ]; then
-    EKKOS_API_KEY=$(cat "$HOME/.ekkos/.hookApiKey" 2>/dev/null || echo "")
-elif [ -f "$HOME/.ekkos/config.json" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-    EKKOS_API_KEY=$(node "$JSON_PARSE_HELPER" "$HOME/.ekkos/config.json" '.hookApiKey' 2>/dev/null || echo "")
-fi
+declare -a ADJECTIVES
+declare -a NOUNS
+declare -a VERBS
+SESSION_WORDS_LOADED=false
 
-RETRIEVED_PATTERNS=""
-PATTERN_COUNT=0
-RETRIEVED_DIRECTIVES=""
-DIRECTIVE_COUNT=0
+load_session_words() {
+    if [ "$SESSION_WORDS_LOADED" = "true" ]; then return 0; fi
 
-# ═══════════════════════════════════════════════════════════════════════════
-# DIRECTIVE CACHE: Local cache to avoid API calls every turn
-# ═══════════════════════════════════════════════════════════════════════════
-DIRECTIVE_CACHE_DIR="$HOME/.ekkos/cache"
-DIRECTIVE_CACHE_FILE="$DIRECTIVE_CACHE_DIR/directives.json"
-DIRECTIVE_CACHE_TTL=3600
-mkdir -p "$DIRECTIVE_CACHE_DIR" 2>/dev/null || true
+    local words_file="$SESSION_WORDS_JSON"
+    [ ! -f "$words_file" ] && words_file="$SESSION_WORDS_DEFAULT"
 
-DIRECTIVE_CACHE_VALID=false
-DIRECTIVE_TRIGGER_DETECTED=false
+    if [ ! -f "$words_file" ] || [ ! -f "$JSON_PARSE_HELPER" ]; then
+        ADJECTIVES=("unknown"); NOUNS=("session"); VERBS=("starts")
+        return 1
+    fi
 
-if echo "$QUERY_LOWER" | grep -qE '(always |never |i prefer|i like |dont |don.t |avoid |remember that |from now on|directive|preference)'; then
-    DIRECTIVE_TRIGGER_DETECTED=true
-fi
+    if command -v node &>/dev/null; then
+        if [ "${BASH_VERSINFO[0]}" -ge 4 ]; then
+            readarray -t ADJECTIVES < <(node "$JSON_PARSE_HELPER" "$words_file" '.adjectives' 2>/dev/null)
+            readarray -t NOUNS < <(node "$JSON_PARSE_HELPER" "$words_file" '.nouns' 2>/dev/null)
+            readarray -t VERBS < <(node "$JSON_PARSE_HELPER" "$words_file" '.verbs' 2>/dev/null)
+        else
+            local i=0
+            while IFS= read -r line; do ADJECTIVES[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.adjectives' 2>/dev/null)
+            i=0
+            while IFS= read -r line; do NOUNS[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.nouns' 2>/dev/null)
+            i=0
+            while IFS= read -r line; do VERBS[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.verbs' 2>/dev/null)
+        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
 
-if [ -f "$DIRECTIVE_CACHE_FILE" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-    CACHE_TIMESTAMP=$(node "$JSON_PARSE_HELPER" "$DIRECTIVE_CACHE_FILE" '.cached_at' 2>/dev/null || echo "0")
-    CURRENT_TIMESTAMP=$(date +%s)
-    CACHE_AGE=$((CURRENT_TIMESTAMP - CACHE_TIMESTAMP))
+    local hex="${uuid//-/}"
+    hex="${hex:0:12}"
+    [[ ! "$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]}"
+}
 
-    if [ "$CACHE_AGE" -lt "$DIRECTIVE_CACHE_TTL" ] && [ "$DIRECTIVE_TRIGGER_DETECTED" = "false" ]; then
-        DIRECTIVE_CACHE_VALID=true
+# Generate session name (or use as-is if already word-based)
+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
 fi
 
-SHOULD_INJECT_DIRECTIVES=false
-if [ "$TURN_NUMBER" -eq 1 ] || [ "$POST_CLEAR_DETECTED" = "true" ] || [ "$DIRECTIVE_TRIGGER_DETECTED" = "true" ]; then
-    SHOULD_INJECT_DIRECTIVES=true
-fi
+# ═══════════════════════════════════════════════════════════════════════════
+# SINGLE SOURCE OF TRUTH: Update ALL session tracking systems
+# ═══════════════════════════════════════════════════════════════════════════
+if [ -n "$SESSION_NAME" ]; then
+    TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+    # 1. Project-level state file
+    echo "{\"session_id\": \"$SESSION_ID\", \"session_name\": \"$SESSION_NAME\", \"timestamp\": \"$TIMESTAMP\"}" > "$SESSION_FILE" 2>/dev/null || true
+
+    # 2. Global ekkOS state (for extension LOCAL-FIRST read)
+    EKKOS_GLOBAL_STATE="$HOME/.ekkos/current-session.json"
+    mkdir -p "$HOME/.ekkos" 2>/dev/null || true
+    echo "{\"session_id\": \"$SESSION_ID\", \"session_name\": \"$SESSION_NAME\", \"project\": \"$PROJECT_ROOT\", \"timestamp\": \"$TIMESTAMP\"}" > "$EKKOS_GLOBAL_STATE" 2>/dev/null || true
+
+    # 3. CLI state file
+    CLI_STATE_FILE="$HOME/.ekkos/state.json"
+    echo "{\"sessionId\": \"$SESSION_ID\", \"sessionName\": \"$SESSION_NAME\", \"turnNumber\": $TURN_NUMBER, \"lastUpdated\": \"$TIMESTAMP\", \"projectPath\": \"$PROJECT_ROOT\"}" > "$CLI_STATE_FILE" 2>/dev/null || true
 
-if [ -n "$EKKOS_API_KEY" ] && [ -n "$USER_QUERY" ]; then
-    # Update phase to RETRIEVE
+    # 4. Multi-session tracking - No jq
+    ACTIVE_SESSIONS_FILE="$HOME/.ekkos/active-sessions.json"
     node -e "
 const fs = require('fs');
-const data = {
-    phase: 'retrieve',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: 0, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$GOLDEN_LOOP_FILE', JSON.stringify(data, null, 2));
-" 2>/dev/null || true
-
-    # Build sources array
-    if [ "$DIRECTIVE_CACHE_VALID" = "true" ]; then
-        SEARCH_SOURCES='["patterns"]'
-    else
-        SEARCH_SOURCES='["patterns", "directives"]'
+const sid = process.argv[1], sname = process.argv[2], ts = process.argv[3], proj = process.argv[4];
+try {
+    let sessions = [];
+    if (fs.existsSync('$ACTIVE_SESSIONS_FILE')) {
+        sessions = JSON.parse(fs.readFileSync('$ACTIVE_SESSIONS_FILE', 'utf8') || '[]');
+    }
+    const idx = sessions.findIndex(s => s.sessionId === sid);
+    if (idx >= 0) {
+        sessions[idx] = {...sessions[idx], sessionName: sname, lastHeartbeat: ts, projectPath: proj};
+    } else {
+        sessions.push({sessionId: sid, sessionName: sname, pid: 0, startedAt: ts, projectPath: proj, lastHeartbeat: ts});
+    }
+    fs.writeFileSync('$ACTIVE_SESSIONS_FILE', JSON.stringify(sessions, null, 2));
+} catch(e) {}
+" "$SESSION_ID" "$SESSION_NAME" "$TIMESTAMP" "$PROJECT_ROOT" 2>/dev/null || true
+
+    # 5. Update Redis via API
+    if [ -n "$AUTH_TOKEN" ]; then
+        curl -s -X POST "$MEMORY_API_URL/api/v1/working/session/current" \
+            -H "Authorization: Bearer $AUTH_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "{\"session_name\": \"$SESSION_NAME\"}" \
+            --connect-timeout 2 \
+            --max-time 3 >/dev/null 2>&1 &
     fi
 
-    # Call ekkOS MCP gateway using node (no curl dependency for JSON handling)
-    SEARCH_RESPONSE=$(node -e "
+    # 6. CRITICAL: Bind session name to proxy for R2 eviction paths - No jq
+    EKKOS_USER_ID=""
+    if [ -f "$HOME/.ekkos/config.json" ] && [ -f "$JSON_PARSE_HELPER" ]; then
+        EKKOS_USER_ID=$(node "$JSON_PARSE_HELPER" "$HOME/.ekkos/config.json" '.userId' 2>/dev/null || echo "")
+    fi
+    if [ -n "$EKKOS_USER_ID" ] && [ -n "$SESSION_NAME" ]; then
+        PENDING_SESSION="${EKKOS_PENDING_SESSION:-_pending}"
+        node -e "
 const https = require('https');
 const body = JSON.stringify({
-    tool: 'ekkOS_Search',
-    arguments: {
-        query: process.argv[1],
-        limit: 5,
-        sources: $SEARCH_SOURCES
-    }
+    userId: process.argv[1],
+    realSession: process.argv[2],
+    projectPath: process.argv[3],
+    pendingSession: process.argv[4]
 });
 const req = https.request({
-    hostname: 'api.ekkos.dev',
-    path: '/api/v1/mcp/call',
+    hostname: 'mcp.ekkos.dev',
+    path: '/proxy/session/bind',
     method: 'POST',
-    headers: {
-        'Authorization': 'Bearer ' + process.argv[2],
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(body)
-    },
-    timeout: 2000
-}, (res) => {
-    let data = '';
-    res.on('data', chunk => data += chunk);
-    res.on('end', () => console.log(data));
-});
-req.on('error', () => console.log('{}'));
-req.on('timeout', () => { req.destroy(); console.log('{}'); });
+    headers: {'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body)}
+}, () => {});
+req.on('error', () => {});
 req.write(body);
 req.end();
-" "$USER_QUERY" "$EKKOS_API_KEY" 2>/dev/null || echo '{}')
-
-    # Parse pattern count using node
-    PATTERN_COUNT=$(echo "$SEARCH_RESPONSE" | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-console.log((data?.result?.results?.patterns?.length || 0));
-" 2>/dev/null || echo "0")
-
-    if [ "$PATTERN_COUNT" -gt 0 ]; then
-        # Update golden loop
-        node -e "
-const fs = require('fs');
-const data = {
-    phase: 'inject',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: $PATTERN_COUNT, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$GOLDEN_LOOP_FILE', JSON.stringify(data, null, 2));
-" 2>/dev/null || true
-
-        # Format patterns for injection
-        RETRIEVED_PATTERNS=$(echo "$SEARCH_RESPONSE" | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const patterns = data?.result?.results?.patterns || [];
-patterns.forEach(p => {
-    console.log('**' + (p.title || 'Untitled') + '**');
-    console.log((p.problem || p.guidance || '') + '\\n');
-    console.log('## Solution');
-    console.log((p.solution || p.content || '') + '\\n');
-    console.log('Success Rate: ' + Math.round((p.success_rate || 0) * 100) + '%');
-    console.log('Applied: ' + (p.applied_count || 0) + ' times\\n');
-});
-" 2>/dev/null || echo "")
-    fi
-
-    # Handle directives
-    if [ "$DIRECTIVE_CACHE_VALID" = "true" ] && [ -f "$DIRECTIVE_CACHE_FILE" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-        DIRECTIVE_COUNT=$(node "$JSON_PARSE_HELPER" "$DIRECTIVE_CACHE_FILE" '.count' 2>/dev/null || echo "0")
-        RETRIEVED_DIRECTIVES=$(node "$JSON_PARSE_HELPER" "$DIRECTIVE_CACHE_FILE" '.formatted' 2>/dev/null || echo "")
-    else
-        DIRECTIVE_COUNT=$(echo "$SEARCH_RESPONSE" | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-console.log((data?.result?.results?.directives?.length || 0));
-" 2>/dev/null || echo "0")
-
-        if [ "$DIRECTIVE_COUNT" -gt 0 ]; then
-            RETRIEVED_DIRECTIVES=$(echo "$SEARCH_RESPONSE" | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const directives = data?.result?.results?.directives || [];
-const byType = { MUST: [], NEVER: [], PREFER: [], AVOID: [] };
-directives.forEach(d => {
-    if (byType[d.type]) byType[d.type].push('  - ' + d.rule);
-});
-let output = 'USER DIRECTIVES (FOLLOW THESE):';
-if (byType.MUST.length) output += '\\n\\nMUST:\\n' + byType.MUST.join('\\n');
-if (byType.NEVER.length) output += '\\n\\nNEVER:\\n' + byType.NEVER.join('\\n');
-if (byType.PREFER.length) output += '\\n\\nPREFER:\\n' + byType.PREFER.join('\\n');
-if (byType.AVOID.length) output += '\\n\\nAVOID:\\n' + byType.AVOID.join('\\n');
-console.log(output);
-" 2>/dev/null || echo "")
-
-            # Save to cache
-            node -e "
-const fs = require('fs');
-fs.writeFileSync('$DIRECTIVE_CACHE_FILE', JSON.stringify({
-    count: $DIRECTIVE_COUNT,
-    formatted: process.argv[1],
-    cached_at: Math.floor(Date.now() / 1000)
-}, null, 2));
-" "$RETRIEVED_DIRECTIVES" 2>/dev/null || true
-        fi
+" "$EKKOS_USER_ID" "$SESSION_NAME" "$PROJECT_ROOT" "$PENDING_SESSION" 2>/dev/null &
     fi
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# COLORS
+# "/continue" COMMAND: Run AFTER /clear to restore last 5 turns
 # ═══════════════════════════════════════════════════════════════════════════
-CYAN='\033[0;36m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-MAGENTA='\033[0;35m'
-DIM='\033[2m'
-BOLD='\033[1m'
-RESET='\033[0m'
+QUERY_LOWER=$(echo "$USER_QUERY" | tr '[:upper:]' '[:lower:]')
 
-CURRENT_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
+if [[ "$USER_QUERY" == "/continue" ]] || [[ "$USER_QUERY" =~ ^/continue[[:space:]] ]] || [[ "$QUERY_LOWER" == "continue" ]] || [[ "$QUERY_LOWER" == "continue." ]]; then
+  if [ -n "$AUTH_TOKEN" ]; then
+    RESTORE_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/turns/recall" \
+      -H "Authorization: Bearer $AUTH_TOKEN" \
+      -H "Content-Type: application/json" \
+      -d "{\"session_id\": \"current\", \"last_n\": 5, \"format\": \"detailed\"}" \
+      --connect-timeout 3 \
+      --max-time 5 2>/dev/null || echo '{"turns":[]}')
+
+    RESTORED_COUNT=$(echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log((d.turns || []).length);
+" 2>/dev/null || echo "0")
 
-# Generate session name
-SESSION_NAME=""
-if [ -n "$SESSION_ID" ] && [ "$SESSION_ID" != "unknown" ] && [ "$SESSION_ID" != "null" ]; then
-    SESSION_NAME=$(uuid_to_words "$SESSION_ID")
-fi
+    LAST_TASK=$(echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+const turns = d.turns || [];
+console.log((turns[turns.length-1]?.user_query || 'unknown task').substring(0, 200));
+" 2>/dev/null || echo "unknown task")
 
-# Simple status line
-echo -e "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
+    LAST_RESPONSE=$(echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+const turns = d.turns || [];
+console.log((turns[turns.length-1]?.assistant_response || '').substring(0, 500));
+" 2>/dev/null || echo "")
 
-# Output skill reminder if detected
-if [ -n "$SKILL_REMINDER" ]; then
     echo ""
-    echo -e "${MAGENTA}${BOLD}$SKILL_REMINDER${RESET}"
-fi
-
-# Inject directives FIRST (highest priority)
-if [ "$SHOULD_INJECT_DIRECTIVES" = "true" ] && [ -n "$RETRIEVED_DIRECTIVES" ] && [ "$DIRECTIVE_COUNT" -gt 0 ]; then
+    echo -e "${GREEN}${BOLD}✓ Session continued${RESET} ${DIM}(${RESTORED_COUNT} turns restored)${RESET}"
     echo ""
-    echo "<system-reminder>"
-    echo -e "$RETRIEVED_DIRECTIVES"
-    echo "</system-reminder>"
-fi
 
-# Inject retrieved patterns into context
-if [ -n "$RETRIEVED_PATTERNS" ] && [ "$PATTERN_COUNT" -gt 0 ]; then
-    echo ""
     echo "<system-reminder>"
-    echo "RETRIEVED PATTERNS FROM ekkOS MEMORY ($PATTERN_COUNT patterns found)"
+    echo "═══════════════════════════════════════════════════════════════════════"
+    echo "CONTEXT RESTORED - Resume seamlessly. DO NOT ask 'what were we doing?'"
+    echo "═══════════════════════════════════════════════════════════════════════"
     echo ""
-    echo -e "$RETRIEVED_PATTERNS"
+    echo "## Last User Request:"
+    echo "$LAST_TASK"
     echo ""
-    echo "These patterns were automatically retrieved based on your query. Review and apply relevant solutions."
-    echo "</system-reminder>"
+    echo "## Your Last Response (truncated):"
+    echo "$LAST_RESPONSE"
     echo ""
-    echo "MANDATORY PATTERN ACKNOWLEDGMENT (PatternGuard):"
-    echo "You MUST acknowledge ALL $PATTERN_COUNT patterns above - either SELECT or SKIP each one."
+
+    if [ "$RESTORED_COUNT" -gt 1 ]; then
+      echo "## Recent Context (older → newer):"
+      echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+const turns = d.turns || [];
+turns.slice(0, -1).forEach(t => {
+    const q = (t.user_query || '...').substring(0, 100);
+    console.log('- Turn ' + (t.turn_number || '?') + ': ' + q + '...');
+});
+" 2>/dev/null || true
+      echo ""
+    fi
+
+    echo "═══════════════════════════════════════════════════════════════════════"
+    echo "INSTRUCTION: Start your response with '✓ **Continuing** -' then pick up"
+    echo "exactly where you left off. If mid-task, continue it. If done, ask what's next."
+    echo "═══════════════════════════════════════════════════════════════════════"
+    echo "</system-reminder>"
+
+    echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${CURRENT_TIME}${RESET}"
+    exit 0
+  fi
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# COMPACTION DETECTION: If context dropped dramatically, auto-restore
+# Was >50% last turn, now <15% = compaction happened
+# ═══════════════════════════════════════════════════════════════════════════
+if [ "$PREV_CONTEXT_PERCENT" -gt 50 ] && [ "$TOKEN_PERCENT" -lt 15 ] && [ -n "$AUTH_TOKEN" ]; then
+  echo ""
+  echo -e "${GREEN}${BOLD}🔄 CONTEXT RESTORED${RESET} ${DIM}| Compaction detected | Auto-loading recent turns...${RESET}"
+
+  RESTORE_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/turns/recall" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "{\"session_id\": \"${SESSION_ID}\", \"last_n\": 10, \"format\": \"summary\"}" \
+    --connect-timeout 3 \
+    --max-time 5 2>/dev/null || echo '{"turns":[]}')
+
+  RESTORED_COUNT=$(echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log((d.turns || []).length);
+" 2>/dev/null || echo "0")
+
+  if [ "$RESTORED_COUNT" -gt 0 ]; then
+    echo -e "${GREEN}   ✓${RESET} Restored ${RESTORED_COUNT} turns from Layer 2"
     echo ""
-    echo "For patterns you USE:"
-    echo "[ekkOS_SELECT]"
-    echo "- id: <pattern_id>"
-    echo "  reason: <1-line why using>"
-    echo "  confidence: <0.0-1.0>"
-    echo "[/ekkOS_SELECT]"
+    echo -e "${MAGENTA}${BOLD}## Recent Context (auto-restored)${RESET}"
     echo ""
-    echo "For patterns NOT relevant:"
-    echo "[ekkOS_SKIP]"
-    echo "- id: <pattern_id>"
-    echo "  reason: <1-line why not relevant>"
-    echo "[/ekkOS_SKIP]"
+
+    echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+(d.turns || []).forEach(t => {
+    const q = (t.user_query || '...').substring(0, 120);
+    const a = (t.assistant_response || '...').substring(0, 250);
+    console.log('**Turn ' + (t.turn_number || '?') + '**: ' + q + '...\n> ' + a + '...\n');
+});
+" 2>/dev/null || true
+
     echo ""
-    echo "AUTOMATIC APPLICATION: When pattern matches your task, APPLY IT immediately without asking."
-    echo "Track outcome after: ekkOS_Outcome({success: true/false})"
+    echo -e "${DIM}Full history: \"turns 1-${TURN_NUMBER}\" or \"recall yesterday\"${RESET}"
+  fi
+
+  echo ""
+  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
+
+elif [ "$POST_CLEAR_DETECTED" = true ] && [ -n "$AUTH_TOKEN" ]; then
+  # /clear detected - show visible restoration banner
+  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
+  echo -e "${GREEN}${BOLD}🔄 SESSION CONTINUED${RESET} ${DIM}| ${TURN_NUMBER} turns preserved | Context restored${RESET}" >&2
+  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
+
+  echo ""
+  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+  echo -e "${GREEN}${BOLD}🔄 SESSION CONTINUED${RESET} ${DIM}| ${TURN_NUMBER} turns preserved | Restoring context...${RESET}"
+  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+
+  RESTORE_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/turns/recall" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "{\"session_id\": \"${SESSION_ID}\", \"last_n\": 10, \"format\": \"summary\"}" \
+    --connect-timeout 3 \
+    --max-time 5 2>/dev/null || echo '{"turns":[]}')
+
+  RESTORED_COUNT=$(echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log((d.turns || []).length);
+" 2>/dev/null || echo "0")
+
+  if [ "$RESTORED_COUNT" -gt 0 ]; then
+    echo -e "${GREEN}   ✓${RESET} Restored ${RESTORED_COUNT} recent turns"
     echo ""
-    echo "100% coverage required. This is how the system learns what works."
+
+    echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+(d.turns || []).forEach(t => {
+    const q = (t.query_preview || t.user_query || '...').substring(0, 80);
+    const a = (t.response_preview || t.assistant_response || '...').substring(0, 150);
+    console.log('**Turn ' + (t.turn_number || '?') + '**: ' + q + '...\n> ' + a + '...\n');
+});
+" 2>/dev/null || true
+  else
+    echo -e "${GREEN}   ✓${RESET} History preserved (${TURN_NUMBER} turns)"
+  fi
+
+  echo ""
+  echo -e "${DIM}Full history: \"recall\" or \"turns 1-${TURN_NUMBER}\"${RESET}"
+  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+  echo ""
+  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
+
+elif [ "$TOKEN_PERCENT" -ge 50 ]; then
+  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ~${IPC_PERCENT:-0}% IPC | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
+
+else
+  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
 fi
 
-# Inject footer format reminder
-if [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "unknown-session" ]; then
-    echo ""
-    echo "<footer-format>End responses with: Claude Code ({Model}) - ekkOS - Turn ${TURN_NUMBER} - ${SESSION_NAME} - ${CURRENT_TIME}</footer-format>"
+# Output skill reminder if detected
+if [ -n "$SKILL_REMINDER" ]; then
+  echo ""
+  echo -e "${MAGENTA}${BOLD}$SKILL_REMINDER${RESET}"
 fi
 
 exit 0