@ekkos/cli 0.2.0

package/templates/cursor-hooks/lib/contract.sh

@@ -0,0 +1,320 @@
+#!/bin/bash
+# ═══════════════════════════════════════════════════════════════════════════
+# ekkOS_ Turn Contract Library
+#
+# Shared functions for Golden Loop compliance enforcement.
+# Used by BOTH Claude Code (.claude/) and Cursor (.cursor/) hooks.
+#
+# TURN CONTRACT: Evidence that retrieval occurred before answering.
+# This is the SINGLE SOURCE OF TRUTH for compliance auditing.
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Get contract directory based on environment
+get_contract_dir() {
+  local source="${1:-claude-code}"
+  local project_root="${2:-$PROJECT_ROOT}"
+
+  if [ "$source" = "cursor" ]; then
+    echo "$project_root/.cursor/state/ekkos"
+  else
+    echo "$project_root/.claude/state/ekkos"
+  fi
+}
+
+# Generate stable hash of user prompt (for deduplication)
+generate_query_hash() {
+  local query="$1"
+  # Use md5 on macOS, md5sum on Linux
+  if command -v md5 >/dev/null 2>&1; then
+    echo -n "$query" | md5 | cut -c1-16
+  elif command -v md5sum >/dev/null 2>&1; then
+    echo -n "$query" | md5sum | cut -c1-16
+  else
+    # Fallback: simple hash using cksum
+    echo -n "$query" | cksum | cut -d' ' -f1
+  fi
+}
+
+# Write turn contract at RETRIEVAL time
+# This is the EVIDENCE that retrieval happened before answering
+write_turn_contract() {
+  local session_id="$1"
+  local retrieval_ok="$2"
+  local retrieval_source="$3"
+  local pattern_ids="$4"      # Comma-separated list
+  local directive_ids="$5"    # Comma-separated list
+  local query_hash="$6"
+  local project_root="${7:-$PROJECT_ROOT}"
+
+  local contract_dir
+  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
+  mkdir -p "$contract_dir" 2>/dev/null || return 1
+
+  local contract_file="$contract_dir/turn-contract-${session_id}.json"
+  local timestamp
+  timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+  # Convert comma-separated IDs to JSON array
+  local pattern_array
+  local directive_array
+  if [ -n "$pattern_ids" ]; then
+    pattern_array=$(echo "$pattern_ids" | tr ',' '\n' | grep -v '^$' | jq -R . | jq -s .)
+  else
+    pattern_array="[]"
+  fi
+  if [ -n "$directive_ids" ]; then
+    directive_array=$(echo "$directive_ids" | tr ',' '\n' | grep -v '^$' | jq -R . | jq -s .)
+  else
+    directive_array="[]"
+  fi
+
+  # Write contract
+  cat > "$contract_file" << EOF
+{
+  "session_id": "$session_id",
+  "retrieval_ok": $retrieval_ok,
+  "retrieval_source": "$retrieval_source",
+  "retrieved_pattern_ids": $pattern_array,
+  "retrieved_directive_ids": $directive_array,
+  "timestamp": "$timestamp",
+  "query_hash": "$query_hash",
+  "ekkos_strict": ${EKKOS_STRICT:-0}
+}
+EOF
+
+  return 0
+}
+
+# Read turn contract
+read_turn_contract() {
+  local session_id="$1"
+  local retrieval_source="$2"
+  local project_root="${3:-$PROJECT_ROOT}"
+
+  local contract_dir
+  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
+  local contract_file="$contract_dir/turn-contract-${session_id}.json"
+
+  if [ -f "$contract_file" ]; then
+    cat "$contract_file"
+    return 0
+  else
+    return 1
+  fi
+}
+
+# Extract field from contract JSON
+get_contract_field() {
+  local contract_json="$1"
+  local field="$2"
+
+  echo "$contract_json" | jq -r ".$field // \"\"" 2>/dev/null
+}
+
+# Get array field as comma-separated string
+get_contract_array() {
+  local contract_json="$1"
+  local field="$2"
+
+  echo "$contract_json" | jq -r ".$field // [] | join(\",\")" 2>/dev/null
+}
+
+# Cleanup turn contract (only after successful capture)
+cleanup_turn_contract() {
+  local session_id="$1"
+  local retrieval_source="$2"
+  local project_root="${3:-$PROJECT_ROOT}"
+
+  local contract_dir
+  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
+  local contract_file="$contract_dir/turn-contract-${session_id}.json"
+
+  rm -f "$contract_file" 2>/dev/null
+}
+
+# Check if strict mode is enabled
+is_strict_mode() {
+  [ "${EKKOS_STRICT:-0}" = "1" ]
+}
+
+# Generate strict mode blocker message for Claude Code
+get_strict_blocker_message() {
+  cat << 'EOF'
+════════════════════════════════════════════════════════════════════════════
+⛔ EKKOS_STRICT MODE: RETRIEVAL FAILED — DO NOT ANSWER
+
+ekkOS memory retrieval failed or was not authenticated.
+In STRICT mode, you MUST NOT answer technical questions without memory context.
+
+ACTION REQUIRED:
+1. Check if ekkOS is connected: Run `ekkOS: Connect` in VS Code
+2. Verify auth token exists: ~/.ekkos/config.json
+3. Retry the request after connecting
+
+DO NOT proceed with answering. The Golden Loop requires retrieval FIRST.
+════════════════════════════════════════════════════════════════════════════
+EOF
+}
+
+# Validate PatternGuard coverage (returns 0-100)
+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)
+
+  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
+  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
+
+  # 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
+  fi
+
+  # Calculate coverage percentage
+  local coverage
+  coverage=$((acknowledged_count * 100 / total_count))
+
+  # Cap at 100%
+  if [ "$coverage" -gt 100 ]; then
+    coverage=100
+  fi
+
+  echo "$coverage"
+}
+
+# Check for ekkOS footer presence
+check_footer_present() {
+  local assistant_response="$1"
+
+  # Look for the mandatory footer format:
+  # 🧠 **ekkOS_™** · 📅 YYYY-MM-DD
+  # OR
+  # {IDE} ({Model}) · 🧠 **ekkOS_™** · 📅 {Timestamp}
+
+  if echo "$assistant_response" | grep -qE '🧠.*ekkOS.*📅.*[0-9]{4}-[0-9]{2}-[0-9]{2}'; then
+    echo "true"
+    return 0
+  else
+    echo "false"
+    return 1
+  fi
+}
+
+# Build compliance metadata for capture
+build_compliance_metadata() {
+  local retrieval_ok="$1"
+  local pattern_guard_coverage="$2"
+  local footer_present="$3"
+  local ekkos_strict="$4"
+  local retrieved_count="$5"
+
+  local pattern_guard_required="false"
+  if [ "$retrieved_count" -gt 0 ]; then
+    pattern_guard_required="true"
+  fi
+
+  cat << EOF
+{
+  "retrieval_ok": $retrieval_ok,
+  "pattern_guard_required": $pattern_guard_required,
+  "pattern_guard_coverage_pct": $pattern_guard_coverage,
+  "footer_present": $footer_present,
+  "ekkos_strict": $ekkos_strict,
+  "retrieved_count": $retrieved_count,
+  "compliance_version": "1.0"
+}
+EOF
+}
+
+# Determine if turn is compliant
+is_turn_compliant() {
+  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
+    echo "false"
+    return 1
+  fi
+
+  # If patterns were retrieved, PatternGuard must be 100%
+  if [ "$pattern_count" -gt 0 ] && [ "$pattern_guard_coverage" -lt 100 ]; then
+    echo "false"
+    return 1
+  fi
+
+  # Footer must be present
+  if [ "$footer_present" != "true" ]; then
+    echo "false"
+    return 1
+  fi
+
+  echo "true"
+  return 0
+}
+
+# Generate violation reason
+get_violation_reason() {
+  local retrieval_ok="$1"
+  local pattern_guard_coverage="$2"
+  local footer_present="$3"
+  local pattern_count="$4"
+
+  local reasons=""
+
+  if [ "$retrieval_ok" != "true" ]; then
+    reasons="retrieval_failed"
+  fi
+
+  if [ "$pattern_count" -gt 0 ] && [ "$pattern_guard_coverage" -lt 100 ]; then
+    if [ -n "$reasons" ]; then
+      reasons="$reasons,pattern_guard_incomplete"
+    else
+      reasons="pattern_guard_incomplete"
+    fi
+  fi
+
+  if [ "$footer_present" != "true" ]; then
+    if [ -n "$reasons" ]; then
+      reasons="$reasons,footer_missing"
+    else
+      reasons="footer_missing"
+    fi
+  fi
+
+  if [ -z "$reasons" ]; then
+    reasons="none"
+  fi
+
+  echo "$reasons"
+}

