@ekkos/cli 1.0.33 → 1.0.35

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

@@ -10,126 +10,207 @@
 
 set +e
 
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
-
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No jq dependency (v1.2 spec)
-# Session words live in ~/.ekkos/ so they work in ANY project
+# SESSION NAME GENERATION (must be defined early - used by ekkos-capture)
+# Format: adj-noun-verb (e.g., "cosmic-penguin-runs")
+# 100 × 100 × 100 = 1,000,000 combinations
 # ═══════════════════════════════════════════════════════════════════════════
-EKKOS_CONFIG_DIR="${EKKOS_CONFIG_DIR:-$HOME/.ekkos}"
-SESSION_WORDS_JSON="$EKKOS_CONFIG_DIR/session-words.json"
-SESSION_WORDS_DEFAULT="$EKKOS_CONFIG_DIR/.defaults/session-words.json"
-JSON_PARSE_HELPER="$EKKOS_CONFIG_DIR/.helpers/json-parse.cjs"
+ADJECTIVES=(
+  "cosmic" "turbo" "mega" "hyper" "quantum" "atomic" "stellar" "epic"
+  "mighty" "groovy" "zippy" "snappy" "jazzy" "funky" "zesty" "peppy"
+  "spicy" "crispy" "fluffy" "sparkly" "chunky" "bouncy" "bubbly" "sassy"
+  "slick" "sleek" "bold" "nifty" "perky" "plucky" "witty" "nimble"
+  "dapper" "fancy" "quirky" "punchy" "swift" "brave" "clever" "dandy"
+  "eager" "fiery" "golden" "hasty" "icy" "jolly" "keen" "lively"
+  "merry" "noble" "odd" "plush" "quick" "royal" "silly" "tidy"
+  "ultra" "vivid" "wacky" "zany" "alpha" "beta" "cyber" "delta"
+  "electric" "foggy" "giga" "hazy" "ionic" "jumpy" "kinky" "lunar"
+  "magic" "nerdy" "omega" "pixel" "quaint" "retro" "solar" "techno"
+  "unified" "viral" "wonky" "xerox" "yappy" "zen" "agile" "binary"
+  "chrome" "disco" "elastic" "fizzy" "glossy" "humble" "itchy" "jiffy"
+  "kooky" "loopy" "moody" "noisy"
+)
+NOUNS=(
+  "penguin" "panda" "otter" "narwhal" "alpaca" "llama" "badger" "walrus"
+  "waffle" "pickle" "noodle" "pretzel" "muffin" "taco" "nugget" "biscuit"
+  "rocket" "comet" "nebula" "quasar" "meteor" "photon" "pulsar" "nova"
+  "ninja" "pirate" "wizard" "robot" "yeti" "phoenix" "sphinx" "kraken"
+  "thunder" "blizzard" "tornado" "avalanche" "mango" "kiwi" "banana" "coconut"
+  "donut" "espresso" "falafel" "gyro" "hummus" "icecream" "jambon" "kebab"
+  "latte" "mocha" "nachos" "olive" "pasta" "quinoa" "ramen" "sushi"
+  "tamale" "udon" "velvet" "wasabi" "xmas" "yogurt" "ziti" "anchor"
+  "beacon" "canyon" "drifter" "echo" "falcon" "glacier" "harbor" "island"
+  "jetpack" "kayak" "lagoon" "meadow" "nebula" "orbit" "parrot" "quest"
+  "rapids" "summit" "tunnel" "umbrella" "volcano" "whisper" "xylophone" "yacht"
+  "zephyr" "acorn" "bobcat" "cactus" "dolphin" "eagle" "ferret" "gopher"
+  "hedgehog" "iguana" "jackal" "koala"
+)
+VERBS=(
+  "runs" "jumps" "flies" "swims" "dives" "soars" "glides" "dashes"
+  "zooms" "zips" "spins" "twirls" "bounces" "floats" "drifts" "sails"
+  "climbs" "leaps" "hops" "skips" "rolls" "slides" "surfs" "rides"
+  "builds" "creates" "forges" "shapes" "crafts" "designs" "codes" "types"
+  "thinks" "dreams" "learns" "grows" "blooms" "shines" "glows" "sparks"
+  "sings" "hums" "calls" "beeps" "clicks" "taps" "pings" "chimes"
+  "wins" "leads" "helps" "saves" "guards" "shields" "heals" "fixes"
+  "starts" "begins" "launches" "ignites" "blazes" "flares" "bursts" "pops"
+  "waves" "nods" "winks" "grins" "smiles" "laughs" "cheers" "claps"
+  "seeks" "finds" "spots" "tracks" "hunts" "chases" "catches" "grabs"
+  "pushes" "pulls" "lifts" "throws" "kicks" "punts" "bats" "swings"
+  "reads" "writes" "draws" "paints" "sculpts" "carves" "molds" "weaves"
+  "cooks" "bakes" "grills" "fries"
+)
 
