@ekkos/cli 1.0.35 → 1.0.36

package/templates/hooks/session-start.ps1

@@ -1,445 +1,308 @@
 # ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: SessionStart - MINIMAL + AUTO-RESTORE + TIME MACHINE CONTINUE
+# ekkOS_ Hook: SessionStart - MINIMAL + TIME MACHINE + DIRECTIVES (Windows)
 # 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
-# 2. Initialize session tracking
-# 3. Auto-restore from L2 if recent turns exist (FAST TRIM support)
+# 2. Initialize session tracking + Golden Loop
+# 3. Fetch and inject user directives (MUST/NEVER/PREFER/AVOID)
 #
-# TIME MACHINE FLOW:
-# User clicks "Continue from here" on web -> API queues request ->
-# User runs `claude` -> This hook detects pending request ->
-# Restores THAT session's context -> Seamless time travel!
-#
-# 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
+# Per spec v1.2 Addendum: NO hardcoded arrays, uses session-words.json
 # ═══════════════════════════════════════════════════════════════════════════
 
 $ErrorActionPreference = "SilentlyContinue"
 
-$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
-$ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
-
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - Per spec v1.2 Addendum
+# CONFIG PATHS
 # ═══════════════════════════════════════════════════════════════════════════
-$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { Join-Path $env:USERPROFILE ".ekkos" }
-$JsonParseHelper = Join-Path $EkkosConfigDir ".helpers\json-parse.cjs"
+$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"
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
-$INPUT = [Console]::In.ReadToEnd()
+$MemoryApiUrl = "https://api.ekkos.dev"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# JSON parsing helper (no jq) - pipes JSON to node, extracts dot-path value
+# Load session words from JSON file - NO HARDCODED ARRAYS
 # ═══════════════════════════════════════════════════════════════════════════
-function Parse-JsonValue {
-    param(
-        [string]$Json,
-        [string]$Path
-    )
-    if (-not $Json) { return "" }
+$script:SessionWords = $null
+
+function Load-SessionWords {
+    $wordsFile = $SessionWordsJson
+    if (-not (Test-Path $wordsFile)) { $wordsFile = $SessionWordsDefault }
+    if (-not (Test-Path $wordsFile)) { return $null }
     try {
-        $result = $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>$null
-        if ($result) { return $result.Trim() } else { return "" }
-    } catch {
-        return ""
-    }
+        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
+    } catch { return $null }
 }
 
