@ekkos/cli 1.2.18 → 1.3.0

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

@@ -1,516 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: UserPromptSubmit - SEAMLESS CONTEXT CONTINUITY
-# ═══════════════════════════════════════════════════════════════════════════
-# ZERO USER ACTION NEEDED:
-# 1. Tracks turn number and context size
-# 2. Detects when compaction happened (context dropped from high to low)
-# 3. AUTO-INJECTS restored context - user just keeps working
-# ═══════════════════════════════════════════════════════════════════════════
-
-set +e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY MODE DETECTION
-# ═══════════════════════════════════════════════════════════════════════════
-PROXY_MODE=false
-if [[ "$ANTHROPIC_BASE_URL" == *"proxy.ekkos.dev"* ]]; then
-  PROXY_MODE=true
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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"
-SESSION_WORDS_DEFAULT="$EKKOS_CONFIG_DIR/.defaults/session-words.json"
-JSON_PARSE_HELPER="$EKKOS_CONFIG_DIR/.helpers/json-parse.cjs"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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 ""
-}
-
-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')
-
-[ -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)
-  fi
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY MODE: Slim hook path (cosmetic output + local state only)
-# ═══════════════════════════════════════════════════════════════════════════
-if [ "$PROXY_MODE" = "true" ]; then
-  SESSION_ID="$RAW_SESSION_ID"
-  UUID_REGEX='^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
-  SESSION_NAME="$SESSION_ID"
-
-  if [[ "$SESSION_ID" =~ $UUID_REGEX ]] && [ -f "$JSON_PARSE_HELPER" ]; then
-    SESSION_NAME=$(node -e "
-const fs = require('fs');
-const sid = process.argv[1] || '';
-const wordsFile = process.argv[2];
-const fallbackFile = process.argv[3];
-const helper = process.argv[4];
-let wordsPath = wordsFile;
-if (!fs.existsSync(wordsPath)) wordsPath = fallbackFile;
-if (!fs.existsSync(wordsPath) || !fs.existsSync(helper)) {
-  console.log(sid || 'unknown-session');
-  process.exit(0);
-}
-const cp = require('child_process');
-function readList(path) {
-  const out = cp.spawnSync('node', [helper, wordsPath, path], { encoding: 'utf8' });
-  if (out.status !== 0) return [];
-  return (out.stdout || '').split('\\n').map(s => s.trim()).filter(Boolean);
-}
-const adjectives = readList('.adjectives');
-const nouns = readList('.nouns');
-const verbs = readList('.verbs');
-if (!adjectives.length || !nouns.length || !verbs.length) {
-  console.log(sid);
-  process.exit(0);
-}
-const hex = sid.replace(/-/g, '').slice(0, 12);
-if (!/^[0-9a-fA-F]{12}$/.test(hex)) {
-  console.log(sid);
-  process.exit(0);
-}
-const adj = parseInt(hex.slice(0, 4), 16) % adjectives.length;
-const noun = parseInt(hex.slice(4, 8), 16) % nouns.length;
-const verb = parseInt(hex.slice(8, 12), 16) % verbs.length;
-console.log(adjectives[adj] + '-' + nouns[noun] + '-' + verbs[verb]);
-" "$SESSION_ID" "$SESSION_WORDS_JSON" "$SESSION_WORDS_DEFAULT" "$JSON_PARSE_HELPER" 2>/dev/null || echo "$SESSION_ID")
-  fi
-
-  TIMESTAMP_UTC=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-  DISPLAY_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
-  mkdir -p "$HOME/.ekkos" "$HOME/.claude/state" 2>/dev/null || true
-  echo "{\"session_id\":\"$SESSION_ID\",\"session_name\":\"$SESSION_NAME\",\"project\":\"$PROJECT_ROOT\",\"timestamp\":\"$TIMESTAMP_UTC\"}" > "$HOME/.ekkos/current-session.json" 2>/dev/null || true
-  echo "{\"session_id\":\"$SESSION_ID\",\"session_name\":\"$SESSION_NAME\",\"timestamp\":\"$TIMESTAMP_UTC\"}" > "$HOME/.claude/state/current-session.json" 2>/dev/null || true
-
-  ACTIVE_SESSIONS_FILE="$HOME/.ekkos/active-sessions.json"
-  node -e "
-const fs = require('fs');
-const file = process.argv[1];
-const sid = process.argv[2];
-const sname = process.argv[3];
-const ts = process.argv[4];
-const project = process.argv[5];
-let sessions = [];
-try {
-  if (fs.existsSync(file)) {
-    sessions = JSON.parse(fs.readFileSync(file, 'utf8') || '[]');
-  }
-} catch {}
-const index = sessions.findIndex(s => s.sessionId === sid);
-if (index >= 0) {
-  sessions[index] = { ...sessions[index], sessionName: sname, projectPath: project, lastHeartbeat: ts };
-} else {
-  sessions.push({ sessionId: sid, sessionName: sname, projectPath: project, startedAt: ts, lastHeartbeat: ts, pid: 0 });
-}
-fs.writeFileSync(file, JSON.stringify(sessions, null, 2));
-" "$ACTIVE_SESSIONS_FILE" "$SESSION_ID" "$SESSION_NAME" "$TIMESTAMP_UTC" "$PROJECT_ROOT" 2>/dev/null || true
-
-  # Dashboard/local tooling hint file
-  echo "{\"sessionName\":\"$SESSION_NAME\",\"sessionId\":\"$SESSION_ID\",\"projectPath\":\"$PROJECT_ROOT\",\"ts\":$(date +%s)000}" > "$HOME/.ekkos/hook-session-hint.json" 2>/dev/null || true
-
-  CYAN='\033[0;36m'
-  DIM='\033[2m'
-  BOLD='\033[1m'
-  RESET='\033[0m'
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${DISPLAY_TIME}${RESET}"
-  exit 0
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# SKILL AUTO-FIRE: Detect keywords and inject skill reminders
-# ═══════════════════════════════════════════════════════════════════════════
-SKILL_REMINDER=""
-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"
-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"
-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"
-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"
-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"
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Load auth - No jq
-# ═══════════════════════════════════════════════════════════════════════════
-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
-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
-# ═══════════════════════════════════════════════════════════════════════════
-STATE_DIR="$PROJECT_ROOT/.claude/state"
-mkdir -p "$STATE_DIR" 2>/dev/null || true
-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
-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"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Turn counter - PROJECT-LOCAL storage
-# ═══════════════════════════════════════════════════════════════════════════
-PROJECT_SESSION_DIR="$STATE_DIR/sessions"
-mkdir -p "$PROJECT_SESSION_DIR" 2>/dev/null || true
-TURN_COUNTER_FILE="$PROJECT_SESSION_DIR/${SESSION_ID}.turn"
-
-# 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
-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")
-POST_CLEAR_DETECTED=false
-
-if [ "$SAVED_TURN_COUNT" -gt "$TURN_NUMBER" ]; then
-  POST_CLEAR_DETECTED=true
-  TURN_NUMBER=$((SAVED_TURN_COUNT + 1))
-fi
-
-echo "$TURN_NUMBER" > "$TURN_COUNTER_FILE"
-
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# COLORS
-# ═══════════════════════════════════════════════════════════════════════════
-CYAN='\033[0;36m'
-GREEN='\033[0;32m'
-MAGENTA='\033[0;35m'
-DIM='\033[2m'
-BOLD='\033[1m'
-RESET='\033[0m'
-
-CURRENT_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
-
-# ═══════════════════════════════════════════════════════════════════════════
-# WORD-BASED SESSION NAMES - No jq, uses ~/.ekkos/ config (works in ANY project)
-# ═══════════════════════════════════════════════════════════════════════════
-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"
-    [ ! -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
-
-    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
-
-    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]}"
-}
-
-# 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
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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
-
-    # 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
-
-    # Session binding removed — proxy now self-resolves _pending → word-based
-    # names inline via uuidToSessionName(). No external bind call needed.
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# "/continue" COMMAND: Run AFTER /clear to restore last 5 turns
-# ═══════════════════════════════════════════════════════════════════════════
-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
-
-if [ "$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 "$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}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
-
-else
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
-fi
-
-# Output skill reminder if detected
-if [ -n "$SKILL_REMINDER" ]; then
-  echo ""
-  echo -e "${MAGENTA}${BOLD}$SKILL_REMINDER${RESET}"
-fi
-
-exit 0