-# ═══════════════════════════════════════════════════════════════════════════
-# JSON PARSING HELPER - No jq required
-# ═══════════════════════════════════════════════════════════════════════════
-parse_json_value() {
-    local json="$1"
-    local path="$2"
-    echo "$json" | node -e "
-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) {
-    if (result === undefined || result === null) { result = undefined; break; }
-    result = result[p];
-}
-if (result !== undefined && result !== null) console.log(result);
-" 2>/dev/null || echo ""
+uuid_to_words() {
+  local uuid="$1"
+  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)
-USER_QUERY=$(parse_json_value "$INPUT" '.query')
-[ -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')
+USER_QUERY=$(echo "$INPUT" | jq -r '.query // .message // .prompt // ""')
+RAW_SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // ""')
 
 [ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ] && exit 0
 
 # Fallback: read session_id from saved state if not in INPUT
 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)
+  if [ -f "$STATE_FILE" ]; then
+    RAW_SESSION_ID=$(jq -r '.session_id // "unknown"' "$STATE_FILE" 2>/dev/null || echo "unknown")
   fi
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# SKILL AUTO-FIRE: Detect keywords and inject skill reminders
+# INTELLIGENT TOOL ROUTER: Multi-trigger skill detection
+# Detects ALL applicable skills/tools and injects as system reminder
 # ═══════════════════════════════════════════════════════════════════════════
-SKILL_REMINDER=""
+SKILL_REMINDERS=()
 QUERY_LOWER=$(echo "$USER_QUERY" | tr '[:upper:]' '[:lower:]')
 
-# 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"
+# ─────────────────────────────────────────────────────────────────────────────
+# MANDATORY TRIGGERS (Always check ekkOS first)
+# ─────────────────────────────────────────────────────────────────────────────
+
+# 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
-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"
+# ─────────────────────────────────────────────────────────────────────────────
+# 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
 
-# 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"
+# ─────────────────────────────────────────────────────────────────────────────
+# 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
-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"
+# ─────────────────────────────────────────────────────────────────────────────
+# 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")
 fi
 
-# 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"
+# ─────────────────────────────────────────────────────────────────────────────
+# 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")
+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")
+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")
+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
+  # Take up to 3 most relevant reminders
+  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
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load auth - No jq
+# Load auth
 # ═══════════════════════════════════════════════════════════════════════════
 EKKOS_CONFIG="$HOME/.ekkos/config.json"
 AUTH_TOKEN=""
-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
+if [ -f "$EKKOS_CONFIG" ]; then
+  AUTH_TOKEN=$(jq -r '.hookApiKey // .apiKey // ""' "$EKKOS_CONFIG" 2>/dev/null || echo "")
 fi
 [ -z "$AUTH_TOKEN" ] && AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" 2>/dev/null | cut -d'=' -f2- | tr -d '"' | tr -d "'" || echo "")
 
 MEMORY_API_URL="https://mcp.ekkos.dev"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Session ID
+# Session ID - NEW ID per conversation (not persisted 24h anymore)
+# Each Claude Code session gets unique ID for proper Time Machine grouping
 # ═══════════════════════════════════════════════════════════════════════════
 STATE_DIR="$PROJECT_ROOT/.claude/state"
 mkdir -p "$STATE_DIR" 2>/dev/null || true
 SESSION_FILE="$STATE_DIR/current-session.json"
 
+# Use Claude's RAW_SESSION_ID exclusively
 SESSION_ID="$RAW_SESSION_ID"
 
+# Skip if no valid session ID from Claude
 if [ -z "$SESSION_ID" ] || [ "$SESSION_ID" = "unknown" ] || [ "$SESSION_ID" = "null" ]; then
   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
-
+# Save for other hooks to reference (but don't reuse across conversations)
 echo "{\"session_id\": \"$SESSION_ID\", \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" > "$SESSION_FILE"
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -138,376 +219,369 @@ 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
+# Count actual user messages in transcript for accurate turn number
 TURN_NUMBER=1
 if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+  # Count user message entries in JSONL transcript
   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
