@adverant/nexus-memory-skill 1.3.0 → 2.1.0

package/hooks/episode-summary.sh

@@ -1,21 +1,20 @@
 #!/bin/bash
 #
-# Nexus Memory - Enhanced Episode Summary Hook (GraphRAG v2)
+# Nexus Memory - Optimized Episode Summary Hook (GraphRAG v2)
 # Captures significant tool uses and generates periodic episode summaries.
-# Uses entity extraction and causal chaining for knowledge graph building.
 #
-# This hook:
-# - Stores SIGNIFICANT tool uses (filters out routine operations)
-# - Generates episode summaries every N tool uses (default: 10)
-# - Builds causal chains between related operations
-# - Extracts entities for knowledge graph
+# PERFORMANCE OPTIMIZED:
+# - Smart tool filtering (skip routine operations)
+# - Significance scoring for tools
+# - Adaptive episode thresholds based on activity
+# - Compressed episode summaries for efficiency
+# - Async storage for non-blocking operation
 #
 # Episodes capture:
-# - Tool name and inputs
-# - Tool outputs (truncated)
-# - Project context
-# - Causal relationships
-# - Extracted entities
+# - Significant tool uses only
+# - Project context and decisions made
+# - Causal relationships between actions
+# - Extracted entities for knowledge graph
 #
 # Usage:
 #   echo '{"tool_name": "Bash", "tool_input": {...}, "tool_output": "..."}' | episode-summary.sh
@@ -31,7 +30,7 @@
 # GraphRAG Enhancement Options:
 #   NEXUS_EXTRACT_ENTITIES  - Enable entity extraction (default: true)
 #   NEXUS_CREATE_RELATIONS  - Create knowledge graph relationships (default: true)
-#   NEXUS_SKIP_ROUTINE      - Skip routine tool uses like Read, ls (default: true)
+#   NEXUS_MIN_SIGNIFICANCE  - Minimum significance to store tool use (default: 40)
 #
 
 set -o pipefail
@@ -47,13 +46,14 @@ EPISODE_THRESHOLD="${NEXUS_EPISODE_THRESHOLD:-10}"
 # GraphRAG Enhancement Configuration
 EXTRACT_ENTITIES="${NEXUS_EXTRACT_ENTITIES:-true}"
 CREATE_RELATIONS="${NEXUS_CREATE_RELATIONS:-true}"
-SKIP_ROUTINE="${NEXUS_SKIP_ROUTINE:-true}"
+MIN_SIGNIFICANCE="${NEXUS_MIN_SIGNIFICANCE:-40}"
 
-# State file for tracking tool count and causal context
+# State file for tracking
 STATE_DIR="${HOME}/.claude/session-env"
 COUNTER_FILE="${STATE_DIR}/episode_counter"
 LAST_TOOL_ID_FILE="${STATE_DIR}/last_tool_id"
 SESSION_TOOLS_FILE="${STATE_DIR}/session_tools"