-$SESSION_ID = Parse-JsonValue $INPUT ".session_id"
-if (-not $SESSION_ID) { $SESSION_ID = "unknown" }
+function Convert-UuidToWords {
+    param([string]$uuid)
+    if (-not $script:SessionWords) { Load-SessionWords }
+    if (-not $script:SessionWords) { return "unknown-session" }
 
-$TRANSCRIPT_PATH = Parse-JsonValue $INPUT ".transcript_path"
-$SOURCE = Parse-JsonValue $INPUT ".source"
-if (-not $SOURCE) { $SOURCE = "unknown" }
+    $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" }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Load auth
-# ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_CONFIG = Join-Path $env:USERPROFILE ".ekkos\config.json"
-$AUTH_TOKEN = ""
-$USER_ID = ""
-
-if ((Test-Path $EKKOS_CONFIG) -and (Test-Path $JsonParseHelper)) {
-    $AUTH_TOKEN = & node $JsonParseHelper $EKKOS_CONFIG ".hookApiKey" 2>$null
-    if (-not $AUTH_TOKEN) {
-        $AUTH_TOKEN = & node $JsonParseHelper $EKKOS_CONFIG ".apiKey" 2>$null
-    }
-    $USER_ID = & node $JsonParseHelper $EKKOS_CONFIG ".userId" 2>$null
-}
+    $clean = $uuid -replace "-", ""
+    if ($clean.Length -lt 12) { return "unknown-session" }
 
-if (-not $AUTH_TOKEN) {
-    $envLocalFile = Join-Path $ProjectRoot ".env.local"
-    if (Test-Path $envLocalFile) {
-        $envLines = Get-Content $envLocalFile
-        foreach ($line in $envLines) {
-            if ($line -match '^SUPABASE_SECRET_KEY=(.+)$') {
-                $AUTH_TOKEN = $Matches[1].Trim('"', "'", ' ', "`r")
-                break
-            }
-        }
-    }
+    try {
+        $a = [Convert]::ToInt32($clean.Substring(0,4), 16) % $adjectives.Length
+        $n = [Convert]::ToInt32($clean.Substring(4,4), 16) % $nouns.Length
+        $an = [Convert]::ToInt32($clean.Substring(8,4), 16) % $verbs.Length
+        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
+    } catch { return "unknown-session" }
 }
 
-if (-not $AUTH_TOKEN) { exit 0 }
+# ═══════════════════════════════════════════════════════════════════════════
+# READ INPUT
+# ═══════════════════════════════════════════════════════════════════════════
+$inputJson = [Console]::In.ReadToEnd()
+try {
+    $input = $inputJson | ConvertFrom-Json
+    $sessionId = $input.session_id
+} catch {
+    $sessionId = "unknown"
+}
+if (-not $sessionId) { $sessionId = "unknown" }
 
-$MEMORY_API_URL = "https://mcp.ekkos.dev"
+$sessionName = Convert-UuidToWords $sessionId
 
 # ═══════════════════════════════════════════════════════════════════════════
-# COLORS (ANSI escape sequences via [char]27)
+# LOAD AUTH
 # ═══════════════════════════════════════════════════════════════════════════
-$ESC = [char]27
-$CYAN = "$ESC[0;36m"
-$GREEN = "$ESC[0;32m"
-$YELLOW = "$ESC[1;33m"
-$MAGENTA = "$ESC[0;35m"
-$DIM = "$ESC[2m"
-$BOLD = "$ESC[1m"
-$RESET = "$ESC[0m"
+$authToken = ""
+$userId = ""
+$configFile = Join-Path $EkkosConfigDir "config.json"
+if (Test-Path $configFile) {
+    try {
+        $config = Get-Content $configFile -Raw | ConvertFrom-Json
+        $authToken = $config.hookApiKey
+        if (-not $authToken) { $authToken = $config.apiKey }
+        $userId = $config.userId
+    } catch {}
+}
+if (-not $authToken) { exit 0 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # TIME MACHINE: Check for pending "Continue from here" requests
 # ═══════════════════════════════════════════════════════════════════════════
-$RESTORE_REQUEST_ID = $env:EKKOS_RESTORE
-$TIME_MACHINE_SESSION = ""
-$TIME_MACHINE_FROM_TURN = ""
-$TIME_MACHINE_TO_TURN = ""
-
-# Check via env var first, then API
-if ($RESTORE_REQUEST_ID) {
-    [Console]::Error.WriteLine("$MAGENTA  Time Machine request detected: $RESTORE_REQUEST_ID$RESET")
-}
+$timeMachineSession = ""
+$timeMachineFromTurn = ""
+$timeMachineToTurn = ""
+$restoreRequestId = $env:EKKOS_RESTORE
 
-# Check API for pending requests (if we have user_id)
-if ((-not $TIME_MACHINE_SESSION) -and $USER_ID) {
-    $PENDING_RESPONSE_RAW = ""
+if (-not $timeMachineSession -and $userId) {
     try {
-        $PENDING_RESPONSE_RAW = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/context/restore-request/pending?user_id=$USER_ID" `
-            -Method GET `
-            -Headers @{ Authorization = "Bearer $AUTH_TOKEN" } `
-            -TimeoutSec 3 `
-            -ErrorAction Stop
-    } catch {
-        $PENDING_RESPONSE_RAW = ""
-    }
-
-    if ($PENDING_RESPONSE_RAW) {
-        # Convert response object to JSON string for Parse-JsonValue
-        $PENDING_JSON = ""
-        if ($PENDING_RESPONSE_RAW -is [string]) {
-            $PENDING_JSON = $PENDING_RESPONSE_RAW
-        } else {
-            try {
-                $PENDING_JSON = $PENDING_RESPONSE_RAW | ConvertTo-Json -Depth 10 -Compress
-            } catch {
-                $PENDING_JSON = "{}"
-            }
-        }
-
-        $IS_PENDING = Parse-JsonValue $PENDING_JSON ".pending"
-
-        if ($IS_PENDING -eq "true" -or $IS_PENDING -eq "True") {
-            $TIME_MACHINE_SESSION = Parse-JsonValue $PENDING_JSON ".request.session_id"
-            $TIME_MACHINE_FROM_TURN = Parse-JsonValue $PENDING_JSON ".request.from_turn"
-            $TIME_MACHINE_TO_TURN = Parse-JsonValue $PENDING_JSON ".request.to_turn"
-            $RESTORE_REQUEST_ID = Parse-JsonValue $PENDING_JSON ".request.request_id"
-
-            if ($TIME_MACHINE_SESSION) {
+        $headers = @{ "Authorization" = "Bearer $authToken" }
+        $pendingResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/context/restore-request/pending?user_id=$userId" `
+            -Method GET -Headers $headers -TimeoutSec 3
+
+        if ($pendingResponse.pending -eq $true -and $pendingResponse.request) {
+            $timeMachineSession = $pendingResponse.request.session_id
+            $timeMachineFromTurn = $pendingResponse.request.from_turn
+            $timeMachineToTurn = $pendingResponse.request.to_turn
+            $restoreRequestId = $pendingResponse.request.request_id
+
+            if ($timeMachineSession) {
+                $esc = [char]27
                 [Console]::Error.WriteLine("")
-                [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-                [Console]::Error.WriteLine("$MAGENTA${BOLD}  TIME MACHINE$RESET $DIM| Restoring session from web request...$RESET")
-                [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-
-                # Mark request as consumed (background, non-blocking)
-                $consumeBody = "{`"request_id`": `"$RESTORE_REQUEST_ID`"}"
-                Start-Job -ScriptBlock {
-                    param($url, $token, $body)
-                    try {
-                        Invoke-RestMethod -Uri "$url/api/v1/context/restore-request/consume" `
-                            -Method POST `
-                            -Headers @{ Authorization = "Bearer $token"; "Content-Type" = "application/json" } `
-                            -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
-                            -TimeoutSec 3 `
-                            -ErrorAction SilentlyContinue | Out-Null
-                    } catch {}
-                } -ArgumentList $MEMORY_API_URL, $AUTH_TOKEN, $consumeBody | Out-Null
+                [Console]::Error.WriteLine("${esc}[0;35m------------------------------------------------------------------------${esc}[0m")
+                [Console]::Error.WriteLine("${esc}[0;35m${esc}[1m  TIME MACHINE${esc}[0m ${esc}[2m| Restoring session from web request...${esc}[0m")
+                [Console]::Error.WriteLine("${esc}[0;35m------------------------------------------------------------------------${esc}[0m")
+
+                $consumeBody = @{ request_id = $restoreRequestId } | ConvertTo-Json -Depth 10
+                try {
+                    Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/context/restore-request/consume" `
+                        -Method POST -Headers @{ "Authorization" = "Bearer $authToken"; "Content-Type" = "application/json" } `
+                        -Body ([System.Text.Encoding]::UTF8.GetBytes($consumeBody)) -TimeoutSec 3 | Out-Null
+                } catch {}
             }
         }
-    }
+    } catch {}
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Session ID persistence - PROJECT-LOCAL for isolation
+# SESSION PERSISTENCE - PROJECT-LOCAL for isolation
 # ═══════════════════════════════════════════════════════════════════════════
-$STATE_DIR = Join-Path $ProjectRoot ".claude\state"
-if (-not (Test-Path $STATE_DIR)) {
-    New-Item -ItemType Directory -Path $STATE_DIR -Force | Out-Null
-}
-$SESSION_FILE = Join-Path $STATE_DIR "current-session.json"
+$projectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+$stateDir = Join-Path $env:USERPROFILE ".claude\state"
+$projectSessionDir = Join-Path $stateDir "sessions"
 
-# Project-local session storage (isolated per project)
-$PROJECT_SESSION_DIR = Join-Path $STATE_DIR "sessions"
-if (-not (Test-Path $PROJECT_SESSION_DIR)) {
-    New-Item -ItemType Directory -Path $PROJECT_SESSION_DIR -Force | Out-Null
-}
+if (-not (Test-Path $stateDir)) { New-Item -ItemType Directory -Path $stateDir -Force | Out-Null }
+if (-not (Test-Path $projectSessionDir)) { New-Item -ItemType Directory -Path $projectSessionDir -Force | Out-Null }
 
-# Use Claude's RAW_SESSION_ID directly (from session_id field)
-$CURRENT_SESSION_ID = $SESSION_ID
-
-# Find most recent session in THIS PROJECT for auto-restore
-$MOST_RECENT_SESSION = ""
-$SAVED_TURN_COUNT = 0
-
-if ($CURRENT_SESSION_ID -and $CURRENT_SESSION_ID -ne "unknown") {
-    # Check if THIS session has saved turns (for /clear continuity)
-    $TURN_COUNTER_FILE = Join-Path $PROJECT_SESSION_DIR "$CURRENT_SESSION_ID.turn"
-    if (Test-Path $TURN_COUNTER_FILE) {
-        try {
-            $SAVED_TURN_COUNT = [int](Get-Content $TURN_COUNTER_FILE -Raw).Trim()
-        } catch {
-            $SAVED_TURN_COUNT = 0
-        }
-        $MOST_RECENT_SESSION = $CURRENT_SESSION_ID
+$savedTurnCount = 0
+$mostRecentSession = ""
+
+if ($sessionId -ne "unknown") {
+    $turnFile = Join-Path $projectSessionDir "$sessionId.turn"
+    if (Test-Path $turnFile) {
+        try { $savedTurnCount = [int](Get-Content $turnFile -Raw).Trim() } catch { $savedTurnCount = 0 }
+        $mostRecentSession = $sessionId
     } else {
-        # Fresh start: find most recent session in project
-        $turnFiles = Get-ChildItem -Path $PROJECT_SESSION_DIR -Filter "*.turn" -ErrorAction SilentlyContinue |
-            Sort-Object LastWriteTime -Descending |
-            Select-Object -First 1
-        if ($turnFiles) {
-            $MOST_RECENT_SESSION = [System.IO.Path]::GetFileNameWithoutExtension($turnFiles.Name)
-            try {
-                $SAVED_TURN_COUNT = [int](Get-Content $turnFiles.FullName -Raw).Trim()
-            } catch {
-                $SAVED_TURN_COUNT = 0
-            }
+        $mostRecentFile = Get-ChildItem "$projectSessionDir\*.turn" -ErrorAction SilentlyContinue |
+            Sort-Object LastWriteTime -Descending | Select-Object -First 1
+        if ($mostRecentFile) {
+            $mostRecentSession = $mostRecentFile.BaseName
+            try { $savedTurnCount = [int](Get-Content $mostRecentFile.FullName -Raw).Trim() } catch { $savedTurnCount = 0 }
         }
     }
 }
 
-# Save current session info
-if ($CURRENT_SESSION_ID) {
-    $TIMESTAMP_UTC = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-    $projectRootNorm = $ProjectRoot -replace '\\', '/'
-    $sessionInfoJson = "{`"session_id`": `"$CURRENT_SESSION_ID`", `"timestamp`": `"$TIMESTAMP_UTC`", `"project_root`": `"$projectRootNorm`"}"
-    Set-Content -Path $SESSION_FILE -Value $sessionInfoJson -Force
-}
+$sessionFile = Join-Path $stateDir "current-session.json"
+$sessionData = @{
+    session_id = $sessionId
+    session_name = $sessionName
+    instance_id = $EkkosInstanceId
+    timestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    project_root = $projectRoot
+} | ConvertTo-Json -Depth 10
+Set-Content -Path $sessionFile -Value $sessionData -Force
+
+$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 -Depth 10
+Set-Content -Path $stateFile -Value $state -Force
 
 # ═══════════════════════════════════════════════════════════════════════════
 # GOLDEN LOOP: Initialize session tracking file
 # ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_DIR = Join-Path $ProjectRoot ".ekkos"
-if (-not (Test-Path $EKKOS_DIR)) {
-    New-Item -ItemType Directory -Path $EKKOS_DIR -Force | Out-Null
-}
-$GOLDEN_LOOP_FILE = Join-Path $EKKOS_DIR "golden-loop-current.json"
-
-# Initialize with session start state using Node (no jq)
-$glPathEscaped = $GOLDEN_LOOP_FILE -replace '\\', '\\\\'
-try {
-    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('$glPathEscaped', JSON.stringify(data, null, 2));
-" 2>$null
-} catch {}
+$ekkosDir = Join-Path $projectRoot ".ekkos"
+if (-not (Test-Path $ekkosDir)) { New-Item -ItemType Directory -Path $ekkosDir -Force | Out-Null }
+
+$goldenLoopFile = Join-Path $ekkosDir "golden-loop-current.json"
+$goldenLoop = @{
+    phase = "idle"
+    turn = 0
+    session = $sessionId
+    timestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    stats = @{ retrieved = 0; applied = 0; forged = 0 }
+} | ConvertTo-Json -Depth 10
+Set-Content -Path $goldenLoopFile -Value $goldenLoop -Force
 
 # ═══════════════════════════════════════════════════════════════════════════
-# AUTO-RESTORE REMOVED: Manual /continue only (saves 79% token burn!)
-# ═══════════════════════════════════════════════════════════════════════════
-# WHY REMOVED:
-# - Auto-restore burned 5,000 tokens per turn on session start
-# - Manual /continue: one-time cost + clean slate (79% token savings!)
-# - Manual /continue is 10x more powerful (Bash + multi-source + narrative)
-#
-# KEPT: Time Machine feature (explicit user request)
+# LOCAL CACHE: Initialize session
 # ═══════════════════════════════════════════════════════════════════════════
+$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
+if ($captureCmd -and $sessionId -ne "unknown") {
+    try {
+        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 {}
+}
 
-# Handle Time Machine requests (explicit user action)
-if ($TIME_MACHINE_SESSION) {
-    $tmPreview = $TIME_MACHINE_SESSION
-    if ($tmPreview.Length -gt 12) {
-        $tmPreview = $tmPreview.Substring(0, 12)
-    }
+# ═══════════════════════════════════════════════════════════════════════════
+# COLORS
+# ═══════════════════════════════════════════════════════════════════════════
+$esc = [char]27
+$CYAN = "${esc}[0;36m"; $GREEN = "${esc}[0;32m"; $MAGENTA = "${esc}[0;35m"
+$DIM = "${esc}[2m"; $BOLD = "${esc}[1m"; $RESET = "${esc}[0m"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# TIME MACHINE RESTORATION
+# ═══════════════════════════════════════════════════════════════════════════
+if ($timeMachineSession) {
     [Console]::Error.WriteLine("")
-    [Console]::Error.WriteLine("$MAGENTA${BOLD}  TIME MACHINE$RESET $DIM| Restoring past session: ${tmPreview}...$RESET")
-
-    # Build recall request with turn range
-    $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"last_n`": 15, `"format`": `"summary`"}"
-
-    if ($TIME_MACHINE_FROM_TURN -and $TIME_MACHINE_TO_TURN) {
-        $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"from_turn`": $TIME_MACHINE_FROM_TURN, `"to_turn`": $TIME_MACHINE_TO_TURN, `"format`": `"summary`"}"
-    } elseif ($TIME_MACHINE_FROM_TURN) {
-        $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"from_turn`": $TIME_MACHINE_FROM_TURN, `"format`": `"summary`"}"
+    $tmPreview = $timeMachineSession.Substring(0, [Math]::Min(12, $timeMachineSession.Length))
+    [Console]::Error.WriteLine("${MAGENTA}${BOLD}  TIME MACHINE${RESET} ${DIM}| Restoring past session: ${tmPreview}...${RESET}")
+
+    $recallBody = @{ session_id = $timeMachineSession; last_n = 15; format = "summary" }
+    if ($timeMachineFromTurn -and $timeMachineToTurn) {
+        $recallBody = @{ session_id = $timeMachineSession; from_turn = [int]$timeMachineFromTurn; to_turn = [int]$timeMachineToTurn; format = "summary" }
+    } elseif ($timeMachineFromTurn) {
+        $recallBody = @{ session_id = $timeMachineSession; from_turn = [int]$timeMachineFromTurn; format = "summary" }
     }
 
-    # Fetch turns from L2
-    $RESTORE_RESPONSE = $null
+    $recallJson = $recallBody | ConvertTo-Json -Depth 10
     try {
-        $RESTORE_RESPONSE = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/turns/recall" `
+        $restoreResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/turns/recall" `
             -Method POST `
-            -Headers @{ Authorization = "Bearer $AUTH_TOKEN"; "Content-Type" = "application/json" } `
-            -Body ([System.Text.Encoding]::UTF8.GetBytes($RECALL_BODY)) `
-            -TimeoutSec 5 `
-            -ErrorAction Stop
-    } catch {
-        $RESTORE_RESPONSE = $null
-    }
-
-    # Check if we got turns back
-    $RESTORED_COUNT = 0
-    $RESTORED_TURNS = @()
-    if ($RESTORE_RESPONSE -and $RESTORE_RESPONSE.turns) {
-        $RESTORED_TURNS = @($RESTORE_RESPONSE.turns)
-        $RESTORED_COUNT = $RESTORED_TURNS.Count
-    }
-
-    if ($RESTORED_COUNT -gt 0) {
-        [Console]::Error.WriteLine("$MAGENTA   $RESET Restored $RESTORED_COUNT turns from past session")
-        [Console]::Error.WriteLine("")
-        [Console]::Error.WriteLine("$MAGENTA${BOLD}## Time Machine Context$RESET")
-        [Console]::Error.WriteLine("")
-
-        # Build turns output for both stderr (display) and stdout (context injection)
-        $turnsOutput = ""
-        foreach ($t in $RESTORED_TURNS) {
-            $q = ""
-            if ($t.user_query) {
-                $q = $t.user_query
-                if ($q.Length -gt 100) { $q = $q.Substring(0, 100) }
-            }
-            $r = ""
-            if ($t.assistant_response) {
-                $r = $t.assistant_response
-                if ($r.Length -gt 200) { $r = $r.Substring(0, 200) }
+            -Headers @{ "Authorization" = "Bearer $authToken"; "Content-Type" = "application/json" } `
+            -Body ([System.Text.Encoding]::UTF8.GetBytes($recallJson)) -TimeoutSec 5
+
+        $restoredCount = ($restoreResponse.turns | Measure-Object).Count
+        if ($restoredCount -gt 0) {
+            [Console]::Error.WriteLine("${MAGENTA}   ✓${RESET} Restored $restoredCount turns from past session")
+            [Console]::Error.WriteLine("")
+
+            $turnsOutput = ""
+            foreach ($t in $restoreResponse.turns) {
+                $q = if ($t.user_query) { $t.user_query.Substring(0, [Math]::Min(100, $t.user_query.Length)) } else { "..." }
+                $r = if ($t.assistant_response) { $t.assistant_response.Substring(0, [Math]::Min(200, $t.assistant_response.Length)) } else { "..." }
+                $turnLine = "**Turn $($t.turn_number)**: $q..."
+                [Console]::Error.WriteLine($turnLine)
+                [Console]::Error.WriteLine("> $r...")
+                [Console]::Error.WriteLine("")
+                $turnsOutput += "$turnLine`n> $r...`n`n"
             }
-            $tn = if ($t.turn_number) { $t.turn_number } else { "?" }
+            Write-Output $turnsOutput
 
-            $turnLine = "**Turn $tn**: $q..."
-            $responseLine = "> $r..."
-            $turnsOutput += "$turnLine`n$responseLine`n`n"
+            [Console]::Error.WriteLine("${DIM}You've traveled to a past session. Continue from here!${RESET}")
+            [Console]::Error.WriteLine("")
         }
-
-        # Output to stderr (visible in terminal)
-        [Console]::Error.WriteLine($turnsOutput)
-        # Output to stdout (injected into context)
-        Write-Output $turnsOutput
-
-        [Console]::Error.WriteLine("")
-        [Console]::Error.WriteLine("${DIM}You've traveled to a past session. Continue from here!$RESET")
-        [Console]::Error.WriteLine("")
-    }
+    } catch {}
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # DIRECTIVE RETRIEVAL: Fetch user's MUST/NEVER/PREFER/AVOID rules
 # ═══════════════════════════════════════════════════════════════════════════
-$DIRECTIVES_INJECTED = $false
-$DIRECTIVE_COUNT = 0
-
-# Only fetch if we have auth
-if ($AUTH_TOKEN) {
-    # Fetch directives (top 20 by priority to avoid token bloat)
-    $DIRECTIVES_RESPONSE_RAW = $null
+if ($authToken) {
     try {
-        $DIRECTIVES_RESPONSE_RAW = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/memory/directives?limit=20" `
-            -Method GET `
-            -Headers @{ Authorization = "Bearer $AUTH_TOKEN" } `
-            -TimeoutSec 3 `
-            -ErrorAction Stop
-    } catch {
-        $DIRECTIVES_RESPONSE_RAW = $null
-    }
-
-    if ($DIRECTIVES_RESPONSE_RAW) {
-        # Convert response object to JSON string for Parse-JsonValue / Node
-        $DIRECTIVES_JSON = ""
-        if ($DIRECTIVES_RESPONSE_RAW -is [string]) {
-            $DIRECTIVES_JSON = $DIRECTIVES_RESPONSE_RAW
-        } else {
-            try {
-                $DIRECTIVES_JSON = $DIRECTIVES_RESPONSE_RAW | ConvertTo-Json -Depth 10 -Compress
-            } catch {
-                $DIRECTIVES_JSON = "{}"
-            }
-        }
+        $directivesResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/memory/directives?limit=20" `
+            -Method GET -Headers @{ "Authorization" = "Bearer $authToken" } -TimeoutSec 3
 
-        $DIRECTIVE_COUNT_STR = Parse-JsonValue $DIRECTIVES_JSON ".count"
-        if ($DIRECTIVE_COUNT_STR -match '^\d+$') {
-            $DIRECTIVE_COUNT = [int]$DIRECTIVE_COUNT_STR
-        }
-
-        if ($DIRECTIVE_COUNT -gt 0) {
-            $DIRECTIVES_INJECTED = $true
-
-            # Extract MUST/NEVER/PREFER/AVOID arrays using Node
+        $directiveCount = $directivesResponse.count
+        if ($directiveCount -gt 0) {
             Write-Output "<system-reminder>"
             Write-Output "USER DIRECTIVES (FOLLOW THESE):"
             Write-Output ""
 
-            $directiveOutput = $DIRECTIVES_JSON | 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>$null
-
-            if ($directiveOutput) {
-                Write-Output $directiveOutput
+            foreach ($type in @("MUST", "NEVER", "PREFER", "AVOID")) {
+                $rules = $directivesResponse.$type
+                if ($rules -and ($rules | Measure-Object).Count -gt 0) {
+                    Write-Output "${type}:"
+                    $rules | Select-Object -First 5 | ForEach-Object { Write-Output "  - $($_.rule)" }
+                }
             }
 
             Write-Output "</system-reminder>"
-            [Console]::Error.WriteLine("$GREEN  $DIRECTIVE_COUNT directives loaded$RESET")
+            [Console]::Error.WriteLine("${GREEN}  $directiveCount directives loaded${RESET}")
         }
-    }
+    } catch {}
 }
 
-# Simple status display (no auto-restore)
-if ($SAVED_TURN_COUNT -gt 0) {
+# ═══════════════════════════════════════════════════════════════════════════
+# STATUS DISPLAY
+# ═══════════════════════════════════════════════════════════════════════════
+if ($savedTurnCount -gt 0) {
     [Console]::Error.WriteLine("")
-    $displaySessionId = if ($CURRENT_SESSION_ID) { $CURRENT_SESSION_ID } else { $SESSION_ID }
-    [Console]::Error.WriteLine("$CYAN${BOLD}  ekkOS$RESET $DIM|$RESET Session: $displaySessionId $DIM|$RESET $GREEN$SAVED_TURN_COUNT turns$RESET")
+    [Console]::Error.WriteLine("${CYAN}${BOLD}  ekkOS${RESET} ${DIM}|${RESET} Session: $sessionId ${DIM}|${RESET} ${GREEN}$savedTurnCount turns${RESET}")
 }
 
-# Final confirmation that's always visible
-if ($TIME_MACHINE_SESSION) {
-    $tmFinalPreview = $TIME_MACHINE_SESSION
-    if ($tmFinalPreview.Length -gt 12) {
-        $tmFinalPreview = $tmFinalPreview.Substring(0, 12)
-    }
-    [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-    [Console]::Error.WriteLine("$MAGENTA  $RESET Time Machine active - Restored from session ${tmFinalPreview}...")
-    [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-} elseif ($SAVED_TURN_COUNT -gt 0) {
-    [Console]::Error.WriteLine("$GREEN------------------------------------------------------------------------$RESET")
-    [Console]::Error.WriteLine("${GREEN}$RESET Session continued - $SAVED_TURN_COUNT turns preserved - Ready to resume")
-    [Console]::Error.WriteLine("$GREEN------------------------------------------------------------------------$RESET")
+if ($timeMachineSession) {
+    $tmP = $timeMachineSession.Substring(0, [Math]::Min(12, $timeMachineSession.Length))
+    [Console]::Error.WriteLine("${MAGENTA}------------------------------------------------------------------------${RESET}")
+    [Console]::Error.WriteLine("${MAGENTA}  ${RESET} Time Machine active - Restored from session ${tmP}...")
+    [Console]::Error.WriteLine("${MAGENTA}------------------------------------------------------------------------${RESET}")
+} elseif ($savedTurnCount -gt 0) {
+    [Console]::Error.WriteLine("${GREEN}------------------------------------------------------------------------${RESET}")
+    [Console]::Error.WriteLine("${GREEN}✓${RESET} Session continued - $savedTurnCount turns preserved - Ready to resume")
+    [Console]::Error.WriteLine("${GREEN}------------------------------------------------------------------------${RESET}")
 } else {
-    [Console]::Error.WriteLine("${CYAN}$RESET New session started")
+    [Console]::Error.WriteLine("${CYAN}✓${RESET} New session started")
 }
 [Console]::Error.WriteLine("")