+# PRESERVE HISTORY: Don't overwrite if saved count is higher (after /clear)
 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  # Save for post-clear detection
 POST_CLEAR_DETECTED=false
-
 if [ "$SAVED_TURN_COUNT" -gt "$TURN_NUMBER" ]; then
-  POST_CLEAR_DETECTED=true
+  # Post-clear: INCREMENT from saved count (not just copy it)
   TURN_NUMBER=$((SAVED_TURN_COUNT + 1))
+  POST_CLEAR_DETECTED=true
 fi
-
 echo "$TURN_NUMBER" > "$TURN_COUNTER_FILE"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Context size tracking - Uses tokenizer script (single source)
+# 🧠 WORKING MEMORY: Fast capture each turn (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
-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
+MEMORY_API_URL="https://mcp.ekkos.dev"
+if [ -f "$HOME/.ekkos/config.json" ]; then
+  CAPTURE_TOKEN=$(jq -r '.hookApiKey // .apiKey // ""' "$HOME/.ekkos/config.json" 2>/dev/null || echo "")
+  if [ -n "$CAPTURE_TOKEN" ] && [ "$CAPTURE_TOKEN" != "null" ]; then
+    # Async capture to Redis/Supabase - doesn't block hook execution
+    (curl -s -X POST "$MEMORY_API_URL/api/v1/working/fast-capture" \
+      -H "Authorization: Bearer $CAPTURE_TOKEN" \
+      -H "Content-Type: application/json" \
+      -d "{\"session_id\":\"$RAW_SESSION_ID\",\"turn\":$TURN_NUMBER,\"query\":$(echo "$USER_QUERY" | jq -Rs .)}" \
+      >/dev/null 2>&1) &
   fi
 fi
 
-echo "$TOKEN_PERCENT" > "$CONTEXT_SIZE_FILE"
+# ═══════════════════════════════════════════════════════════════════════════
+# 💾 LOCAL CACHE: Tier 0 capture for instant /continue (async, non-blocking)
+# ═══════════════════════════════════════════════════════════════════════════
+if command -v ekkos-capture &>/dev/null; then
+  # Generate session name if not already set
+  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
+  # Async local capture - writes to ~/.ekkos/cache/sessions/<uuid>.jsonl
+  (ekkos-capture user "$RAW_SESSION_ID" "$SESSION_NAME" "$TURN_NUMBER" "$USER_QUERY" "$PROJECT_ROOT" \
+    >/dev/null 2>&1) &
+fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# COLORS
+# 📥 GOLDEN LOOP: CAPTURE PHASE - Track turn start
 # ═══════════════════════════════════════════════════════════════════════════
-CYAN='\033[0;36m'
-GREEN='\033[0;32m'
-MAGENTA='\033[0;35m'
-DIM='\033[2m'
-BOLD='\033[1m'
-RESET='\033[0m'
+GOLDEN_LOOP_FILE="$PROJECT_ROOT/.ekkos/golden-loop-current.json"
+mkdir -p "$PROJECT_ROOT/.ekkos" 2>/dev/null || true
+
+# Write current phase to file (extension watches this for real-time updates)
+jq -n \
+  --arg phase "capture" \
+  --argjson turn "$TURN_NUMBER" \
+  --arg session "$SESSION_ID" \
+  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  '{
+    phase: $phase,
+    turn: $turn,
+    session: $session,
+    timestamp: $timestamp,
+    stats: {
+      retrieved: 0,
+      applied: 0,
+      forged: 0
+    }
+  }' > "$GOLDEN_LOOP_FILE" 2>/dev/null || true
 
-CURRENT_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
+# ═══════════════════════════════════════════════════════════════════════════
+# 🔍 GOLDEN LOOP: RETRIEVE PHASE - Auto-retrieve patterns from ekkOS
+# ═══════════════════════════════════════════════════════════════════════════
+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" ]; then
+  EKKOS_API_KEY=$(jq -r '.hookApiKey // ""' "$HOME/.ekkos/config.json" 2>/dev/null || echo "")
+fi
+
+RETRIEVED_PATTERNS=""
+PATTERN_COUNT=0
+RETRIEVED_DIRECTIVES=""
+DIRECTIVE_COUNT=0
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORD-BASED SESSION NAMES - No jq, uses ~/.ekkos/ config (works in ANY project)
+# 📦 DIRECTIVE CACHE: Local cache to avoid API calls every turn
+# Only fetch from API if:
+#   1. Cache doesn't exist
+#   2. Cache is >1 hour old
+#   3. Directive-related trigger detected in query
 # ═══════════════════════════════════════════════════════════════════════════