+LAST_EPISODE_FILE="${STATE_DIR}/last_episode_id"
 
 # Logging function
 log() {
@@ -66,43 +66,45 @@ log_error() {
   echo "[episode-summary] ERROR: $1" >&2
 }
 
+# =========================================================
+# FAST PATH: Early exit checks
+# =========================================================
+
 # Skip if no API key
 if [[ -z "$NEXUS_API_KEY" ]]; then
-  log "NEXUS_API_KEY not set, skipping episode summary"
-  exit 0
-fi
-
-# Check dependencies
-if ! command -v jq &> /dev/null; then
-  log "jq not installed, skipping episode summary"
   exit 0
 fi
 
-if ! command -v curl &> /dev/null; then
-  log "curl not installed, skipping episode summary"
-  exit 0
-fi
+# Fast dependency check
+type jq &>/dev/null || exit 0
+type curl &>/dev/null || exit 0
 
 # Ensure state directory exists
-mkdir -p "$STATE_DIR"
+mkdir -p "$STATE_DIR" 2>/dev/null
 
 # Read input from stdin
 INPUT=$(cat)
 
 if [[ -z "$INPUT" ]]; then
-  log "No input provided"
   exit 0
 fi
 
 log "Received input: ${INPUT:0:100}..."
 
-# Extract fields from input
-FORCE_SUMMARY=$(echo "$INPUT" | jq -r '.force // false' 2>/dev/null)
-SESSION_END=$(echo "$INPUT" | jq -r '.session_end // false' 2>/dev/null)
-TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
-TOOL_INPUT=$(echo "$INPUT" | jq -r '.tool_input // empty' 2>/dev/null)
-TOOL_OUTPUT=$(echo "$INPUT" | jq -r '.tool_output // empty' 2>/dev/null)
-CONTENT=$(echo "$INPUT" | jq -r '.content // .conversation_summary // .prompt // empty' 2>/dev/null)
+# =========================================================
+# INPUT PARSING
+# =========================================================
+
+# Extract fields with single jq call
+read -r TOOL_NAME FORCE_SUMMARY SESSION_END < <(echo "$INPUT" | jq -r '[
+  (.tool_name // ""),
+  (.force // "false"),
+  (.session_end // "false")
+] | @tsv' 2>/dev/null || echo "	false	false")
+
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}' 2>/dev/null)
+TOOL_OUTPUT=$(echo "$INPUT" | jq -r '.tool_output // ""' 2>/dev/null)
+CONTENT=$(echo "$INPUT" | jq -r '.content // .conversation_summary // .prompt // ""' 2>/dev/null)
 
 # Get project context
 PROJECT_NAME=$(basename "$(pwd)")
@@ -110,81 +112,113 @@ PROJECT_DIR=$(pwd)
 TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 INTERACTION_ID="${PROJECT_NAME}-$(date +%s)-$$"
 
-# --- ROUTINE TOOL FILTERING ---
-# Skip storing routine operations that don't add value to memory
+# =========================================================
+# TOOL SIGNIFICANCE SCORING
+# =========================================================
 
-should_skip_tool() {
+# Tool categories with base significance scores
+get_tool_significance() {
   local tool="$1"
   local input="$2"
-
-  if [[ "$SKIP_ROUTINE" != "true" ]]; then
-    return 1  # Don't skip anything
-  fi
-
-  # Always skip Read tool (just reading files, no action)
-  if [[ "$tool" == "Read" ]]; then
-    log "Skipping routine Read tool"
-    return 0
-  fi
-
-  # Skip Glob and Grep (search operations)
-  if [[ "$tool" == "Glob" ]] || [[ "$tool" == "Grep" ]]; then
-    log "Skipping routine search tool: $tool"
-    return 0
-  fi
-
-  # Skip routine Bash commands
-  if [[ "$tool" == "Bash" ]]; then
-    # Extract command from input
-    local cmd=$(echo "$input" | jq -r '.command // ""' 2>/dev/null)
-
-    # Skip common read-only commands
-    if echo "$cmd" | grep -qE '^(ls|pwd|cat|head|tail|wc|find|grep|which|echo|date|whoami|hostname|env|printenv|type)(\s|$)'; then
-      log "Skipping routine Bash command: ${cmd:0:50}"
-      return 0
+  local output="$3"
+  local score=50  # Base score
+
+  # High-value tools (creation/modification)
+  case "$tool" in
+    Write|Edit|NotebookEdit)
+      score=80  # File modifications are significant
+      ;;
+    Bash)
+      # Analyze the command
+      local cmd=$(echo "$input" | jq -r '.command // ""' 2>/dev/null)
+
+      # Skip routine read commands
+      if echo "$cmd" | grep -qE '^(ls|pwd|cat|head|tail|wc|find|grep|which|echo|date|whoami|type|file)(\s|$)'; then
+        score=10
+      # Skip routine git read commands
+      elif echo "$cmd" | grep -qE '^git\s+(status|log|diff|branch|show|remote|fetch)(\s|$)'; then
+        score=15
+      # High-value git commands
+      elif echo "$cmd" | grep -qE '^git\s+(commit|push|merge|rebase|checkout|reset)(\s|$)'; then
+        score=85
+      # Package management
+      elif echo "$cmd" | grep -qE '^(npm|yarn|pnpm)\s+(install|add|remove|run build|run test)'; then
+        score=70
+      # Docker commands
+      elif echo "$cmd" | grep -qE '^docker\s+(build|run|push|pull|compose)'; then
+        score=75
+      # kubectl commands
+      elif echo "$cmd" | grep -qE '^(kubectl|k3s kubectl)\s+(apply|delete|create|rollout)'; then
+        score=80
+      else
+        score=40  # Unknown commands get medium score
+      fi
+      ;;
+    TodoWrite)
+      score=60  # Task management
+      ;;
+    WebFetch|WebSearch)
+      score=30  # Research/lookup
+      ;;
+    Read|Glob|Grep)
+      score=10  # Read-only operations
+      ;;
+    Skill)
+      score=75  # Skill invocations are significant
+      ;;
+    *)
+      score=50  # Unknown tools get base score
+      ;;
+  esac
+
+  # Output-based adjustments
+  if [[ -n "$output" ]]; then
+    # Errors are always significant
+    if echo "$output" | grep -qiE '(error|exception|failed|failure)'; then
+      score=$((score + 20))
     fi
 
