@ekkos/cli 1.0.33 → 1.0.35

package/templates/hooks/assistant-response.sh

@@ -1,14 +1,6 @@
 #!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: AssistantResponse - Validates and enforces footer format
-# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
-# EKKOS_MANAGED=1
-# ═══════════════════════════════════════════════════════════════════════════
+# Post-response hook: Validates and enforces ekkOS footer format
 # Runs AFTER assistant response, checks footer compliance
-# Per spec v1.2 Addendum: NO jq, NO hardcoded arrays
-# ═══════════════════════════════════════════════════════════════════════════
-
-set +e
 
 RESPONSE_FILE="$1"
 HOOK_ENV="$2"
@@ -18,143 +10,87 @@ if [[ ! -f "$RESPONSE_FILE" ]]; then
   exit 0
 fi
 
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
-# ═══════════════════════════════════════════════════════════════════════════
-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"
-
-# Parse metadata from hook environment using Node (no jq)
-parse_hook_env() {
-    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 ""
-}
-
-SESSION_ID=$(parse_hook_env "$HOOK_ENV" '.sessionId')
-[ -z "$SESSION_ID" ] && SESSION_ID="unknown"
-
-MODEL=$(parse_hook_env "$HOOK_ENV" '.model')
-[ -z "$MODEL" ] && MODEL="Claude Code (Opus 4.5)"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Session name conversion - Uses external session-words.json (NO hardcoded arrays)
-# ═══════════════════════════════════════════════════════════════════════════
-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"
-    if [ ! -f "$words_file" ]; then
-        words_file="$SESSION_WORDS_DEFAULT"
-    fi
-
-    if [ ! -f "$words_file" ] || [ ! -f "$JSON_PARSE_HELPER" ]; then
-        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
-
-        if [ ${#ADJECTIVES[@]} -gt 0 ] && [ ${#NOUNS[@]} -gt 0 ] && [ ${#VERBS[@]} -gt 0 ]; then
-            SESSION_WORDS_LOADED=true
-            return 0
-        fi
-    fi
-    return 1
-}
+# Parse metadata from hook environment
+SESSION_ID=$(echo "$HOOK_ENV" | jq -r '.sessionId // "unknown"')
+TURN=$(echo "$HOOK_ENV" | jq -r '.turn // 0')
+CONTEXT_PERCENT=$(echo "$HOOK_ENV" | jq -r '.contextUsagePercent // 0')
+MODEL=$(echo "$HOOK_ENV" | jq -r '.model // "Claude Code (Opus 4.5)"')
 
+# Convert session UUID to word-based name
 convert_uuid_to_name() {
-    local uuid="$1"
-
-    load_session_words || {
-        echo "unknown-session"
-        return
-    }
-
-    local hex="${uuid//-/}"
-    hex="${hex:0:12}"
-
-    if [[ ! "$hex" =~ ^[0-9a-fA-F]+$ ]]; then
-        echo "unknown-session"
-        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]}"
+  local uuid="$1"
+
+  # Word lists (same as MCP)
+  local 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")
+
+  local 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" "orbit" "parrot" "quest"
+    "rapids" "summit" "tunnel" "umbrella" "volcano" "whisper" "xylophone" "yacht"
+    "zephyr" "acorn" "bobcat" "cactus" "dolphin" "eagle" "ferret" "gopher"
+    "hedgehog" "iguana" "jackal" "koala")
+
+  # Extract first 8 hex chars
+  local hex="${uuid:0:8}"
+  hex="${hex//-/}"
+
+  # Convert to number
+  local num=$((16#$hex))
+
+  # Calculate indices
+  local adj_idx=$((num % 100))
+  local noun_idx=$(((num / 100) % 100))
+
+  echo "${ADJECTIVES[$adj_idx]}-${NOUNS[$noun_idx]}"
 }
 
 SESSION_NAME=$(convert_uuid_to_name "$SESSION_ID")
-TIMESTAMP=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
+TIMESTAMP=$(date "+%Y-%m-%d %I:%M %p %Z")
 
 # Required footer format
 REQUIRED_FOOTER="---
-$MODEL · 🧠 ekkOS_™ · $SESSION_NAME · 📅 $TIMESTAMP"
+$MODEL · $SESSION_NAME · Turn $TURN · ${CONTEXT_PERCENT}% · 🧠 **ekkOS_™** · 📅 $TIMESTAMP"
 
 # Check if response has correct footer
 RESPONSE_CONTENT=$(cat "$RESPONSE_FILE")
 LAST_LINE=$(echo "$RESPONSE_CONTENT" | tail -1)
 
 # Check if footer exists and is correct
-if [[ "$LAST_LINE" == *"ekkOS"* ]] && [[ "$LAST_LINE" == *"$SESSION_NAME"* ]]; then
-    # Footer exists - validate format
-    if [[ "$LAST_LINE" == *"$SESSION_NAME"* ]] && [[ "$LAST_LINE" == *"📅"* ]]; then
-        # Footer is correct
-        exit 0
-    else
-        # Footer exists but is malformed - replace it
-        RESPONSE_WITHOUT_FOOTER=$(echo "$RESPONSE_CONTENT" | head -n -2)
-        echo "$RESPONSE_WITHOUT_FOOTER" > "$RESPONSE_FILE"
-        echo "" >> "$RESPONSE_FILE"
-        echo "$REQUIRED_FOOTER" >> "$RESPONSE_FILE"
-    fi
-else
-    # Footer missing - append it
+if [[ "$LAST_LINE" == *"ekkOS"* ]] && [[ "$LAST_LINE" == *"Turn"* ]]; then
+  # Footer exists - validate format
+  if [[ "$LAST_LINE" == *"Turn $TURN"* ]] && [[ "$LAST_LINE" == *"${CONTEXT_PERCENT}%"* ]] && [[ "$LAST_LINE" == *"$SESSION_NAME"* ]]; then
+    # Footer is correct
+    exit 0
+  else
+    # Footer exists but is malformed - replace it
+    RESPONSE_WITHOUT_FOOTER=$(echo "$RESPONSE_CONTENT" | head -n -2)  # Remove last 2 lines (--- and footer)
+    echo "$RESPONSE_WITHOUT_FOOTER" > "$RESPONSE_FILE"
     echo "" >> "$RESPONSE_FILE"
     echo "$REQUIRED_FOOTER" >> "$RESPONSE_FILE"
+  fi
+else
+  # Footer missing - append it
+  echo "" >> "$RESPONSE_FILE"
+  echo "$REQUIRED_FOOTER" >> "$RESPONSE_FILE"
 fi
 
 exit 0

package/templates/hooks/hooks.json

@@ -17,12 +17,6 @@
         "type": "command",
         "command": "bash .claude/hooks/stop.sh"
       }