-declare -a ADJECTIVES
-declare -a NOUNS
-declare -a VERBS
-SESSION_WORDS_LOADED=false
+DIRECTIVE_CACHE_DIR="$HOME/.ekkos/cache"
+DIRECTIVE_CACHE_FILE="$DIRECTIVE_CACHE_DIR/directives.json"
+DIRECTIVE_CACHE_TTL=3600  # 1 hour in seconds
+mkdir -p "$DIRECTIVE_CACHE_DIR" 2>/dev/null || true
+
+# Check if we need to refresh directive cache
+DIRECTIVE_CACHE_VALID=false
+DIRECTIVE_TRIGGER_DETECTED=false
+
+# Smart detection: Check if query mentions directive-related keywords
+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
 
-load_session_words() {
-    if [ "$SESSION_WORDS_LOADED" = "true" ]; then return 0; fi
+if [ -f "$DIRECTIVE_CACHE_FILE" ]; then
+  CACHE_TIMESTAMP=$(jq -r '.cached_at // 0' "$DIRECTIVE_CACHE_FILE" 2>/dev/null || echo "0")
+  CURRENT_TIMESTAMP=$(date +%s)
+  CACHE_AGE=$((CURRENT_TIMESTAMP - CACHE_TIMESTAMP))
 
-    local words_file="$SESSION_WORDS_JSON"
-    [ ! -f "$words_file" ] && words_file="$SESSION_WORDS_DEFAULT"
+  # Cache is valid if <1 hour old AND no directive trigger detected
+  if [ "$CACHE_AGE" -lt "$DIRECTIVE_CACHE_TTL" ] && [ "$DIRECTIVE_TRIGGER_DETECTED" = "false" ]; then
+    DIRECTIVE_CACHE_VALID=true
+  fi
+fi
 
-    if [ ! -f "$words_file" ] || [ ! -f "$JSON_PARSE_HELPER" ]; then
-        ADJECTIVES=("unknown"); NOUNS=("session"); VERBS=("starts")
-        return 1
-    fi
+# Decide whether to inject directives this turn
+# SMART INJECTION: Only on Turn 1, post-clear, or directive trigger
+SHOULD_INJECT_DIRECTIVES=false
+if [ "$TURN_NUMBER" -eq 1 ] || [ "$POST_CLEAR_DETECTED" = "true" ] || [ "$DIRECTIVE_TRIGGER_DETECTED" = "true" ]; then
+  SHOULD_INJECT_DIRECTIVES=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
-}
+if [ -n "$EKKOS_API_KEY" ] && [ -n "$USER_QUERY" ]; then
+  # Update phase to RETRIEVE
+  jq -n \
+    --arg phase "retrieve" \
+    --argjson turn "$TURN_NUMBER" \
+    --arg session "$SESSION_ID" \
+    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    '{
+      phase: $phase,
+      turn: $turn,
+      session: $session,
+      timestamp: $timestamp,
+      stats: {
+        retrieved: 0,
+        applied: 0,
+        forged: 0
+      }
+    }' > "$GOLDEN_LOOP_FILE" 2>/dev/null || true
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # PATTERN RETRIEVAL: Always search patterns (they're query-specific)
+  # DIRECTIVE RETRIEVAL: Only if cache is invalid or trigger detected
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  # Build sources array - always include patterns, conditionally include directives
+  if [ "$DIRECTIVE_CACHE_VALID" = "true" ]; then
+    SEARCH_SOURCES='["patterns"]'
+  else
+    SEARCH_SOURCES='["patterns", "directives"]'
+  fi
 