package/templates/cursor-hooks/stop.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# ═══════════════════════════════════════════════════════════════════════════
+# ekkOS_ Hook: Stop (Cursor Agent Mode)
+#
+# Fires when agent iteration completes. Can:
+# 1. Clear Time Machine consumed flag (allow new requests)
+# 2. Capture session summary
+# 3. Optionally submit follow-up message
+# ═══════════════════════════════════════════════════════════════════════════
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
+STATE_DIR="$PROJECT_ROOT/.cursor/state"
+
+# Read JSON input
+INPUT=$(cat)
+
+# Extract status
+STATUS=$(echo "$INPUT" | jq -r '.status // "unknown"' 2>/dev/null || echo "unknown")
+LOOP_COUNT=$(echo "$INPUT" | jq -r '.loop_count // 0' 2>/dev/null || echo "0")
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Clear Time Machine flag on session end (allow new requests next session)
+# ═══════════════════════════════════════════════════════════════════════════
+if [ "$STATUS" = "completed" ] || [ "$STATUS" = "aborted" ]; then
+  rm -f "$STATE_DIR/time-machine-consumed.flag" 2>/dev/null || true
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Optional: Load auth for session summary
+# ═══════════════════════════════════════════════════════════════════════════
+EKKOS_CONFIG="$HOME/.ekkos/config.json"
+AUTH_TOKEN=""
+USER_ID=""
+
+if [ -f "$EKKOS_CONFIG" ]; then
+  AUTH_TOKEN=$(jq -r '.hookApiKey // .apiKey // ""' "$EKKOS_CONFIG" 2>/dev/null || echo "")
+  USER_ID=$(jq -r '.userId // ""' "$EKKOS_CONFIG" 2>/dev/null || echo "")
+fi
+
+if [ -z "$AUTH_TOKEN" ] && [ -f "$PROJECT_ROOT/.env.local" ]; then
+  AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" | cut -d'=' -f2- | tr -d '"' | tr -d "'" | tr -d '\r')
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Log session end (fire and forget)
+# ═══════════════════════════════════════════════════════════════════════════
+if [ -n "$AUTH_TOKEN" ]; then
+  SESSION_ID=""
+  if [ -f "$STATE_DIR/current_session_id.txt" ]; then
+    SESSION_ID=$(cat "$STATE_DIR/current_session_id.txt" 2>/dev/null || echo "")
+  fi
+
+  TURN_COUNT=0
+  TURN_FILE="$STATE_DIR/turn_${SESSION_ID}.txt"
+  if [ -f "$TURN_FILE" ]; then
+    TURN_COUNT=$(cat "$TURN_FILE" 2>/dev/null || echo "0")
+  fi
+
+  # Could capture session end event here
+  # For now, just clean up
+
+  # Clean up turn counter for next session
+  # (commented out - might want to persist across agent runs)
+  # rm -f "$TURN_FILE" 2>/dev/null || true
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Return empty response (no follow-up)
+# ═══════════════════════════════════════════════════════════════════════════
+echo '{}'
+
+exit 0

