@ekkos/cli 1.0.34 → 1.0.36

package/templates/hooks/assistant-response.ps1

@@ -2,117 +2,66 @@
 # ekkOS_ Hook: AssistantResponse - Process Claude's response (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"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
+# CONFIG PATHS
 # ═══════════════════════════════════════════════════════════════════════════
 $EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { "$env:USERPROFILE\.ekkos" }
 $HooksEnabledJson = "$EkkosConfigDir\hooks-enabled.json"
 $HooksEnabledDefault = "$EkkosConfigDir\.defaults\hooks-enabled.json"
 $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" }
 
+$MemoryApiUrl = "https://api.ekkos.dev"
+
 # ═══════════════════════════════════════════════════════════════════════════
-# CHECK ENABLEMENT - Respect hooks-enabled.json
+# CHECK ENABLEMENT
 # ═══════════════════════════════════════════════════════════════════════════
 function Test-HookEnabled {
     param([string]$HookName)
-
     $enabledFile = $HooksEnabledJson
-    if (-not (Test-Path $enabledFile)) {
-        $enabledFile = $HooksEnabledDefault
-    }
-
-    if (-not (Test-Path $enabledFile)) {
-        # No enablement file = all enabled by default
-        return $true
-    }
-
+    if (-not (Test-Path $enabledFile)) { $enabledFile = $HooksEnabledDefault }
+    if (-not (Test-Path $enabledFile)) { return $true }
     try {
         $config = Get-Content $enabledFile -Raw | ConvertFrom-Json
-
-        # Check claude.enabled array
         if ($config.claude -and $config.claude.enabled) {
             $enabledHooks = $config.claude.enabled
-            if ($enabledHooks -contains $HookName -or $enabledHooks -contains "assistant-response") {
-                return $true
-            }
+            if ($enabledHooks -contains $HookName -or $enabledHooks -contains "assistant-response") { return $true }
             return $false
         }
-
-        return $true  # Default to enabled if no config
-    } catch {
-        return $true  # Default to enabled on error
-    }
+        return $true
+    } catch { return $true }
 }
 
-# Check if this hook is enabled
-if (-not (Test-HookEnabled "assistant-response")) {
-    exit 0
-}
+if (-not (Test-HookEnabled "assistant-response")) { exit 0 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load session words from JSON file - NO HARDCODED ARRAYS
+# Load session words - NO HARDCODED ARRAYS
 # ═══════════════════════════════════════════════════════════════════════════
 $script:SessionWords = $null
 
 function Load-SessionWords {
     $wordsFile = $SessionWordsJson
-
-    # Fallback to managed defaults if user file missing/invalid
-    if (-not (Test-Path $wordsFile)) {
-        $wordsFile = $SessionWordsDefault
-    }
-
-    if (-not (Test-Path $wordsFile)) {
-        return $null
-    }
-
+    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
-    }
+    } catch { return $null }
 }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# SESSION NAME (UUID to words) - Uses external session-words.json
-# ═══════════════════════════════════════════════════════════════════════════
 function Convert-UuidToWords {
     param([string]$uuid)
-
-    # Load session words if not already loaded
-    if (-not $script:SessionWords) {
-        Load-SessionWords
-    }
-
-    # Handle missing session words gracefully
-    if (-not $script:SessionWords) {
-        return "unknown-session"
-    }
+    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 $adjectives -or -not $nouns -or -not $verbs) { return "unknown-session" }
     if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
     $clean = $uuid -replace "-", ""