-    ],
-    "AssistantResponse": [
-      {
-        "type": "command",
-        "command": "bash .claude/hooks/assistant-response.sh"
-      }
     ]
   }
 }

package/templates/hooks/lib/contract.sh

@@ -78,7 +78,7 @@ write_turn_contract() {
   "retrieved_directive_ids": $directive_array,
   "timestamp": "$timestamp",
   "query_hash": "$query_hash",
-  "ekkos_strict": ${EKKOS_STRICT:-1}
+  "ekkos_strict": ${EKKOS_STRICT:-0}
 }
 EOF
 
@@ -134,7 +134,7 @@ cleanup_turn_contract() {
 
 # Check if strict mode is enabled
 is_strict_mode() {
-  [ "${EKKOS_STRICT:-1}" = "1" ]  # DEFAULT: ON
+  [ "${EKKOS_STRICT:-0}" = "1" ]
 }
 
 # Generate strict mode blocker message for Claude Code
@@ -157,57 +157,50 @@ EOF
 }
 
 # Validate PatternGuard coverage (returns 0-100)
-# PORTABLE: Works on macOS without Perl regex (grep -P)
 calculate_pattern_guard_coverage() {
   local assistant_response="$1"
   local pattern_ids="$2"  # Comma-separated
 
-  # Count total patterns - more robust counting
-  local total_count=0
-  if [ -n "$pattern_ids" ]; then
-    total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -v '^$' | wc -l | tr -d ' ')
-  fi
+  # Count total patterns
+  local total_count
+  total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -c '.' || echo 0)
 
   if [ "$total_count" -eq 0 ]; then
     echo "100"  # No patterns = 100% coverage by definition
     return 0
   fi
 
-  # Extract acknowledged IDs using portable awk (works on macOS and Linux)
+  # Extract acknowledged IDs from [ekkOS_SELECT] and [ekkOS_SKIP] blocks
   local acknowledged_count=0
 
