@ekkos/cli 1.0.35 → 1.1.0

package/templates/hooks/assistant-response.sh

@@ -1,6 +1,14 @@
 #!/bin/bash
-# Post-response hook: Validates and enforces ekkOS footer format
+# ═══════════════════════════════════════════════════════════════════════════
+# ekkOS_ Hook: AssistantResponse - Validates and enforces footer format
+# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
+# EKKOS_MANAGED=1
+# ═══════════════════════════════════════════════════════════════════════════
 # 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"
@@ -10,87 +18,143 @@ if [[ ! -f "$RESPONSE_FILE" ]]; then
   exit 0
 fi
 
-# 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)"')
+# ═══════════════════════════════════════════════════════════════════════════
+# 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
+}
 
-# Convert session UUID to word-based name
 convert_uuid_to_name() {
-  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]}"
+    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]}"
 }
 
 SESSION_NAME=$(convert_uuid_to_name "$SESSION_ID")
-TIMESTAMP=$(date "+%Y-%m-%d %I:%M %p %Z")
+TIMESTAMP=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
 
 # Required footer format
 REQUIRED_FOOTER="---
-$MODEL · $SESSION_NAME · Turn $TURN · ${CONTEXT_PERCENT}% · 🧠 **ekkOS_™** · 📅 $TIMESTAMP"
+$MODEL · 🧠 ekkOS_™ · $SESSION_NAME · 📅 $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" == *"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"
+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
     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

@@ -2,20 +2,38 @@
   "hooks": {
     "SessionStart": [
       {
-        "type": "command",
-        "command": "bash .claude/hooks/session-start.sh"
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/session-start.sh",
+            "timeout": 5000
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [
       {
-        "type": "command",
-        "command": "bash .claude/hooks/user-prompt-submit.sh"
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/user-prompt-submit.sh",
+            "timeout": 5000
+          }
+        ]
       }
     ],
     "Stop": [
       {
-        "type": "command",
-        "command": "bash .claude/hooks/stop.sh"
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/stop.sh",
+            "timeout": 5000
+          }
+        ]
       }
     ]
   }

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:-0}
+  "ekkos_strict": ${EKKOS_STRICT:-1}
 }
 EOF
 
@@ -134,7 +134,7 @@ cleanup_turn_contract() {
 
 # Check if strict mode is enabled
 is_strict_mode() {
-  [ "${EKKOS_STRICT:-0}" = "1" ]
+  [ "${EKKOS_STRICT:-1}" = "1" ]  # DEFAULT: ON
 }
 
 # Generate strict mode blocker message for Claude Code
@@ -157,50 +157,57 @@ 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
-  local total_count
-  total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -c '.' || echo 0)
+  # 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
 
   if [ "$total_count" -eq 0 ]; then
     echo "100"  # No patterns = 100% coverage by definition
     return 0
   fi
 
-  # Extract acknowledged IDs from [ekkOS_SELECT] and [ekkOS_SKIP] blocks
+  # Extract acknowledged IDs using portable awk (works on macOS and Linux)
   local acknowledged_count=0
 
-  # 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
+  # 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))
 
   # 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\]' || echo 0)
-    acknowledged_count=$apply_count
+    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' 2>/dev/null || echo 0)
+    acknowledged_count=$((acknowledged_count + apply_count))
   fi
 
   # Calculate coverage percentage
-  local coverage
-  coverage=$((acknowledged_count * 100 / total_count))
+  local coverage=0
+  if [ "$total_count" -gt 0 ]; then
+    coverage=$((acknowledged_count * 100 / total_count))
+  fi
 
   # Cap at 100%
   if [ "$coverage" -gt 100 ]; then
@@ -255,11 +262,16 @@ EOF
 }
 
 # Determine if turn is compliant
+# ROBUST: Handles edge cases with non-numeric or empty values
 is_turn_compliant() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local pattern_count="$4"
+  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")
 
   # Retrieval must have succeeded
   if [ "$retrieval_ok" != "true" ]; then

package/templates/hooks/lib/state.sh

@@ -20,25 +20,40 @@ mkdir -p "$STATE_DIR"
 # State File Management
 # ═══════════════════════════════════════════════════════════════════════════
 
-# Save patterns for session
+# Save patterns for session (with retrieval_token for verified tracking)
 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"
@@ -57,6 +72,43 @@ 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
 # ═══════════════════════════════════════════════════════════════════════════