-uuid_to_words() {
-    local uuid="$1"
-    load_session_words
-
-    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]}"
-}
+  # Call ekkOS MCP gateway
+  SEARCH_RESPONSE=$(curl -s -X POST "https://api.ekkos.dev/api/v1/mcp/call" \
+    -H "Authorization: Bearer $EKKOS_API_KEY" \
+    -H "Content-Type: application/json" \
+    --max-time 2 \
+    -d "{\"tool\": \"ekkOS_Search\", \"arguments\": {\"query\": $(echo "$USER_QUERY" | jq -Rs .), \"limit\": 5, \"sources\": $SEARCH_SOURCES}}" 2>/dev/null || echo '{"result": {"results": {"patterns": [], "directives": []}}}')
+
+  # Count patterns retrieved (MCP response: .result.results.patterns)
+  PATTERN_COUNT=$(echo "$SEARCH_RESPONSE" | jq -r '.result.results.patterns | length' 2>/dev/null || echo "0")
+
+  # Update golden loop with retrieved count
+  if [ "$PATTERN_COUNT" -gt 0 ]; then
+    jq -n \
+      --arg phase "inject" \
+      --argjson turn "$TURN_NUMBER" \
+      --arg session "$SESSION_ID" \
+      --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+      --argjson retrieved "$PATTERN_COUNT" \
+      '{
+        phase: $phase,
+        turn: $turn,
+        session: $session,
+        timestamp: $timestamp,
+        stats: {
+          retrieved: $retrieved,
+          applied: 0,
+          forged: 0
+        }
+      }' > "$GOLDEN_LOOP_FILE" 2>/dev/null || true
+
+    # Format patterns for injection (MCP response: .result.results.patterns)
+    RETRIEVED_PATTERNS=$(echo "$SEARCH_RESPONSE" | jq -r '
+      .result.results.patterns[]? |
+      "**\(.title)**\n\(.problem // .guidance // "")\n\n## Solution\n\(.solution // .content // "")\n\nSuccess Rate: \((.success_rate // 0) * 100)%\nApplied: \(.applied_count // 0) times\n"
+    ' 2>/dev/null || echo "")
+  fi
 
-# 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"
+  # ═══════════════════════════════════════════════════════════════════════════
+  # DIRECTIVE HANDLING: Use cache if valid, otherwise process from response
+  # ═══════════════════════════════════════════════════════════════════════════
+  if [ "$DIRECTIVE_CACHE_VALID" = "true" ]; then
+    # Load directives from cache
+    DIRECTIVE_COUNT=$(jq -r '.count // 0' "$DIRECTIVE_CACHE_FILE" 2>/dev/null || echo "0")
+    RETRIEVED_DIRECTIVES=$(jq -r '.formatted // ""' "$DIRECTIVE_CACHE_FILE" 2>/dev/null || echo "")
+  else
+    # Extract and format DIRECTIVES from API response
+    DIRECTIVE_COUNT=$(echo "$SEARCH_RESPONSE" | jq -r '.result.results.directives | length' 2>/dev/null || echo "0")
+
+    if [ "$DIRECTIVE_COUNT" -gt 0 ]; then
+      # Group directives by type for clean display
+      MUST_DIRECTIVES=$(echo "$SEARCH_RESPONSE" | jq -r '.result.results.directives[] | select(.type == "MUST") | "  • \(.rule)"' 2>/dev/null || echo "")
+      NEVER_DIRECTIVES=$(echo "$SEARCH_RESPONSE" | jq -r '.result.results.directives[] | select(.type == "NEVER") | "  • \(.rule)"' 2>/dev/null || echo "")
+      PREFER_DIRECTIVES=$(echo "$SEARCH_RESPONSE" | jq -r '.result.results.directives[] | select(.type == "PREFER") | "  • \(.rule)"' 2>/dev/null || echo "")
+      AVOID_DIRECTIVES=$(echo "$SEARCH_RESPONSE" | jq -r '.result.results.directives[] | select(.type == "AVOID") | "  • \(.rule)"' 2>/dev/null || echo "")
+
+      # Build directive section
+      if [ -n "$MUST_DIRECTIVES" ] || [ -n "$NEVER_DIRECTIVES" ] || [ -n "$PREFER_DIRECTIVES" ] || [ -n "$AVOID_DIRECTIVES" ]; then
+        RETRIEVED_DIRECTIVES="🔴 USER DIRECTIVES (FOLLOW THESE):"
+        [ -n "$MUST_DIRECTIVES" ] && RETRIEVED_DIRECTIVES="$RETRIEVED_DIRECTIVES
+
+MUST:
+$MUST_DIRECTIVES"
+        [ -n "$NEVER_DIRECTIVES" ] && RETRIEVED_DIRECTIVES="$RETRIEVED_DIRECTIVES
+
+NEVER:
+$NEVER_DIRECTIVES"
+        [ -n "$PREFER_DIRECTIVES" ] && RETRIEVED_DIRECTIVES="$RETRIEVED_DIRECTIVES
+
+PREFER:
+$PREFER_DIRECTIVES"
+        [ -n "$AVOID_DIRECTIVES" ] && RETRIEVED_DIRECTIVES="$RETRIEVED_DIRECTIVES
+
+AVOID:
+$AVOID_DIRECTIVES"
+      fi
+
+      # Save to cache for future turns
+      jq -n \
+        --argjson count "$DIRECTIVE_COUNT" \
+        --arg formatted "$RETRIEVED_DIRECTIVES" \
+        --argjson cached_at "$(date +%s)" \
+        '{
+          count: $count,
+          formatted: $formatted,
+          cached_at: $cached_at
+        }' > "$DIRECTIVE_CACHE_FILE" 2>/dev/null || true
     fi