-  # Use awk to extract SELECT block and count IDs - PORTABLE approach
-  local select_count=0
-  select_count=$(echo "$assistant_response" | awk '
-    /\[ekkOS_SELECT\]/{in_block=1; next}
-    /\[\/ekkOS_SELECT\]/{in_block=0}
-    in_block && /id:/{count++}
-    END{print count+0}
-  ')
-  acknowledged_count=$((acknowledged_count + select_count))
-
-  # Use awk to extract SKIP block and count IDs
-  local skip_count=0
-  skip_count=$(echo "$assistant_response" | awk '
-    /\[ekkOS_SKIP\]/{in_block=1; next}
-    /\[\/ekkOS_SKIP\]/{in_block=0}
-    in_block && /id:/{count++}
-    END{print count+0}
-  ')
-  acknowledged_count=$((acknowledged_count + skip_count))
+  # Check SELECT block
+  local select_block
+  select_block=$(echo "$assistant_response" | grep -ozP '\[ekkOS_SELECT\][\s\S]*?\[/ekkOS_SELECT\]' 2>/dev/null | tr '\0' '\n' || true)
+  if [ -n "$select_block" ]; then
+    local select_count
+    select_count=$(echo "$select_block" | grep -oE 'id:\s*[a-f0-9-]+' | wc -l | tr -d ' ')
+    acknowledged_count=$((acknowledged_count + select_count))
+  fi
+
+  # Check SKIP block
+  local skip_block
+  skip_block=$(echo "$assistant_response" | grep -ozP '\[ekkOS_SKIP\][\s\S]*?\[/ekkOS_SKIP\]' 2>/dev/null | tr '\0' '\n' || true)
+  if [ -n "$skip_block" ]; then
+    local skip_count
+    skip_count=$(echo "$skip_block" | grep -oE 'id:\s*[a-f0-9-]+' | wc -l | tr -d ' ')
+    acknowledged_count=$((acknowledged_count + skip_count))
+  fi
 
   # Legacy: Check for [ekkOS_APPLY] markers (fallback)
   if [ "$acknowledged_count" -eq 0 ]; then
     local apply_count
-    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' 2>/dev/null || echo 0)
-    acknowledged_count=$((acknowledged_count + apply_count))
+    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' || echo 0)
+    acknowledged_count=$apply_count
   fi
 
   # Calculate coverage percentage
-  local coverage=0
-  if [ "$total_count" -gt 0 ]; then
-    coverage=$((acknowledged_count * 100 / total_count))
-  fi
+  local coverage
+  coverage=$((acknowledged_count * 100 / total_count))
 
   # Cap at 100%
   if [ "$coverage" -gt 100 ]; then
@@ -262,16 +255,11 @@ EOF
 }
 
 # Determine if turn is compliant
-# ROBUST: Handles edge cases with non-numeric or empty values
 is_turn_compliant() {
-  local retrieval_ok="${1:-true}"
-  local pattern_guard_coverage="${2:-100}"
-  local footer_present="${3:-true}"
-  local pattern_count="${4:-0}"
-
-  # Sanitize numeric values (default to safe values)
-  pattern_guard_coverage=$(echo "$pattern_guard_coverage" | grep -oE '^[0-9]+$' || echo "100")
-  pattern_count=$(echo "$pattern_count" | grep -oE '^[0-9]+$' || echo "0")
+  local retrieval_ok="$1"
+  local pattern_guard_coverage="$2"
+  local footer_present="$3"
+  local pattern_count="$4"
 
   # Retrieval must have succeeded
   if [ "$retrieval_ok" != "true" ]; then

package/templates/hooks/lib/state.sh

@@ -20,40 +20,25 @@ mkdir -p "$STATE_DIR"
 # State File Management
 # ═══════════════════════════════════════════════════════════════════════════
 
-# Save patterns for session (with retrieval_token for verified tracking)
+# Save patterns for session
 save_patterns() {
   local session_id="$1"
   local patterns="$2"
   local model_used="$3"
-  local retrieval_token="${4:-}"  # Optional retrieval_token for verified applications
 
   local state_file="$STATE_DIR/patterns-${session_id}.json"
 
   jq -n \
     --argjson patterns "$patterns" \
     --arg model "$model_used" \
-    --arg token "$retrieval_token" \
     --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
     '{
       patterns: $patterns,
       model_used: $model,
-      retrieval_token: $token,
       saved_at: $timestamp
     }' > "$state_file"
 }
 
-# Get retrieval token from saved patterns
-get_retrieval_token() {
-  local session_id="$1"
-  local state_file="$STATE_DIR/patterns-${session_id}.json"
-
-  if [ -f "$state_file" ]; then
-    jq -r '.retrieval_token // ""' "$state_file" 2>/dev/null
-  else
-    echo ""
-  fi
-}
-
 # Load patterns for session
 load_patterns() {
   local session_id="$1"
@@ -72,43 +57,6 @@ clear_patterns() {
   rm -f "$STATE_DIR/patterns-${session_id}.json"
 }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Conversation Context (for Golden Loop MEASURE phase)
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Save current conversation context for pattern tracking
-# Called by user-prompt-submit.sh when new query is submitted
-save_conversation_context() {
-  local session_id="$1"
-  local user_query="$2"
-  local prev_response="$3"
-
-  local context_file="$STATE_DIR/conversation-${session_id}.json"
-
-  jq -n \
-    --arg query "$user_query" \
-    --arg response "$prev_response" \
-    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    '{
-      query: $query,
-      response: $response,
-      saved_at: $timestamp
-    }' > "$context_file" 2>/dev/null || true
-}
-
-# Load current conversation context
-# Called by post-tool-use.sh when tracking pattern applications
-load_conversation_context() {
-  local session_id="$1"
-  local context_file="$STATE_DIR/conversation-${session_id}.json"
-
-  if [ -f "$context_file" ]; then
-    cat "$context_file"
-  else
-    echo '{"query":"","response":""}'
-  fi
-}
-
 # ═══════════════════════════════════════════════════════════════════════════
 # Capture Deduplication
 # ═══════════════════════════════════════════════════════════════════════════