package/templates/cursor-rules/ekkos-memory.md

@@ -0,0 +1,187 @@
+---
+description: "ekkOS Memory - 11-layer cognitive memory with 31 MCP tools"
+alwaysApply: true
+---
+
+# ekkOS Memory System
+
+You have access to **ekkOS memory** via 31 MCP tools. This is an 11-layer cognitive memory system that makes AI smarter over time by learning from past sessions.
+
+## MANDATORY RULES
+
+### RULE 1: SEARCH BEFORE ANSWERING
+Before answering ANY technical question, call `ekkOS_Search` first.
+Do not skip this. Do not assume you know the answer.
+
+### RULE 2: ACKNOWLEDGE RETRIEVED PATTERNS
+When patterns are retrieved, acknowledge each one:
+```
+[ekkOS_SELECT]
+- id: <pattern_id>
+  reason: <why using this>
+  confidence: <0.0-1.0>
+[/ekkOS_SELECT]
+
+[ekkOS_SKIP]
+- id: <pattern_id>
+  reason: <why not relevant>
+[/ekkOS_SKIP]
+```
+
+### RULE 3: FORGE WHAT YOU LEARN
+When you fix a bug, get corrected, or learn something new, call `ekkOS_Forge` immediately.
+
+### RULE 4: FAILURES ARE VALUABLE
+When something DOES NOT work, forge it as an anti-pattern.
+
+## MCP Tools (31 Total)
+
+### Core Memory Tools
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Search` | Search across all 11 memory layers |
+| `ekkOS_Context` | Get relevant context for a task |
+| `ekkOS_Capture` | Capture memory events |
+| `ekkOS_Forge` | Create pattern from learned solution |
+| `ekkOS_Directive` | Create MUST/NEVER/PREFER/AVOID rules |
+| `ekkOS_Outcome` | Track if pattern worked or failed |
+| `ekkOS_Detect` | Auto-detect which patterns were used |
+| `ekkOS_Summary` | Get summary of recent MCP activity |
+| `ekkOS_Conflict` | Check for directive/pattern conflicts |
+| `ekkOS_Recall` | Recall past conversations by time |
+| `ekkOS_Codebase` | Search project code embeddings |
+| `ekkOS_Stats` | Get statistics for all layers |
+| `ekkOS_Track` | Track when pattern is applied |
+| `ekkOS_Reflect` | Analyze response for improvements |
+
+### Schema Awareness Tools
+| Tool | Description |
+|------|-------------|
+| `ekkOS_IndexSchema` | Index database schemas (Supabase/Prisma/TS) |
+| `ekkOS_GetSchema` | Get schema for a specific table/type |
+
+### Portability Tools
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Export` | Export your memory data as portable JSON backup |
+| `ekkOS_Import` | Import memory from backup (auto-deduplication) |
+
+### Plan Management
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Plan` | Create structured task plan |
+| `ekkOS_Plans` | List user's plans |
+| `ekkOS_PlanStatus` | Update plan status |
+| `ekkOS_PlanStep` | Mark step complete/incomplete |
+| `ekkOS_Generate` | AI-generate plan from context |
+| `ekkOS_SaveTemplate` | Save plan as reusable template |
+| `ekkOS_Templates` | List available templates |
+| `ekkOS_FromTemplate` | Create plan from template |
+
+### Secrets Management (Layer 11)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_StoreSecret` | Encrypt and store sensitive data |
+| `ekkOS_GetSecret` | Retrieve and decrypt a secret |
+| `ekkOS_ListSecrets` | List secrets metadata (no values) |
+| `ekkOS_DeleteSecret` | Permanently delete a secret |
+| `ekkOS_RotateSecret` | Update secret with new value |
+
+## 11-Layer Architecture
+
+| # | Layer | Purpose |
+|---|-------|---------|
+| 1 | Working | Current session state |
+| 2 | Episodic | Past conversations |
+| 3 | Semantic | Embeddings/knowledge |
+| 4 | Patterns | Proven solutions |
+| 5 | Procedural | Step-by-step guides |
+| 6 | Collective | Cross-project wisdom |
+| 7 | Meta | Pattern effectiveness |
+| 8 | Codebase | Project-specific code |
+| 9 | Directives | MUST/NEVER/PREFER/AVOID rules |
+| 10 | Conflict Resolution | Auto-resolves contradictions |
+| 11 | Secrets | Encrypted credentials (AES-256-GCM) |
+
+## FORGE TRIGGERS
+
+Call `ekkOS_Forge` when you:
+- Fix a bug (especially non-obvious)
+- Discover a better approach
+- Find a pitfall or gotcha
+- Get corrected by the user
+- Solve auth/config issues
+- Make architectural decisions
+- Debug non-trivially
+- Find something that DOESN'T work
+
+Call `ekkOS_Directive` when user says:
+- "always..." → MUST
+- "never..." → NEVER
+- "I prefer..." → PREFER
+- "don't..." / "avoid..." → AVOID
+
+## Response Format
+
+End every response with:
+```
+---
+🧠 **ekkOS_™** · 📅 YYYY-MM-DD H:MM AM/PM TZ
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/templates/hooks/assistant-response.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+# Post-response hook: Validates and enforces ekkOS footer format
+# Runs AFTER assistant response, checks footer compliance
+
+RESPONSE_FILE="$1"
+HOOK_ENV="$2"
+
+# Exit if no response file
+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)"')
+
+# 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]}"
+}
+
+SESSION_NAME=$(convert_uuid_to_name "$SESSION_ID")
+TIMESTAMP=$(date "+%Y-%m-%d %I:%M %p %Z")
+
+# Required footer format
+REQUIRED_FOOTER="---
+$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" == *"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