@@ -122,11 +71,8 @@ function Convert-UuidToWords {
         $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"
-    }
+    } catch { return "unknown-session" }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -135,23 +81,16 @@ function Convert-UuidToWords {
 $inputJson = [Console]::In.ReadToEnd()
 if (-not $inputJson) { exit 0 }
 
-try {
-    $input = $inputJson | ConvertFrom-Json
-} catch {
-    exit 0
-}
+try { $input = $inputJson | ConvertFrom-Json } catch { exit 0 }
 
-# Extract response content
 $assistantResponse = $input.response
 if (-not $assistantResponse) { $assistantResponse = $input.message }
 if (-not $assistantResponse) { $assistantResponse = $input.content }
 if (-not $assistantResponse) { exit 0 }
 
-# Get session ID
 $rawSessionId = $input.session_id
 if (-not $rawSessionId -or $rawSessionId -eq "null") { $rawSessionId = "unknown" }
 
-# Fallback: read session_id from saved state
 if ($rawSessionId -eq "unknown") {
     $stateFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
     if (Test-Path $stateFile) {
@@ -167,16 +106,13 @@ $sessionName = Convert-UuidToWords $rawSessionId
 # ═══════════════════════════════════════════════════════════════════════════
 # READ TURN STATE
 # ═══════════════════════════════════════════════════════════════════════════
-$stateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
+$hookStateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
 $turn = 0
-
-if (Test-Path $stateFile) {
+if (Test-Path $hookStateFile) {
     try {
-        $hookState = Get-Content $stateFile -Raw | ConvertFrom-Json
+        $hookState = Get-Content $hookStateFile -Raw | ConvertFrom-Json
         $turn = [int]$hookState.turn
-    } catch {
-        $turn = 0
-    }
+    } catch { $turn = 0 }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -184,7 +120,6 @@ if (Test-Path $stateFile) {
 # ═══════════════════════════════════════════════════════════════════════════
 $patternIds = @()
 if ($assistantResponse -match '\[ekkOS_SELECT\]') {
-    # Extract pattern IDs from SELECT blocks
     $selectMatches = [regex]::Matches($assistantResponse, 'id:\s*([a-zA-Z0-9\-_]+)')
     foreach ($match in $selectMatches) {
         $patternIds += $match.Groups[1].Value
@@ -192,18 +127,15 @@ if ($assistantResponse -match '\[ekkOS_SELECT\]') {
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Tier 0 capture (async, non-blocking)
-# Per v1.2 ADDENDUM: Pass instanceId for namespacing
+# LOCAL CACHE: Tier 0 capture (async)
 # ═══════════════════════════════════════════════════════════════════════════
 $captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
 if ($captureCmd -and $rawSessionId -ne "unknown") {
     try {
-        # NEW format: ekkos-capture response <instance_id> <session_id> <turn_id> <response> [tools] [files]
         $responseBase64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($assistantResponse))
         $toolsJson = "[]"
         $filesJson = "[]"
 
-        # Extract tools used from response
         $toolMatches = [regex]::Matches($assistantResponse, '\[TOOL:\s*([^\]]+)\]')
         if ($toolMatches.Count -gt 0) {
             $tools = $toolMatches | ForEach-Object { $_.Groups[1].Value } | Select-Object -Unique
@@ -221,7 +153,7 @@ if ($captureCmd -and $rawSessionId -ne "unknown") {
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORKING MEMORY: Fast capture to API (async, non-blocking)
+# WORKING MEMORY: Fast capture to API (async)
 # ═══════════════════════════════════════════════════════════════════════════
 $configFile = Join-Path $EkkosConfigDir "config.json"
 if (Test-Path $configFile) {
@@ -242,7 +174,7 @@ if (Test-Path $configFile) {
                     pattern_ids = $patterns
                 } | ConvertTo-Json -Depth 10
 
-                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/turn" `
+                Invoke-RestMethod -Uri "https://api.ekkos.dev/api/v1/working/turn" `
                     -Method POST `
                     -Headers @{ Authorization = "Bearer $token" } `
                     -ContentType "application/json" `

package/templates/hooks/session-start.ps1

@@ -1,29 +1,28 @@
 # ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: SessionStart - Initialize session (Windows)
+# ekkOS_ Hook: SessionStart - MINIMAL + TIME MACHINE + DIRECTIVES (Windows)
 # MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
 # EKKOS_MANAGED=1
-# EKKOS_MANIFEST_SHA256=<computed-at-build>
-# EKKOS_TEMPLATE_VERSION=1.0.0
+# ═══════════════════════════════════════════════════════════════════════════
+# This hook does THREE things:
+# 1. Check for pending Time Machine "Continue from here" requests
+# 2. Initialize session tracking + Golden Loop
+# 3. Fetch and inject user directives (MUST/NEVER/PREFER/AVOID)
 #
-# 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
+# Per spec v1.2 Addendum: NO hardcoded arrays, uses session-words.json
 # ═══════════════════════════════════════════════════════════════════════════
 
 $ErrorActionPreference = "SilentlyContinue"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
+# CONFIG PATHS
 # ═══════════════════════════════════════════════════════════════════════════
 $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" }
 
+$MemoryApiUrl = "https://api.ekkos.dev"
+
 # ═══════════════════════════════════════════════════════════════════════════
 # Load session words from JSON file - NO HARDCODED ARRAYS
 # ═══════════════════════════════════════════════════════════════════════════
@@ -31,41 +30,22 @@ $script:SessionWords = $null
 
 function Load-SessionWords {
     $wordsFile = $SessionWordsJson
-
-    if (-not (Test-Path $wordsFile)) {
-        $wordsFile = $SessionWordsDefault
-    }
-
-    if (-not (Test-Path $wordsFile)) {
-        return $null
-    }
-
+    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
-    }
+    } catch { return $null }
 }
 
 function Convert-UuidToWords {
     param([string]$uuid)
-
-    if (-not $script:SessionWords) {
-        Load-SessionWords
-    }
-
-    if (-not $script:SessionWords) {
-        return "unknown-session"
-    }
+    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 $adjectives -or -not $nouns -or -not $verbs) { return "unknown-session" }
     if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
     $clean = $uuid -replace "-", ""
@@ -75,36 +55,116 @@ function Convert-UuidToWords {
         $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"
-    }
+    } catch { return "unknown-session" }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # READ INPUT
 # ═══════════════════════════════════════════════════════════════════════════
 $inputJson = [Console]::In.ReadToEnd()
-
 try {
     $input = $inputJson | ConvertFrom-Json
     $sessionId = $input.session_id
 } catch {
     $sessionId = "unknown"
 }
+if (-not $sessionId) { $sessionId = "unknown" }
 
 $sessionName = Convert-UuidToWords $sessionId
 
 # ═══════════════════════════════════════════════════════════════════════════
-# INITIALIZE STATE DIRECTORY
+# LOAD AUTH
+# ═══════════════════════════════════════════════════════════════════════════
+$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
 # ═══════════════════════════════════════════════════════════════════════════
+$timeMachineSession = ""
+$timeMachineFromTurn = ""
+$timeMachineToTurn = ""
+$restoreRequestId = $env:EKKOS_RESTORE
+
+if (-not $timeMachineSession -and $userId) {
+    try {
+        $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("${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 PERSISTENCE - PROJECT-LOCAL for isolation
+# ═══════════════════════════════════════════════════════════════════════════
+$projectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
 $stateDir = Join-Path $env:USERPROFILE ".claude\state"
-if (-not (Test-Path $stateDir)) {
-    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
+$projectSessionDir = Join-Path $stateDir "sessions"
+
+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 }
+
+$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 {
+        $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 }
+        }
+    }
 }
 
-# Reset turn counter for new session
+$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
@@ -113,34 +173,137 @@ $state = @{
     instance_id = $EkkosInstanceId
     started_at = (Get-Date).ToString("o")
 } | ConvertTo-Json -Depth 10
-
 Set-Content -Path $stateFile -Value $state -Force
 
-# Save session ID for other hooks
-$sessionFile = Join-Path $stateDir "current-session.json"
-$sessionData = @{
-    session_id = $sessionId
-    session_name = $sessionName
-    instance_id = $EkkosInstanceId
-} | ConvertTo-Json -Depth 10
+# ═══════════════════════════════════════════════════════════════════════════
+# GOLDEN LOOP: Initialize session tracking file
+# ═══════════════════════════════════════════════════════════════════════════
+$ekkosDir = Join-Path $projectRoot ".ekkos"
+if (-not (Test-Path $ekkosDir)) { New-Item -ItemType Directory -Path $ekkosDir -Force | Out-Null }
 
-Set-Content -Path $sessionFile -Value $sessionData -Force
+$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
 
 # ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Initialize session in Tier 0 cache
-# Per v1.2 ADDENDUM: Pass instanceId for namespacing
+# LOCAL CACHE: Initialize session
 # ═══════════════════════════════════════════════════════════════════════════
 $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 {}
+            try { & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null } catch {}
         } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName | Out-Null
     } catch {}
 }
 
-Write-Output "ekkOS session initialized"
+# ═══════════════════════════════════════════════════════════════════════════
+# 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("")
+    $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" }
+    }
+
+    $recallJson = $recallBody | ConvertTo-Json -Depth 10
+    try {
+        $restoreResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/turns/recall" `
+            -Method POST `
+            -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"
+            }
+            Write-Output $turnsOutput
+
+            [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
+# ═══════════════════════════════════════════════════════════════════════════
+if ($authToken) {
+    try {
+        $directivesResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/memory/directives?limit=20" `
+            -Method GET -Headers @{ "Authorization" = "Bearer $authToken" } -TimeoutSec 3
+
+        $directiveCount = $directivesResponse.count
+        if ($directiveCount -gt 0) {
+            Write-Output "<system-reminder>"
+            Write-Output "USER DIRECTIVES (FOLLOW THESE):"
+            Write-Output ""
+
+            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}  $directiveCount directives loaded${RESET}")
+        }
+    } catch {}
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# STATUS DISPLAY
+# ═══════════════════════════════════════════════════════════════════════════
+if ($savedTurnCount -gt 0) {
+    [Console]::Error.WriteLine("")
+    [Console]::Error.WriteLine("${CYAN}${BOLD}  ekkOS${RESET} ${DIM}|${RESET} Session: $sessionId ${DIM}|${RESET} ${GREEN}$savedTurnCount turns${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("")
+
+exit 0

package/templates/hooks/session-start.sh

@@ -78,7 +78,7 @@ fi
 
 [ -z "$AUTH_TOKEN" ] && exit 0
 
-MEMORY_API_URL="https://mcp.ekkos.dev"
+MEMORY_API_URL="https://api.ekkos.dev"
 
 # ═══════════════════════════════════════════════════════════════════════════
 # TIME MACHINE: Check for pending "Continue from here" requests