package/templates/project-stubs/session-start.ps1

@@ -1,63 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS Project Hook Stub: session-start.ps1
-# EKKOS_MANAGED=1
-# EKKOS_MANIFEST_SHA256=project-stub-v1
-# EKKOS_TEMPLATE_VERSION=1.0.0
-#
-# This is a DELEGATING STUB that:
-# 1. Executes the global hook first
-# 2. Then loads project-specific overrides if present
-#
-# Do not modify this file directly. Customizations go in:
-#   <project>\.ekkos\hooks.local.ps1
-# ═══════════════════════════════════════════════════════════════════════════
-
-$ErrorActionPreference = 'Stop'
-
-# ═══════════════════════════════════════════════════════════════════════════
-# RESOLVE PATHS
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Get absolute path to this stub
-$StubPath = $PSScriptRoot
-$StubFile = $MyInvocation.MyCommand.Path
-
-# Project root is two levels up from .claude\hooks\
-$ProjectRoot = (Get-Item "$StubPath\..\..").FullName
-
-# Global hooks directory
-$GlobalHooksDir = Join-Path $env:USERPROFILE ".claude\hooks"
-
-# Global hook path
-$GlobalHook = Join-Path $GlobalHooksDir "session-start.ps1"
-
-# Project override file
-$ProjectOverride = Join-Path $ProjectRoot ".ekkos\hooks.local.ps1"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# EXECUTE GLOBAL HOOK
-# ═══════════════════════════════════════════════════════════════════════════
-
-if (Test-Path $GlobalHook) {
-    try {
-        # Dot-source the global hook (inherits all env vars and args)
-        . $GlobalHook
-    } catch {
-        Write-Error "[ekkOS] Error executing global hook: $_"
-    }
-} else {
-    Write-Warning "[ekkOS] Global hook not found: $GlobalHook"
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# LOAD PROJECT OVERRIDES (optional)
-# ═══════════════════════════════════════════════════════════════════════════
-
-if (Test-Path $ProjectOverride) {
-    try {
-        # Dot-source project-specific customizations
-        . $ProjectOverride
-    } catch {
-        Write-Warning "[ekkOS] Error loading project override: $_"
-    }
-}

package/templates/project-stubs/session-start.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS Project Hook Stub: session-start.sh
-# EKKOS_MANAGED=1
-# EKKOS_MANIFEST_SHA256=project-stub-v1
-# EKKOS_TEMPLATE_VERSION=1.0.0
-#
-# This is a DELEGATING STUB that:
-# 1. Executes the global hook first
-# 2. Then loads project-specific overrides if present
-#
-# Do not modify this file directly. Customizations go in:
-#   <project>/.ekkos/hooks.local.sh
-# ═══════════════════════════════════════════════════════════════════════════
-set -euo pipefail
-
-# ═══════════════════════════════════════════════════════════════════════════
-# RESOLVE PATHS
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Get absolute path to this stub
-STUB_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/$(basename "${BASH_SOURCE[0]}")"
-
-# Project root is two levels up from .claude/hooks/
-PROJECT_ROOT="$(cd "$(dirname "$STUB_PATH")/../.." && pwd)"
-
-# Global hooks directory
-GLOBAL_HOOKS_DIR="$HOME/.claude/hooks"
-
-# Global hook path
-GLOBAL_HOOK="$GLOBAL_HOOKS_DIR/session-start.sh"
-
-# Project override file
-PROJECT_OVERRIDE="$PROJECT_ROOT/.ekkos/hooks.local.sh"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# EXECUTE GLOBAL HOOK
-# ═══════════════════════════════════════════════════════════════════════════
-
-if [ -f "$GLOBAL_HOOK" ] && [ -x "$GLOBAL_HOOK" ]; then
-    # Source the global hook (inherits all env vars and args)
-    source "$GLOBAL_HOOK"
-else
-    echo "[ekkOS] Warning: Global hook not found: $GLOBAL_HOOK" >&2
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# LOAD PROJECT OVERRIDES (optional)
-# ═══════════════════════════════════════════════════════════════════════════
-
-if [ -f "$PROJECT_OVERRIDE" ]; then
-    # Source project-specific customizations
-    # These can override functions or add project-specific behavior
-    source "$PROJECT_OVERRIDE"
-fi