-    # Skip git status/log/diff (read-only git commands)
-    if echo "$cmd" | grep -qE '^git\s+(status|log|diff|branch|show|remote|fetch)(\s|$)'; then
-      log "Skipping routine git command: ${cmd:0:50}"
-      return 0
+    # Success messages boost significance
+    if echo "$output" | grep -qiE '(success|completed|created|fixed|resolved)'; then
+      score=$((score + 15))
     fi
   fi
 
-  # Don't skip - this is a significant tool use
-  return 1
+  # Clamp to 0-100
+  if [[ "$score" -lt 0 ]]; then score=0; fi
+  if [[ "$score" -gt 100 ]]; then score=100; fi
+
+  echo "$score"
 }
 
-# Check if tool output indicates an error/fix (always store these)
-is_significant_output() {
-  local output="$1"
+# =========================================================
+# TOOL PROCESSING
+# =========================================================
+
+if [[ -n "$TOOL_NAME" ]] && [[ "$TOOL_NAME" != "null" ]]; then
+  # Calculate tool significance
+  SIGNIFICANCE=$(get_tool_significance "$TOOL_NAME" "$TOOL_INPUT" "$TOOL_OUTPUT")
+  log "Tool: $TOOL_NAME, Significance: $SIGNIFICANCE (min: $MIN_SIGNIFICANCE)"
 
-  # Always significant: errors, fixes, failures
-  if echo "$output" | grep -qiE '(error|exception|failed|failure|fix|fixed|resolved|success|completed|created|deleted|modified)'; then
-    return 0
+  # Get current counter
+  CURRENT_COUNT=0
+  if [[ -f "$COUNTER_FILE" ]]; then
+    CURRENT_COUNT=$(cat "$COUNTER_FILE" 2>/dev/null || echo "0")
   fi
 
-  return 1
-}
+  # Always increment counter
+  NEW_COUNT=$((CURRENT_COUNT + 1))
+  echo "$NEW_COUNT" > "$COUNTER_FILE"
 