+  fi
 fi
 
+# Context tracking removed - Claude Code handles its own context management
+
 # ═══════════════════════════════════════════════════════════════════════════
-# SINGLE SOURCE OF TRUTH: Update ALL session tracking systems
+# COLORS
 # ═══════════════════════════════════════════════════════════════════════════
-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
-
-    # 4. Multi-session tracking - No jq
-    ACTIVE_SESSIONS_FILE="$HOME/.ekkos/active-sessions.json"
-    node -e "
-const fs = require('fs');
-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
+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'
 
-    # 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({
-    userId: process.argv[1],
-    realSession: process.argv[2],
-    projectPath: process.argv[3],
-    pendingSession: process.argv[4]
-});
-const req = https.request({
-    hostname: 'mcp.ekkos.dev',
-    path: '/proxy/session/bind',
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body)}
-}, () => {});
-req.on('error', () => {});
-req.write(body);
-req.end();
-" "$EKKOS_USER_ID" "$SESSION_NAME" "$PROJECT_ROOT" "$PENDING_SESSION" 2>/dev/null &
-    fi
+CURRENT_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
+
+# Generate session name (arrays and uuid_to_words defined at top of file)
+SESSION_NAME=""
+if [ -n "$SESSION_ID" ] && [ "$SESSION_ID" != "unknown" ] && [ "$SESSION_ID" != "null" ]; then
+  SESSION_NAME=$(uuid_to_words "$SESSION_ID")
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# "/continue" COMMAND: Run AFTER /clear to restore last 5 turns
+# "/continue" COMMAND: Delegated to Skill system (DO NOT INTERCEPT)
+# ═══════════════════════════════════════════════════════════════════════════
+# REMOVED: Hook used to intercept /continue and do simple restoration
+# NOW: Let /continue Skill handle it - supports session names + intelligent narrative
+#
+# Why this changed:
+# - Hook was ignoring session name argument (always used "current")
+# - Hook couldn't provide intelligent narrative briefing
+# - Skill system now has proper name→UUID resolution in API
+#
+# OLD BEHAVIOR (removed):
+# - Hook caught /continue → API call with "current" → exit
+# NEW BEHAVIOR:
+# - /continue groovy-cactus → Skill system → API with session name → intelligent briefing
 # ═══════════════════════════════════════════════════════════════════════════
-QUERY_LOWER=$(echo "$USER_QUERY" | tr '[:upper:]' '[:lower:]')
-
-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")
-
-    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")
-
-    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 "")
-
-    echo ""
-    echo -e "${GREEN}${BOLD}✓ Session continued${RESET} ${DIM}(${RESTORED_COUNT} turns restored)${RESET}"
-    echo ""
-
-    echo "<system-reminder>"
-    echo "═══════════════════════════════════════════════════════════════════════"
-    echo "CONTEXT RESTORED - Resume seamlessly. DO NOT ask 'what were we doing?'"
-    echo "═══════════════════════════════════════════════════════════════════════"
-    echo ""
-    echo "## Last User Request:"
-    echo "$LAST_TASK"
-    echo ""
-    echo "## Your Last Response (truncated):"
-    echo "$LAST_RESPONSE"
-    echo ""
-
-    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}| ${CURRENT_TIME}${RESET}"
-    exit 0
-  fi
-fi
+# Note: Session name is shown in status line for easy reference:
+# Example: "🧠 ekkOS Memory | Turn 42 | groovy-cactus | 2026-01-12 09:40 AM EST"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# COMPACTION DETECTION: If context dropped dramatically, auto-restore
-# Was >50% last turn, now <15% = compaction happened
+# AUTO-RESTORE REMOVED: Manual /continue only (saves 79% token burn!)
+# ═══════════════════════════════════════════════════════════════════════════
+# WHY REMOVED:
+# - Auto-restore burns 5,000 tokens per turn (250K tokens over 50 turns)
+# - Manual /continue: 2,000 tokens once + clean slate (52K total = 79% savings!)
+# - Manual /continue is 10x more powerful (Bash + multi-source + narrative)
+# - User has control (can choose session, can skip if starting fresh)
+# - Explicit > implicit (user knows exactly what's happening)
+#
+# OLD BEHAVIOR (removed):
+# - Compaction detection → auto-inject 10 turns
+# - Post-clear detection → auto-inject 10 turns
+# NEW BEHAVIOR:
+# - User types: /continue groovy-cactus
+# - Skill runs with full Bash power + intelligent narrative
 # ═══════════════════════════════════════════════════════════════════════════
