@ekkos/cli 0.2.9 → 0.2.10

package/templates/hooks/session-start.ps1

@@ -1,10 +1,90 @@
 # ═══════════════════════════════════════════════════════════════════════════
 # ekkOS_ Hook: SessionStart - Initialize session (Windows)
+# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
+# EKKOS_MANAGED=1
+# EKKOS_MANIFEST_SHA256=<computed-at-build>
+# EKKOS_TEMPLATE_VERSION=1.0.0
+#
+# Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
+# - All persisted records MUST include: instanceId, sessionId, sessionName
+# - Uses EKKOS_INSTANCE_ID env var for multi-session isolation
 # ═══════════════════════════════════════════════════════════════════════════
 
 $ErrorActionPreference = "SilentlyContinue"
 
-# Read input
+# ═══════════════════════════════════════════════════════════════════════════
+# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
+# ═══════════════════════════════════════════════════════════════════════════
+$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { "$env:USERPROFILE\.ekkos" }
+$SessionWordsJson = "$EkkosConfigDir\session-words.json"
+$SessionWordsDefault = "$EkkosConfigDir\.defaults\session-words.json"
+
+# ═══════════════════════════════════════════════════════════════════════════
+# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
+# ═══════════════════════════════════════════════════════════════════════════
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Load session words from JSON file - NO HARDCODED ARRAYS
+# ═══════════════════════════════════════════════════════════════════════════
+$script:SessionWords = $null
+
+function Load-SessionWords {
+    $wordsFile = $SessionWordsJson
+
+    if (-not (Test-Path $wordsFile)) {
+        $wordsFile = $SessionWordsDefault
+    }
+
+    if (-not (Test-Path $wordsFile)) {
+        return $null
+    }
+
+    try {
+        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
+    } catch {
+        return $null
+    }
+}
+
+function Convert-UuidToWords {
+    param([string]$uuid)
+
+    if (-not $script:SessionWords) {
+        Load-SessionWords
+    }
+
+    if (-not $script:SessionWords) {
+        return "unknown-session"
+    }
+
+    $adjectives = $script:SessionWords.adjectives
+    $nouns = $script:SessionWords.nouns
+    $verbs = $script:SessionWords.verbs
+
+    if (-not $adjectives -or -not $nouns -or -not $verbs) {
+        return "unknown-session"
+    }
+
+    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
+
+    $clean = $uuid -replace "-", ""
+    if ($clean.Length -lt 6) { return "unknown-session" }
+
+    try {
+        $a = [Convert]::ToInt32($clean.Substring(0,2), 16) % $adjectives.Length
+        $n = [Convert]::ToInt32($clean.Substring(2,2), 16) % $nouns.Length
+        $an = [Convert]::ToInt32($clean.Substring(4,2), 16) % $verbs.Length
+
+        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
+    } catch {
+        return "unknown-session"
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# READ INPUT
+# ═══════════════════════════════════════════════════════════════════════════
 $inputJson = [Console]::In.ReadToEnd()
 
 try {
@@ -14,7 +94,11 @@ try {
     $sessionId = "unknown"
 }
 
-# Initialize state directory
+$sessionName = Convert-UuidToWords $sessionId
+
+# ═══════════════════════════════════════════════════════════════════════════
+# INITIALIZE STATE DIRECTORY
+# ═══════════════════════════════════════════════════════════════════════════
 $stateDir = Join-Path $env:USERPROFILE ".claude\state"
 if (-not (Test-Path $stateDir)) {
     New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
@@ -25,6 +109,8 @@ $stateFile = Join-Path $stateDir "hook-state.json"
 $state = @{
     turn = 0
     session_id = $sessionId
+    session_name = $sessionName
+    instance_id = $EkkosInstanceId
     started_at = (Get-Date).ToString("o")
 } | ConvertTo-Json
 
@@ -34,8 +120,27 @@ Set-Content -Path $stateFile -Value $state -Force
 $sessionFile = Join-Path $stateDir "current-session.json"
 $sessionData = @{
     session_id = $sessionId
+    session_name = $sessionName
+    instance_id = $EkkosInstanceId
 } | ConvertTo-Json
 
 Set-Content -Path $sessionFile -Value $sessionData -Force
 
+# ═══════════════════════════════════════════════════════════════════════════
+# LOCAL CACHE: Initialize session in Tier 0 cache
+# Per v1.2 ADDENDUM: Pass instanceId for namespacing
+# ═══════════════════════════════════════════════════════════════════════════
+$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
+if ($captureCmd -and $sessionId -ne "unknown") {
+    try {
+        # NEW format: ekkos-capture init <instance_id> <session_id> <session_name>
+        Start-Job -ScriptBlock {
+            param($instanceId, $sessId, $sessName)
+            try {
+                & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null
+            } catch {}
+        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName | Out-Null
+    } catch {}
+}
+
 Write-Output "ekkOS session initialized"

package/templates/hooks/session-start.sh

@@ -1,6 +1,8 @@
 #!/bin/bash
 # ═══════════════════════════════════════════════════════════════════════════
 # ekkOS_ Hook: SessionStart - MINIMAL + AUTO-RESTORE + TIME MACHINE CONTINUE
+# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
+# EKKOS_MANAGED=1
 # ═══════════════════════════════════════════════════════════════════════════
 # This hook does THREE things:
 # 1. Check for pending Time Machine "Continue from here" requests
@@ -15,6 +17,8 @@
 # FAST TRIM FLOW:
 # User runs /clear → session-start detects fresh session →
 # Checks L2 for recent turns → Auto-injects last 15 turns → Seamless continuity
+#
+# Per spec v1.2 Addendum: NO jq dependency
 # ═══════════════════════════════════════════════════════════════════════════
 
 set +e
@@ -22,10 +26,36 @@ set +e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# CONFIG PATHS - Per spec v1.2 Addendum
+# ═══════════════════════════════════════════════════════════════════════════
+EKKOS_CONFIG_DIR="${EKKOS_CONFIG_DIR:-$HOME/.ekkos}"
+JSON_PARSE_HELPER="$EKKOS_CONFIG_DIR/.helpers/json-parse.cjs"
+
 INPUT=$(cat)
-SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
-TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // ""')
-SOURCE=$(echo "$INPUT" | jq -r '.source // "unknown"')  # "startup", "resume", or "clear"
+
+# Parse input using Node (no jq)
+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 ""
+}
+
+SESSION_ID=$(parse_json_value "$INPUT" '.session_id')
+[ -z "$SESSION_ID" ] && SESSION_ID="unknown"
+
+TRANSCRIPT_PATH=$(parse_json_value "$INPUT" '.transcript_path')
+SOURCE=$(parse_json_value "$INPUT" '.source')
+[ -z "$SOURCE" ] && SOURCE="unknown"
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Load auth
@@ -34,13 +64,16 @@ 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 "")
+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
+    USER_ID=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.userId' 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')
+    AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" | cut -d'=' -f2- | tr -d '"' | tr -d "'" | tr -d '\r')
 fi
 
 [ -z "$AUTH_TOKEN" ] && exit 0
@@ -57,39 +90,55 @@ TIME_MACHINE_TO_TURN=""
 
 # Check via env var first, then API
 if [ -n "$RESTORE_REQUEST_ID" ]; then
-  echo -e "\033[0;35m⏰ Time Machine request detected: $RESTORE_REQUEST_ID\033[0m" >&2
+    echo -e "\033[0;35m  Time Machine request detected: $RESTORE_REQUEST_ID\033[0m" >&2
 fi
 
 # Check API for pending requests (if we have user_id)
 if [ -z "$TIME_MACHINE_SESSION" ] && [ -n "$USER_ID" ]; then
-  PENDING_RESPONSE=$(curl -s -X GET "$MEMORY_API_URL/api/v1/context/restore-request/pending?user_id=$USER_ID" \
-    -H "Authorization: Bearer $AUTH_TOKEN" \
-    --connect-timeout 2 \
-    --max-time 3 2>/dev/null || echo '{}')
-
-  IS_PENDING=$(echo "$PENDING_RESPONSE" | jq -r '.pending // false' 2>/dev/null)
-
-  if [ "$IS_PENDING" = "true" ]; then
-    TIME_MACHINE_SESSION=$(echo "$PENDING_RESPONSE" | jq -r '.request.session_id // ""')
-    TIME_MACHINE_FROM_TURN=$(echo "$PENDING_RESPONSE" | jq -r '.request.from_turn // ""')
-    TIME_MACHINE_TO_TURN=$(echo "$PENDING_RESPONSE" | jq -r '.request.to_turn // ""')
-    RESTORE_REQUEST_ID=$(echo "$PENDING_RESPONSE" | jq -r '.request.request_id // ""')
-
-    if [ -n "$TIME_MACHINE_SESSION" ]; then
-      echo "" >&2
-      echo -e "\033[0;35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m" >&2
-      echo -e "\033[0;35m\033[1m⏰ TIME MACHINE\033[0m \033[2m| Restoring session from web request...\033[0m" >&2
-      echo -e "\033[0;35m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m" >&2
-
-      # Mark request as consumed
-      curl -s -X POST "$MEMORY_API_URL/api/v1/context/restore-request/consume" \
+    PENDING_RESPONSE=$(curl -s -X GET "$MEMORY_API_URL/api/v1/context/restore-request/pending?user_id=$USER_ID" \
         -H "Authorization: Bearer $AUTH_TOKEN" \
-        -H "Content-Type: application/json" \
-        -d "{\"request_id\": \"$RESTORE_REQUEST_ID\"}" \
         --connect-timeout 2 \
-        --max-time 3 >/dev/null 2>&1 || true
+        --max-time 3 2>/dev/null || echo '{}')
+
+    # Parse using Node (no jq)
+    IS_PENDING=$(echo "$PENDING_RESPONSE" | node -e "
+const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log(data.pending || false);
+" 2>/dev/null || echo "false")
+
+    if [ "$IS_PENDING" = "true" ]; then
+        TIME_MACHINE_SESSION=$(echo "$PENDING_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log(d.request?.session_id || '');
+" 2>/dev/null || echo "")
+        TIME_MACHINE_FROM_TURN=$(echo "$PENDING_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log(d.request?.from_turn || '');
+" 2>/dev/null || echo "")
+        TIME_MACHINE_TO_TURN=$(echo "$PENDING_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log(d.request?.to_turn || '');
+" 2>/dev/null || echo "")
+        RESTORE_REQUEST_ID=$(echo "$PENDING_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log(d.request?.request_id || '');
+" 2>/dev/null || echo "")
+
+        if [ -n "$TIME_MACHINE_SESSION" ]; then
+            echo "" >&2
+            echo -e "\033[0;35m------------------------------------------------------------------------\033[0m" >&2
+            echo -e "\033[0;35m\033[1m  TIME MACHINE\033[0m \033[2m| Restoring session from web request...\033[0m" >&2
+            echo -e "\033[0;35m------------------------------------------------------------------------\033[0m" >&2
+
+            # Mark request as consumed
+            curl -s -X POST "$MEMORY_API_URL/api/v1/context/restore-request/consume" \
+                -H "Authorization: Bearer $AUTH_TOKEN" \
+                -H "Content-Type: application/json" \
+                -d "{\"request_id\": \"$RESTORE_REQUEST_ID\"}" \
+                --connect-timeout 2 \
+                --max-time 3 >/dev/null 2>&1 || true
+        fi
     fi
-  fi
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -111,24 +160,24 @@ MOST_RECENT_SESSION=""
 SAVED_TURN_COUNT=0
 
 if [ -n "$CURRENT_SESSION_ID" ] && [ "$CURRENT_SESSION_ID" != "unknown" ]; then
-  # Check if THIS session has saved turns (for /clear continuity)
-  TURN_COUNTER_FILE="$PROJECT_SESSION_DIR/${CURRENT_SESSION_ID}.turn"
-  if [ -f "$TURN_COUNTER_FILE" ]; then
-    SAVED_TURN_COUNT=$(cat "$TURN_COUNTER_FILE" 2>/dev/null || echo "0")
-    MOST_RECENT_SESSION="$CURRENT_SESSION_ID"
-  else
-    # Fresh start: find most recent session in project
-    MOST_RECENT_FILE=$(ls -t "$PROJECT_SESSION_DIR"/*.turn 2>/dev/null | head -1)
-    if [ -n "$MOST_RECENT_FILE" ]; then
-      MOST_RECENT_SESSION=$(basename "$MOST_RECENT_FILE" .turn)
-      SAVED_TURN_COUNT=$(cat "$MOST_RECENT_FILE" 2>/dev/null || echo "0")
+    # Check if THIS session has saved turns (for /clear continuity)
+    TURN_COUNTER_FILE="$PROJECT_SESSION_DIR/${CURRENT_SESSION_ID}.turn"
+    if [ -f "$TURN_COUNTER_FILE" ]; then
+        SAVED_TURN_COUNT=$(cat "$TURN_COUNTER_FILE" 2>/dev/null || echo "0")
+        MOST_RECENT_SESSION="$CURRENT_SESSION_ID"
+    else
+        # Fresh start: find most recent session in project
+        MOST_RECENT_FILE=$(ls -t "$PROJECT_SESSION_DIR"/*.turn 2>/dev/null | head -1)
+        if [ -n "$MOST_RECENT_FILE" ]; then
+            MOST_RECENT_SESSION=$(basename "$MOST_RECENT_FILE" .turn)
+            SAVED_TURN_COUNT=$(cat "$MOST_RECENT_FILE" 2>/dev/null || echo "0")
+        fi
     fi
-  fi
 fi
 
 # Save current session info
 if [ -n "$CURRENT_SESSION_ID" ]; then
-  cat > "$SESSION_FILE" << EOF
+    cat > "$SESSION_FILE" << EOF
 {
   "session_id": "$CURRENT_SESSION_ID",
   "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
@@ -138,28 +187,23 @@ EOF
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
-# 🔄 GOLDEN LOOP: Initialize session tracking file
+# GOLDEN LOOP: Initialize session tracking file
 # ═══════════════════════════════════════════════════════════════════════════
 GOLDEN_LOOP_FILE="$PROJECT_ROOT/.ekkos/golden-loop-current.json"
 mkdir -p "$PROJECT_ROOT/.ekkos" 2>/dev/null || true
 
-# Initialize with session start state
-jq -n \
-  --arg phase "idle" \
-  --argjson turn 0 \
-  --arg session "${CURRENT_SESSION_ID}" \
-  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  '{
-    phase: $phase,
-    turn: $turn,
-    session: $session,
-    timestamp: $timestamp,
-    stats: {
-      retrieved: 0,
-      applied: 0,
-      forged: 0
-    }
-  }' > "$GOLDEN_LOOP_FILE" 2>/dev/null || true
+# Initialize with session start state using Node (no jq)
+node -e "
+const fs = require('fs');
+const data = {
+    phase: 'idle',
+    turn: 0,
+    session: '$CURRENT_SESSION_ID',
+    timestamp: new Date().toISOString(),
+    stats: { retrieved: 0, applied: 0, forged: 0 }
+};
+fs.writeFileSync('$GOLDEN_LOOP_FILE', JSON.stringify(data, null, 2));
+" 2>/dev/null || true
 
 # ═══════════════════════════════════════════════════════════════════════════
 # COLORS
@@ -185,44 +229,56 @@ RESET='\033[0m'
 
 # Handle Time Machine requests (explicit user action)
 if [ -n "$TIME_MACHINE_SESSION" ]; then
-  echo "" >&2
-  echo -e "${MAGENTA}${BOLD}⏰ TIME MACHINE${RESET} ${DIM}| Restoring past session: ${TIME_MACHINE_SESSION:0:12}...${RESET}" >&2
-
-  # Build recall request with turn range
-  RECALL_BODY="{\"session_id\": \"${TIME_MACHINE_SESSION}\", \"last_n\": 15, \"format\": \"summary\"}"
-
-  if [ -n "$TIME_MACHINE_FROM_TURN" ] && [ -n "$TIME_MACHINE_TO_TURN" ]; then
-    RECALL_BODY="{\"session_id\": \"${TIME_MACHINE_SESSION}\", \"from_turn\": ${TIME_MACHINE_FROM_TURN}, \"to_turn\": ${TIME_MACHINE_TO_TURN}, \"format\": \"summary\"}"
-  elif [ -n "$TIME_MACHINE_FROM_TURN" ]; then
-    RECALL_BODY="{\"session_id\": \"${TIME_MACHINE_SESSION}\", \"from_turn\": ${TIME_MACHINE_FROM_TURN}, \"format\": \"summary\"}"
-  fi
-
-  # Fetch turns from L2
-  RESTORE_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/turns/recall" \
-    -H "Authorization: Bearer $AUTH_TOKEN" \
-    -H "Content-Type: application/json" \
-    -d "$RECALL_BODY" \
-    --connect-timeout 3 \
-    --max-time 5 2>/dev/null || echo '{"error":"timeout"}')
-
-  # Check if we got turns back
-  RESTORED_COUNT=$(echo "$RESTORE_RESPONSE" | jq '.turns // [] | length' 2>/dev/null || echo "0")
-
-  if [ "$RESTORED_COUNT" -gt 0 ]; then
-    echo -e "${MAGENTA}   ✓${RESET} Restored ${RESTORED_COUNT} turns from past session" >&2
-    echo "" >&2
-    echo -e "${MAGENTA}${BOLD}## Time Machine Context${RESET}" >&2
     echo "" >&2
+    echo -e "${MAGENTA}${BOLD}  TIME MACHINE${RESET} ${DIM}| Restoring past session: ${TIME_MACHINE_SESSION:0:12}...${RESET}" >&2
 
-    # Output the turns as context (stderr for user, stdout for Claude)
-    TURNS_OUTPUT=$(echo "$RESTORE_RESPONSE" | jq -r '.turns[]? | "**Turn \(.turn_number // "?")**: \(.user_query[:100] // "...")...\n> \(.assistant_response[:200] // "...")...\n"' 2>/dev/null || true)
-    echo "$TURNS_OUTPUT" >&2
-    echo "$TURNS_OUTPUT"  # Also to stdout for Claude's context
+    # Build recall request with turn range
+    RECALL_BODY="{\"session_id\": \"${TIME_MACHINE_SESSION}\", \"last_n\": 15, \"format\": \"summary\"}"
 
-    echo "" >&2
-    echo -e "${DIM}You've traveled to a past session. Continue from here!${RESET}" >&2
-    echo "" >&2
-  fi
+    if [ -n "$TIME_MACHINE_FROM_TURN" ] && [ -n "$TIME_MACHINE_TO_TURN" ]; then
+        RECALL_BODY="{\"session_id\": \"${TIME_MACHINE_SESSION}\", \"from_turn\": ${TIME_MACHINE_FROM_TURN}, \"to_turn\": ${TIME_MACHINE_TO_TURN}, \"format\": \"summary\"}"
+    elif [ -n "$TIME_MACHINE_FROM_TURN" ]; then
+        RECALL_BODY="{\"session_id\": \"${TIME_MACHINE_SESSION}\", \"from_turn\": ${TIME_MACHINE_FROM_TURN}, \"format\": \"summary\"}"
+    fi
+
+    # Fetch turns from L2
+    RESTORE_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/turns/recall" \
+        -H "Authorization: Bearer $AUTH_TOKEN" \
+        -H "Content-Type: application/json" \
+        -d "$RECALL_BODY" \
+        --connect-timeout 3 \
+        --max-time 5 2>/dev/null || echo '{"error":"timeout"}')
+
+    # Check if we got turns back using Node (no jq)
+    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 "${MAGENTA}   ✓${RESET} Restored ${RESTORED_COUNT} turns from past session" >&2
+        echo "" >&2
+        echo -e "${MAGENTA}${BOLD}## Time Machine Context${RESET}" >&2
+        echo "" >&2
+
+        # Output the turns as context using Node (no jq)
+        TURNS_OUTPUT=$(echo "$RESTORE_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+(d.turns || []).forEach(t => {
+    const q = (t.user_query || '').substring(0, 100);
+    const r = (t.assistant_response || '').substring(0, 200);
+    console.log('**Turn ' + (t.turn_number || '?') + '**: ' + q + '...');
+    console.log('> ' + r + '...');
+    console.log('');
+});
+" 2>/dev/null || echo "")
+        echo "$TURNS_OUTPUT" >&2
+        echo "$TURNS_OUTPUT"
+
+        echo "" >&2
+        echo -e "${DIM}You've traveled to a past session. Continue from here!${RESET}" >&2
+        echo "" >&2
+    fi
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -233,85 +289,64 @@ DIRECTIVE_COUNT=0
 
 # Only fetch if we have auth
 if [ -n "$AUTH_TOKEN" ]; then
-  # Fetch directives (top 20 by priority to avoid token bloat)
-  DIRECTIVES_RESPONSE=$(curl -s -X GET "$MEMORY_API_URL/api/v1/memory/directives?limit=20" \
-    -H "Authorization: Bearer $AUTH_TOKEN" \
-    --connect-timeout 2 \
-    --max-time 3 2>/dev/null || echo '{}')
-
-  # Parse response
-  DIRECTIVE_COUNT=$(echo "$DIRECTIVES_RESPONSE" | jq '.count // 0' 2>/dev/null || echo "0")
-
-  if [ "$DIRECTIVE_COUNT" -gt 0 ]; then
-    DIRECTIVES_INJECTED=true
-
-    # Extract MUST/NEVER/PREFER/AVOID arrays
-    MUST_RULES=$(echo "$DIRECTIVES_RESPONSE" | jq -r '.MUST[]?.rule // empty' 2>/dev/null | head -5)
-    NEVER_RULES=$(echo "$DIRECTIVES_RESPONSE" | jq -r '.NEVER[]?.rule // empty' 2>/dev/null | head -5)
-    PREFER_RULES=$(echo "$DIRECTIVES_RESPONSE" | jq -r '.PREFER[]?.rule // empty' 2>/dev/null | head -5)
-    AVOID_RULES=$(echo "$DIRECTIVES_RESPONSE" | jq -r '.AVOID[]?.rule // empty' 2>/dev/null | head -5)
-
-    # Build compact directive block for injection
-    echo "<system-reminder>"
-    echo "USER DIRECTIVES (FOLLOW THESE):"
-    echo ""
-
-    if [ -n "$MUST_RULES" ]; then
-      echo "MUST:"
-      echo "$MUST_RULES" | while read -r rule; do
-        [ -n "$rule" ] && echo "  • $rule"
-      done
-    fi
-
-    if [ -n "$NEVER_RULES" ]; then
-      echo "NEVER:"
-      echo "$NEVER_RULES" | while read -r rule; do
-        [ -n "$rule" ] && echo "  • $rule"
-      done
-    fi
-
-    if [ -n "$PREFER_RULES" ]; then
-      echo "PREFER:"
-      echo "$PREFER_RULES" | while read -r rule; do
-        [ -n "$rule" ] && echo "  • $rule"
-      done
-    fi
+    # Fetch directives (top 20 by priority to avoid token bloat)
+    DIRECTIVES_RESPONSE=$(curl -s -X GET "$MEMORY_API_URL/api/v1/memory/directives?limit=20" \
+        -H "Authorization: Bearer $AUTH_TOKEN" \
+        --connect-timeout 2 \
+        --max-time 3 2>/dev/null || echo '{}')
+
+    # Parse response using Node (no jq)
+    DIRECTIVE_COUNT=$(echo "$DIRECTIVES_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+console.log(d.count || 0);
+" 2>/dev/null || echo "0")
+
+    if [ "$DIRECTIVE_COUNT" -gt 0 ]; then
+        DIRECTIVES_INJECTED=true
+
+        # Extract MUST/NEVER/PREFER/AVOID arrays using Node
+        echo "<system-reminder>"
+        echo "USER DIRECTIVES (FOLLOW THESE):"
+        echo ""
+
+        echo "$DIRECTIVES_RESPONSE" | node -e "
+const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
+const types = ['MUST', 'NEVER', 'PREFER', 'AVOID'];
+types.forEach(type => {
+    const rules = (d[type] || []).slice(0, 5);
+    if (rules.length > 0) {
+        console.log(type + ':');
+        rules.forEach(r => console.log('  - ' + (r.rule || '')));
+    }
+});
+" 2>/dev/null || true
 
-    if [ -n "$AVOID_RULES" ]; then
-      echo "AVOID:"
-      echo "$AVOID_RULES" | while read -r rule; do
-        [ -n "$rule" ] && echo "  • $rule"
-      done
+        echo "</system-reminder>"
+        echo -e "${GREEN}  ${DIRECTIVE_COUNT} directives loaded${RESET}" >&2
     fi
-
-    echo "</system-reminder>"
-
-    echo -e "${GREEN}📋 ${DIRECTIVE_COUNT} directives loaded${RESET}" >&2
-  fi
 fi
 
 # Simple status display (no auto-restore)
 if [ "$SAVED_TURN_COUNT" -gt 0 ]; then
-  # New session or few turns - just show status
-  echo "" >&2
-  if [ "$SAVED_TURN_COUNT" -gt 0 ]; then
-    echo -e "${CYAN}${BOLD}🧠 ekkOS${RESET} ${DIM}|${RESET} Session: ${CURRENT_SESSION_ID:-$SESSION_ID} ${DIM}|${RESET} ${GREEN}${SAVED_TURN_COUNT} turns${RESET}" >&2
-  else
-    echo -e "${CYAN}${BOLD}🧠 ekkOS${RESET} ${DIM}|${RESET} Session: ${CURRENT_SESSION_ID:-$SESSION_ID} ${DIM}| New session${RESET}" >&2
-  fi
+    echo "" >&2
+    if [ "$SAVED_TURN_COUNT" -gt 0 ]; then
+        echo -e "${CYAN}${BOLD}  ekkOS${RESET} ${DIM}|${RESET} Session: ${CURRENT_SESSION_ID:-$SESSION_ID} ${DIM}|${RESET} ${GREEN}${SAVED_TURN_COUNT} turns${RESET}" >&2
+    else
+        echo -e "${CYAN}${BOLD}  ekkOS${RESET} ${DIM}|${RESET} Session: ${CURRENT_SESSION_ID:-$SESSION_ID} ${DIM}| New session${RESET}" >&2
+    fi
 fi
 
 # Final confirmation that's always visible
 if [ -n "$TIME_MACHINE_SESSION" ]; then
-  echo -e "${MAGENTA}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
-  echo -e "${MAGENTA}⏰${RESET} Time Machine active · Restored from session ${TIME_MACHINE_SESSION:0:12}..." >&2
-  echo -e "${MAGENTA}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
+    echo -e "${MAGENTA}------------------------------------------------------------------------${RESET}" >&2
+    echo -e "${MAGENTA}  ${RESET} Time Machine active - Restored from session ${TIME_MACHINE_SESSION:0:12}..." >&2
+    echo -e "${MAGENTA}------------------------------------------------------------------------${RESET}" >&2
 elif [ "$SAVED_TURN_COUNT" -gt 0 ]; then
-  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
-  echo -e "${GREEN}✓${RESET} Session continued · ${SAVED_TURN_COUNT} turns preserved · Ready to resume" >&2
-  echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
+    echo -e "${GREEN}------------------------------------------------------------------------${RESET}" >&2
+    echo -e "${GREEN}✓${RESET} Session continued - ${SAVED_TURN_COUNT} turns preserved - Ready to resume" >&2
+    echo -e "${GREEN}------------------------------------------------------------------------${RESET}" >&2
 else
-  echo -e "${CYAN}✓${RESET} New session started" >&2
+    echo -e "${CYAN}✓${RESET} New session started" >&2
 fi
 echo "" >&2