-# --- STEP 1: Process tool use if present ---
-if [[ -n "$TOOL_NAME" ]] && [[ "$TOOL_NAME" != "null" ]]; then
-  # Check if we should skip this routine tool
-  if should_skip_tool "$TOOL_NAME" "$TOOL_INPUT"; then
-    # Still increment counter but don't store
-    if [[ -f "$COUNTER_FILE" ]]; then
-      CURRENT_COUNT=$(cat "$COUNTER_FILE" 2>/dev/null || echo "0")
-    else
-      CURRENT_COUNT=0
-    fi
-    echo "$((CURRENT_COUNT + 1))" > "$COUNTER_FILE"
-    log "Counter incremented to $((CURRENT_COUNT + 1)) (routine tool skipped)"
+  # Skip storing low-significance tools
+  if [[ "$SIGNIFICANCE" -lt "$MIN_SIGNIFICANCE" ]]; then
+    log "Tool below significance threshold, skipping storage (count: $NEW_COUNT)"
   else
     log "Storing significant tool use: $TOOL_NAME"
 
     # Truncate long outputs
-    if [[ ${#TOOL_OUTPUT} -gt 1000 ]]; then
-      TOOL_OUTPUT="${TOOL_OUTPUT:0:1000}... [truncated]"
+    if [[ ${#TOOL_OUTPUT} -gt 800 ]]; then
+      TOOL_OUTPUT="${TOOL_OUTPUT:0:800}... [truncated]"
     fi
 
     # Get previous tool ID for causal chaining
@@ -193,54 +227,44 @@ if [[ -n "$TOOL_NAME" ]] && [[ "$TOOL_NAME" != "null" ]]; then
       PREV_TOOL_ID=$(cat "$LAST_TOOL_ID_FILE" 2>/dev/null)
     fi
 
-    # Determine significance level
-    SIGNIFICANCE="normal"
-    if is_significant_output "$TOOL_OUTPUT"; then
-      SIGNIFICANCE="high"
-    fi
-
-    # Detect domain for entity extraction
+    # Determine domain
     DOMAIN="code"
-    if [[ "$TOOL_NAME" == "WebFetch" ]] || [[ "$TOOL_NAME" == "WebSearch" ]]; then
-      DOMAIN="web"
-    elif [[ "$TOOL_NAME" == "TodoWrite" ]]; then
-      DOMAIN="planning"
-    fi
+    case "$TOOL_NAME" in
+      WebFetch|WebSearch) DOMAIN="web" ;;
+      TodoWrite) DOMAIN="planning" ;;
+    esac
 
-    # Build tool use content
-    TOOL_CONTENT="[Tool Use] $TOOL_NAME
+    # Build compact tool content
+    TOOL_CONTENT="[Tool] $TOOL_NAME (sig: $SIGNIFICANCE)
 Project: $PROJECT_NAME
-Significance: $SIGNIFICANCE
-Input: ${TOOL_INPUT:0:500}
+Input: ${TOOL_INPUT:0:400}
 Output: $TOOL_OUTPUT"
 
-    # Build enhanced payload for tool use with entity extraction
+    # Build payload
     TOOL_PAYLOAD=$(jq -n \
       --arg content "$TOOL_CONTENT" \
       --arg tool "$TOOL_NAME" \
       --arg project "$PROJECT_NAME" \
-      --arg projectDir "$PROJECT_DIR" \
       --arg timestamp "$TIMESTAMP" \
       --arg interactionId "$INTERACTION_ID" \
       --arg prevToolId "$PREV_TOOL_ID" \
-      --arg significance "$SIGNIFICANCE" \
+      --argjson significance "$SIGNIFICANCE" \
       --arg domain "$DOMAIN" \
       --argjson extractEntities "$EXTRACT_ENTITIES" \
       --argjson createRelations "$CREATE_RELATIONS" \
       '{
         content: $content,
-        tags: ["claude-code", "type:tool-use", "tool:\($tool)", "project:\($project)", "significance:\($significance)"],
+        tags: ["claude-code", "type:tool-use", "tool:\($tool)", "project:\($project)", "sig:\($significance)"],
         metadata: {
           eventType: "tool-use",
           toolName: $tool,
           projectName: $project,
-          projectDir: $projectDir,
           timestamp: $timestamp,
           interactionId: $interactionId,
           significance: $significance
         },
         extract_entities: $extractEntities,
-        entity_types: ["code_pattern", "error", "file", "function", "class", "command"],
+        entity_types: ["code_pattern", "error", "file", "function", "command"],
         domain: $domain,
         create_relationships: $createRelations,
         episodic: {
@@ -250,49 +274,45 @@ Output: $TOOL_OUTPUT"
         }
       }')
 
-    # Store tool use asynchronously with enhanced GraphRAG features
+    # Store tool use asynchronously
     (
-      RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "$NEXUS_API_URL/api/memory/store" \
+      RESPONSE=$(curl -s -X POST "$NEXUS_API_URL/api/memory/store" \
         -H "Content-Type: application/json" \
         -H "Authorization: Bearer $NEXUS_API_KEY" \
         -H "X-Company-ID: $COMPANY_ID" \
         -H "X-App-ID: $APP_ID" \
         -H "X-User-ID: ${USER:-unknown}" \
+        -H "Connection: keep-alive" \
         -d "$TOOL_PAYLOAD" \
+        --connect-timeout 2 \
         --max-time 5 2>/dev/null)
 
-      HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
-      BODY=$(echo "$RESPONSE" | sed '$d')
-
       # Save this tool's memory ID for causal chaining
-      MEMORY_ID=$(echo "$BODY" | jq -r '.data.memoryId // .memoryId // empty' 2>/dev/null)
+      MEMORY_ID=$(echo "$RESPONSE" | jq -r '.data.memoryId // .memoryId // empty' 2>/dev/null)
       if [[ -n "$MEMORY_ID" ]]; then
         echo "$MEMORY_ID" > "$LAST_TOOL_ID_FILE"
       fi
 
-      # Append to session tools log for episode summary
-      echo "$TOOL_NAME:$SIGNIFICANCE:$INTERACTION_ID" >> "$SESSION_TOOLS_FILE"
-
+      # Append to session tools log (compact format)
+      echo "$TOOL_NAME:$SIGNIFICANCE:$(date +%H%M%S)" >> "$SESSION_TOOLS_FILE"
     ) &
 
-    log "Tool use stored with causal chain"
+    log "Tool use stored"
   fi
-fi
-
-# --- STEP 2: Check if we should generate episode summary ---
-
-# Get current counter
-if [[ -f "$COUNTER_FILE" ]]; then
-  CURRENT_COUNT=$(cat "$COUNTER_FILE" 2>/dev/null || echo "0")
 else
-  CURRENT_COUNT=0
+  # No tool - just get counter
+  if [[ -f "$COUNTER_FILE" ]]; then
+    CURRENT_COUNT=$(cat "$COUNTER_FILE" 2>/dev/null || echo "0")
+  else
+    CURRENT_COUNT=0
+  fi
+  NEW_COUNT=$((CURRENT_COUNT + 1))
+  echo "$NEW_COUNT" > "$COUNTER_FILE"
 fi
 
-# Increment counter
-NEW_COUNT=$((CURRENT_COUNT + 1))
-echo "$NEW_COUNT" > "$COUNTER_FILE"
-
-log "Tool count: $NEW_COUNT (threshold: $EPISODE_THRESHOLD)"
+# =========================================================
+# EPISODE SUMMARY GENERATION
+# =========================================================
 
 # Determine if we should generate an episode summary
 SHOULD_SUMMARIZE=false
@@ -305,8 +325,7 @@ elif [[ "$SESSION_END" == "true" ]]; then
   log "Session end summary"
 elif [[ "$NEW_COUNT" -ge "$EPISODE_THRESHOLD" ]]; then
   SHOULD_SUMMARIZE=true
-  log "Threshold reached, generating episode"
-  # Reset counter
+  log "Threshold reached ($NEW_COUNT >= $EPISODE_THRESHOLD)"
   echo "0" > "$COUNTER_FILE"
 fi
 
@@ -316,74 +335,74 @@ if [[ "$SHOULD_SUMMARIZE" != "true" ]]; then
   exit 0
 fi
 
-# Generate session ID for this episode
+# =========================================================
+# BUILD EPISODE SUMMARY
+# =========================================================
+
 SESSION_ID=$(date +%Y%m%d-%H%M%S)
 
 # Read session tools for summary
 SESSION_TOOLS=""
+SIGNIFICANT_TOOLS=""
 if [[ -f "$SESSION_TOOLS_FILE" ]]; then
-  SESSION_TOOLS=$(cat "$SESSION_TOOLS_FILE" 2>/dev/null | tail -20)
-  # Clear the session tools file after reading
+  SESSION_TOOLS=$(cat "$SESSION_TOOLS_FILE" 2>/dev/null | tail -30)
+  # Count high-significance tools (sig >= 60)
+  SIGNIFICANT_TOOLS=$(echo "$SESSION_TOOLS" | awk -F: '$2 >= 60 {print $1}' | sort | uniq -c | sort -rn | head -5)
+  # Clear the session tools file
   echo "" > "$SESSION_TOOLS_FILE"
 fi
 
-# Skip if no content to summarize
+# Build content from session activity if not provided
 if [[ -z "$CONTENT" ]] || [[ "$CONTENT" == "null" ]]; then
-  # Build content from session tools
   if [[ -n "$SESSION_TOOLS" ]]; then
-    CONTENT="Session activity:
-$SESSION_TOOLS"
+    CONTENT="Session activity in $PROJECT_NAME"
   else
     CONTENT="Conversation segment in $PROJECT_NAME project"
   fi
 fi
 
 # Truncate very long content
-if [[ ${#CONTENT} -gt 5000 ]]; then
-  CONTENT="${CONTENT:0:5000}... [truncated]"
+if [[ ${#CONTENT} -gt 3000 ]]; then
+  CONTENT="${CONTENT:0:3000}... [truncated]"
 fi
 
-# Count significant tools in this episode
-SIGNIFICANT_COUNT=$(echo "$SESSION_TOOLS" | grep -c ":high:" || echo "0")
+# Count tools by significance
+TOTAL_TOOLS=$(echo "$SESSION_TOOLS" | grep -c ':' || echo "0")
+HIGH_SIG_COUNT=$(echo "$SESSION_TOOLS" | awk -F: '$2 >= 60' | wc -l | tr -d ' ')
 
-# Generate episode summary with enhanced structure
+# Generate compact episode summary
 EPISODE_CONTENT=$(cat <<EOF
-[Episode Summary - $PROJECT_NAME]
-Timestamp: $TIMESTAMP
-Project: $PROJECT_NAME
-Directory: $PROJECT_DIR
-Tool Count: $NEW_COUNT
-Significant Events: $SIGNIFICANT_COUNT
+[Episode] $PROJECT_NAME
+Time: $TIMESTAMP
+Tools: $TOTAL_TOOLS total, $HIGH_SIG_COUNT significant
 
-Session Activity:
+Activity Summary:
 $CONTENT
 
-Tools Used:
-$(echo "$SESSION_TOOLS" | awk -F: '{print "- " $1 " (" $2 ")"}' | head -10)
+Top Tools:
+$(echo "$SIGNIFICANT_TOOLS" | head -5 | awk '{print "- " $2 " (" $1 "x)"}')
 
 ---
-This episode was automatically generated after $NEW_COUNT tool interactions.
+Auto-generated after $NEW_COUNT interactions.
 EOF
 )
 
-log "Generating episode summary for $PROJECT_NAME"
+log "Generating episode summary"
 
 # Get previous episode ID for causal chaining
 PREV_EPISODE_ID=""
-LAST_EPISODE_FILE="${STATE_DIR}/last_episode_id"
 if [[ -f "$LAST_EPISODE_FILE" ]]; then
   PREV_EPISODE_ID=$(cat "$LAST_EPISODE_FILE" 2>/dev/null)
 fi
 
-# Build the enhanced payload with causal chaining
+# Build the payload
 PAYLOAD=$(jq -n \
   --arg content "$EPISODE_CONTENT" \
   --arg session "$SESSION_ID" \
   --arg project "$PROJECT_NAME" \
-  --arg projectDir "$PROJECT_DIR" \
   --arg timestamp "$TIMESTAMP" \
   --argjson toolCount "$NEW_COUNT" \
-  --argjson significantCount "$SIGNIFICANT_COUNT" \
+  --argjson sigCount "$HIGH_SIG_COUNT" \
   --arg prevEpisodeId "$PREV_EPISODE_ID" \
   --argjson extractEntities "$EXTRACT_ENTITIES" \
   --argjson createRelations "$CREATE_RELATIONS" \
@@ -393,11 +412,10 @@ PAYLOAD=$(jq -n \
     metadata: {
       sessionId: $session,
       eventType: "episode",
-      projectDir: $projectDir,
       projectName: $project,
       timestamp: $timestamp,
       toolCount: $toolCount,
-      significantEventCount: $significantCount,
+      significantToolCount: $sigCount,
       isEpisodeSummary: true
     },
     extract_entities: $extractEntities,
@@ -415,37 +433,36 @@ PAYLOAD=$(jq -n \
 
 log "Storing episode to $NEXUS_API_URL/api/memory/store"
 
-# Store to GraphRAG via API Gateway
+# Store episode
 if [[ "$VERBOSE" == "1" ]]; then
-  # Sync mode with output for debugging
   RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "$NEXUS_API_URL/api/memory/store" \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer $NEXUS_API_KEY" \
     -H "X-Company-ID: $COMPANY_ID" \
     -H "X-App-ID: $APP_ID" \
     -H "X-User-ID: ${USER:-unknown}" \
+    -H "Connection: keep-alive" \
     -d "$PAYLOAD" \
-    --max-time 10 2>&1)
+    --connect-timeout 2 \
+    --max-time 8 2>&1)
 
   HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
   BODY=$(echo "$RESPONSE" | sed '$d')
 
   log "Response code: $HTTP_CODE"
-  log "Response body: ${BODY:0:500}"
 
   if [[ "$HTTP_CODE" == "200" ]] || [[ "$HTTP_CODE" == "201" ]]; then
-    # Save episode ID for causal chaining
     EPISODE_ID=$(echo "$BODY" | jq -r '.data.memoryId // .memoryId // empty' 2>/dev/null)
     if [[ -n "$EPISODE_ID" ]]; then
       echo "$EPISODE_ID" > "$LAST_EPISODE_FILE"
-      log "Saved episode ID for causal chain: $EPISODE_ID"
+      log "Saved episode ID: $EPISODE_ID"
     fi
     log "Episode stored successfully"
   else
     log_error "Failed to store episode (HTTP $HTTP_CODE)"
   fi
 else
-  # Async mode for normal operation
+  # Async mode
   (
     RESPONSE=$(curl -s -X POST "$NEXUS_API_URL/api/memory/store" \
       -H "Content-Type: application/json" \
@@ -453,10 +470,11 @@ else
       -H "X-Company-ID: $COMPANY_ID" \
       -H "X-App-ID: $APP_ID" \
       -H "X-User-ID: ${USER:-unknown}" \
+      -H "Connection: keep-alive" \
       -d "$PAYLOAD" \
+      --connect-timeout 2 \
       --max-time 5 2>/dev/null)
 
-    # Save episode ID for causal chaining
     EPISODE_ID=$(echo "$RESPONSE" | jq -r '.data.memoryId // .memoryId // empty' 2>/dev/null)
     if [[ -n "$EPISODE_ID" ]]; then
       echo "$EPISODE_ID" > "$LAST_EPISODE_FILE"