-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 -e "${MAGENTA}${BOLD}## Recent Context (auto-restored)${RESET}"
-    echo ""
-
-    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 -e "${DIM}Full history: \"turns 1-${TURN_NUMBER}\" or \"recall yesterday\"${RESET}"
-  fi
+# Simple status line - no context warnings, Claude handles its own context
+echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
 
+# Output skill reminder if detected
+if [ -n "$SKILL_REMINDER" ]; then
   echo ""
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${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 -e "${MAGENTA}${BOLD}$SKILL_REMINDER${RESET}"
+fi
 
+# 💉 GOLDEN LOOP: INJECT PHASE - Inject directives FIRST (highest priority)
+# SMART INJECTION: Only on Turn 1, post-clear, or directive trigger
+if [ "$SHOULD_INJECT_DIRECTIVES" = "true" ] && [ -n "$RETRIEVED_DIRECTIVES" ] && [ "$DIRECTIVE_COUNT" -gt 0 ]; then
   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 "$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 "<system-reminder>"
+  echo -e "$RETRIEVED_DIRECTIVES"
+  echo "</system-reminder>"
+fi
 
+# 💉 GOLDEN LOOP: INJECT PHASE - Inject retrieved patterns into context
+if [ -n "$RETRIEVED_PATTERNS" ] && [ "$PATTERN_COUNT" -gt 0 ]; then
   echo ""
-  echo -e "${DIM}Full history: \"recall\" or \"turns 1-${TURN_NUMBER}\"${RESET}"
-  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+  echo "<system-reminder>"
+  echo "🔍 RETRIEVED PATTERNS FROM ekkOS MEMORY ($PATTERN_COUNT patterns found)"
   echo ""
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
-
-elif [ "$TOKEN_PERCENT" -ge 50 ]; then
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ~${IPC_PERCENT:-0}% IPC | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
-
-else
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
+  echo -e "$RETRIEVED_PATTERNS"
+  echo ""
+  echo "These patterns were automatically retrieved based on your query. Review and apply relevant solutions."
+  echo "</system-reminder>"
+  echo ""
+  echo "🔴 MANDATORY PATTERN ACKNOWLEDGMENT (PatternGuard):"
+  echo "You MUST acknowledge ALL $PATTERN_COUNT patterns above - either SELECT or SKIP each one."
+  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 ""
+  echo "For patterns NOT relevant:"
+  echo "[ekkOS_SKIP]"
+  echo "- id: <pattern_id>"
+  echo "  reason: <1-line why not relevant>"
+  echo "[/ekkOS_SKIP]"
+  echo ""
+  echo "⚡ AUTOMATIC APPLICATION: When pattern matches your task, APPLY IT immediately without asking."
+  echo "Track outcome after: ekkOS_Outcome({success: true/false})"
+  echo ""
+  echo "100% coverage required. This is how the system learns what works."
 fi
 
-# Output skill reminder if detected
-if [ -n "$SKILL_REMINDER" ]; then
+# Inject footer format reminder (helps Claude remember session name)
+if [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "unknown-session" ]; then
   echo ""
-  echo -e "${MAGENTA}${BOLD}$SKILL_REMINDER${RESET}"
+  echo "<footer-format>End responses with: Claude Code ({Model}) · 🧠 **ekkOS_™** · Turn ${TURN_NUMBER} · ${SESSION_NAME} · 📅 ${CURRENT_TIME}</footer-format>"
 fi
 
 exit 0