@ekkos/cli 1.0.34 → 1.0.36

package/templates/hooks/user-prompt-submit.ps1

@@ -3,7 +3,12 @@
 # MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
 # EKKOS_MANAGED=1
 # EKKOS_MANIFEST_SHA256=<computed-at-build>
-# EKKOS_TEMPLATE_VERSION=1.0.0
+# EKKOS_TEMPLATE_VERSION=2.0.0
+#
+# ZERO USER ACTION NEEDED:
+# 1. Tracks turn number and context size
+# 2. Detects when compaction happened (context dropped from high to low)
+# 3. AUTO-INJECTS restored context - user just keeps working
 #
 # Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
 # - All persisted records MUST include: instanceId, sessionId, sessionName
@@ -12,18 +17,27 @@
 
 $ErrorActionPreference = "SilentlyContinue"
 
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
+
 # ═══════════════════════════════════════════════════════════════════════════
 # 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"
+$JsonParseHelper = "$EkkosConfigDir\.helpers\json-parse.cjs"
 
 # ═══════════════════════════════════════════════════════════════════════════
 # INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
 # ═══════════════════════════════════════════════════════════════════════════
 $EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
+# ═══════════════════════════════════════════════════════════════════════════
+# API URL
+# ═══════════════════════════════════════════════════════════════════════════
+$MemoryApiUrl = "https://api.ekkos.dev"
+
 # ═══════════════════════════════════════════════════════════════════════════
 # Load session words from JSON file - NO HARDCODED ARRAYS
 # ═══════════════════════════════════════════════════════════════════════════
@@ -48,7 +62,9 @@ function Load-SessionWords {
     }
 }
 
+# ═══════════════════════════════════════════════════════════════════════════
 # Read input from stdin
+# ═══════════════════════════════════════════════════════════════════════════
 $inputJson = [Console]::In.ReadToEnd()
 if (-not $inputJson) { exit 0 }
 
@@ -65,15 +81,24 @@ if (-not $userQuery) { exit 0 }
 
 $rawSessionId = $input.session_id
 if (-not $rawSessionId -or $rawSessionId -eq "null") { $rawSessionId = "unknown" }
+$transcriptPath = $input.transcript_path
 
 # Fallback: read session_id from saved state
-if ($rawSessionId -eq "unknown") {
+if ($rawSessionId -eq "unknown" -or $rawSessionId -eq "null" -or [string]::IsNullOrEmpty($rawSessionId)) {
     $stateFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
-    if (Test-Path $stateFile) {
+    if ((Test-Path $stateFile) -and (Test-Path $JsonParseHelper)) {
         try {
-            $state = Get-Content $stateFile -Raw | ConvertFrom-Json
-            $rawSessionId = $state.session_id
-        } catch {}
+            $rawSessionId = node $JsonParseHelper $stateFile '.session_id' 2>$null
+            if (-not $rawSessionId) { $rawSessionId = "unknown" }
+        } catch {
+            $rawSessionId = "unknown"
+        }
+    }
+
+    # VSCode extension fallback: Extract session ID from transcript path
+    # Path format: ~/.claude/projects/<project>/<session-uuid>.jsonl
+    if ($rawSessionId -eq "unknown" -and $transcriptPath -and (Test-Path $transcriptPath)) {
+        $rawSessionId = [System.IO.Path]::GetFileNameWithoutExtension($transcriptPath)
     }
 }
 
@@ -108,6 +133,20 @@ if ($queryLower -match '(sql|query|supabase|prisma|database|table|column|select
     $skillReminders += "SCHEMA REQUIRED: Call ekkOS_GetSchema for correct field names"
 }
 
+# ═══════════════════════════════════════════════════════════════════════════
+# Load auth - Read from config.json
+# ═══════════════════════════════════════════════════════════════════════════
+$EkkosConfig = Join-Path $EkkosConfigDir "config.json"
+$authToken = ""
+if ((Test-Path $EkkosConfig) -and (Test-Path $JsonParseHelper)) {
+    try {
+        $authToken = node $JsonParseHelper $EkkosConfig '.hookApiKey' 2>$null
+        if (-not $authToken) {
+            $authToken = node $JsonParseHelper $EkkosConfig '.apiKey' 2>$null
+        }
+    } catch {}
+}
+
 # ═══════════════════════════════════════════════════════════════════════════
 # SESSION NAME - Resolve early so it's available for all downstream use
 # ═══════════════════════════════════════════════════════════════════════════
@@ -137,158 +176,282 @@ function Convert-UuidToWords {
     }
 }
 
-$sessionName = Convert-UuidToWords $rawSessionId
+$sessionId = $rawSessionId
+if (-not $sessionId -or $sessionId -eq "unknown" -or $sessionId -eq "null") {
+    exit 0
+}
+
+# Check if SESSION_ID is a UUID (8-4-4-4-12 format)
+$isUuid = $sessionId -match '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+
+$sessionName = ""
+if ($isUuid) {
+    $sessionName = Convert-UuidToWords $sessionId
+} else {
+    $sessionName = $sessionId
+}
 
 # ═══════════════════════════════════════════════════════════════════════════
-# PROXY SESSION BIND: _pending → real session name (fires every turn)
-# Mirrors bash user-prompt-submit.sh lines 319-338.
-# No PTY on Windows so run.ts can't detect session name — hook must bind it.
+# STATE DIRECTORIES
 # ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session" -and $rawSessionId -ne "unknown") {
-    $configFile = Join-Path $EkkosConfigDir "config.json"
-    if (Test-Path $configFile) {
-        try {
-            $config = Get-Content $configFile -Raw | ConvertFrom-Json
-            $userId = $config.userId
-            if ($userId) {
-                $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
-                $pendingSession = if ($env:EKKOS_PENDING_SESSION) { $env:EKKOS_PENDING_SESSION } else { "_pending" }
-                $projectPath = $projectPath -replace '\\', '/'
-                $bindBody = @{
-                    userId         = $userId
-                    realSession    = $sessionName
-                    projectPath    = $projectPath
-                    pendingSession = $pendingSession
-                } | ConvertTo-Json -Depth 10 -Compress
-
-                Start-Job -ScriptBlock {
-                    param($body)
-                    Invoke-RestMethod -Uri "https://mcp.ekkos.dev/proxy/session/bind" `
-                        -Method POST `
-                        -Headers @{ "Content-Type" = "application/json" } `
-                        -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue | Out-Null
-                } -ArgumentList $bindBody | Out-Null
-            }
-        } catch {}
-    }
+$stateDir = Join-Path $ProjectRoot ".claude\state"
+if (-not (Test-Path $stateDir)) {
+    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
 }
+$sessionFile = Join-Path $stateDir "current-session.json"
+
+$projectSessionDir = Join-Path $stateDir "sessions"
+if (-not (Test-Path $projectSessionDir)) {
+    New-Item -ItemType Directory -Path $projectSessionDir -Force | Out-Null
+}
+$turnCounterFile = Join-Path $projectSessionDir "$sessionId.turn"
+$contextSizeFile = Join-Path $projectSessionDir "$sessionId.context"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# SESSION CURRENT: Update Redis with current session name
+# Turn counter - TRANSCRIPT-BASED (source of truth)
+# Count "type":"user" entries in transcript JSONL
 # ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session" -and $rawSessionId -ne "unknown") {
-    $configFile2 = Join-Path $EkkosConfigDir "config.json"
-    if (Test-Path $configFile2) {
-        try {
-            $config2 = Get-Content $configFile2 -Raw | ConvertFrom-Json
-            $sessionToken = $config2.hookApiKey
-            if (-not $sessionToken) { $sessionToken = $config2.apiKey }
-            if ($sessionToken) {
-                $sessionBody = @{ session_name = $sessionName } | ConvertTo-Json -Depth 10
-                Start-Job -ScriptBlock {
-                    param($body, $token)
-                    Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/session/current" `
-                        -Method POST `
-                        -Headers @{ Authorization = "Bearer $token"; "Content-Type" = "application/json" } `
-                        -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue | Out-Null
-                } -ArgumentList $sessionBody, $sessionToken | Out-Null
-            }
-        } catch {}
+$turnNumber = 1
+if ($transcriptPath -and (Test-Path $transcriptPath)) {
+    try {
+        $turnNumber = node -e "
+const fs = require('fs');
+const lines = fs.readFileSync(process.argv[1], 'utf8').split('\n').filter(Boolean);
+let count = 0;
+for (const line of lines) {
+    try { if (JSON.parse(line).type === 'user') count++; } catch(e) {}
+}
+console.log(count || 1);
+" $transcriptPath 2>$null
+        $turnNumber = [int]$turnNumber
+        if ($turnNumber -eq 0) { $turnNumber = 1 }
+    } catch {
+        $turnNumber = 1
+    }
+}
+
+# Detect post-clear: saved count higher than transcript means /clear happened
+$savedTurnCount = 0
+if (Test-Path $turnCounterFile) {
+    try {
+        $savedTurnCount = [int](Get-Content $turnCounterFile -Raw).Trim()
+    } catch {
+        $savedTurnCount = 0
     }
 }
 
+$postClearDetected = $false
+if ($savedTurnCount -gt $turnNumber) {
+    $postClearDetected = $true
+    $turnNumber = $savedTurnCount + 1
+}
+
+# Save current turn count
+Set-Content -Path $turnCounterFile -Value $turnNumber -Force
+
 # ═══════════════════════════════════════════════════════════════════════════
-# TURN TRACKING & STATE MANAGEMENT
+# Context size tracking - Uses tokenizer script (single source)
 # ═══════════════════════════════════════════════════════════════════════════
-$stateDir = Join-Path $env:USERPROFILE ".claude\state"
-if (-not (Test-Path $stateDir)) {
-    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
+$prevContextPercent = 0
+if (Test-Path $contextSizeFile) {
+    try {
+        $prevContextPercent = [int](Get-Content $contextSizeFile -Raw).Trim()
+    } catch {
+        $prevContextPercent = 0
+    }
 }
 
-$stateFile = Join-Path $stateDir "hook-state.json"
-$turn = 0
-$contextPercent = ""
+$tokenPercent = 0
+$ipcPercent = 0
+$maxTokens = 200000
+$tokenizerScript = Join-Path $ScriptDir "lib\count-tokens.cjs"
 
-if (Test-Path $stateFile) {
+if ($transcriptPath -and (Test-Path $transcriptPath) -and (Test-Path $tokenizerScript)) {
     try {
-        $hookState = Get-Content $stateFile -Raw | ConvertFrom-Json
-        # Only continue incrementing if this state belongs to the SAME session.
-        # If session changed, reset turn counter to 0.
-        if ($hookState.session_id -eq $rawSessionId) {
-            $turn = [int]$hookState.turn + 1
-        } else {
-            $turn = 0
+        $tokenCount = node $tokenizerScript $transcriptPath 2>$null
+        if ($tokenCount -match '^\d+$' -and [int]$tokenCount -gt 0) {
+            $tokenPercent = [int]([int]$tokenCount * 100 / $maxTokens)
+            if ($tokenPercent -gt 100) { $tokenPercent = 100 }
+            # In proxy mode, IPC compresses ~65-70% - show estimated post-compression %
+            $ipcPercent = [int]($tokenPercent * 30 / 100)
+            if ($ipcPercent -lt 1) { $ipcPercent = 1 }
         }
-    } catch {
-        $turn = 0
-    }
+    } catch {}
 }
 
-# Save updated state
-$newState = @{
-    turn = $turn
-    session_id = $rawSessionId
-    last_query = $userQuery.Substring(0, [Math]::Min(100, $userQuery.Length))
-    timestamp = (Get-Date).ToString("o")
-} | ConvertTo-Json -Depth 10
+Set-Content -Path $contextSizeFile -Value $tokenPercent -Force
 
-Set-Content -Path $stateFile -Value $newState -Force
+# ═══════════════════════════════════════════════════════════════════════════
+# 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"
+
+$timestamp = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt") + " EST"
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SINGLE SOURCE OF TRUTH: Update ALL session tracking systems
+# ═══════════════════════════════════════════════════════════════════════════
+if ($sessionName -and $sessionName -ne "unknown-session") {
+    $utcTimestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+    $projectPathUnix = $projectPath -replace '\\', '/'
+
+    # 1. Project-level state file
+    try {
+        $stateJson = @{
+            session_id   = $sessionId
+            session_name = $sessionName
+            timestamp    = $utcTimestamp
+        } | ConvertTo-Json -Depth 10 -Compress
+        Set-Content -Path $sessionFile -Value $stateJson -Force
+    } catch {}
+
+    # 2. Global ekkOS state (for extension LOCAL-FIRST read)
+    $ekkosGlobalState = Join-Path $EkkosConfigDir "current-session.json"
+    try {
+        if (-not (Test-Path $EkkosConfigDir)) {
+            New-Item -ItemType Directory -Path $EkkosConfigDir -Force | Out-Null
+        }
+        $globalJson = @{
+            session_id   = $sessionId
+            session_name = $sessionName
+            project      = $ProjectRoot
+            timestamp    = $utcTimestamp
+        } | ConvertTo-Json -Depth 10 -Compress
+        Set-Content -Path $ekkosGlobalState -Value $globalJson -Force
+    } catch {}
+
+    # 3. CLI state file
+    $cliStateFile = Join-Path $EkkosConfigDir "state.json"
+    try {
+        $cliJson = @{
+            sessionId   = $sessionId
+            sessionName = $sessionName
+            turnNumber  = $turnNumber
+            lastUpdated = $utcTimestamp
+            projectPath = $ProjectRoot
+        } | ConvertTo-Json -Depth 10 -Compress
+        Set-Content -Path $cliStateFile -Value $cliJson -Force
+    } catch {}
+
+    # 4. Multi-session tracking - upsert into active-sessions.json
+    $activeSessionsFile = Join-Path $EkkosConfigDir "active-sessions.json"
+    try {
+        node -e "
+const fs = require('fs');
+const sid = process.argv[1], sname = process.argv[2], ts = process.argv[3], proj = process.argv[4];
+try {
+    let sessions = [];
+    const filePath = process.argv[5];
+    if (fs.existsSync(filePath)) {
+        sessions = JSON.parse(fs.readFileSync(filePath, 'utf8') || '[]');
+    }
+    const idx = sessions.findIndex(s => s.sessionId === sid);
+    if (idx >= 0) {
+        sessions[idx] = {...sessions[idx], sessionName: sname, lastHeartbeat: ts, projectPath: proj};
+    } else {
+        sessions.push({sessionId: sid, sessionName: sname, pid: 0, startedAt: ts, projectPath: proj, lastHeartbeat: ts});
+    }
+    fs.writeFileSync(filePath, JSON.stringify(sessions, null, 2));
+} catch(e) {}
+" $sessionId $sessionName $utcTimestamp $ProjectRoot $activeSessionsFile 2>$null
+    } catch {}
+
+    # 5. Update Redis via API (async)
+    if ($authToken) {
+        $sessionBody = @{ session_name = $sessionName } | ConvertTo-Json -Depth 10 -Compress
+        Start-Job -ScriptBlock {
+            param($body, $token, $apiUrl)
+            try {
+                Invoke-RestMethod -Uri "$apiUrl/api/v1/working/session/current" `
+                    -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 $sessionBody, $authToken, $MemoryApiUrl | Out-Null
+    }
+
+    # 6. CRITICAL: Bind session name to proxy for R2 eviction paths
+    $ekkosUserId = ""
+    if ((Test-Path $EkkosConfig) -and (Test-Path $JsonParseHelper)) {
+        try {
+            $ekkosUserId = node $JsonParseHelper $EkkosConfig '.userId' 2>$null
+        } catch {}
+    }
+    if ($ekkosUserId -and $sessionName) {
+        $pendingSession = if ($env:EKKOS_PENDING_SESSION) { $env:EKKOS_PENDING_SESSION } else { "_pending" }
+        $bindBody = @{
+            userId         = $ekkosUserId
+            realSession    = $sessionName
+            projectPath    = $projectPathUnix
+            pendingSession = $pendingSession
+        } | ConvertTo-Json -Depth 10 -Compress
+
+        Start-Job -ScriptBlock {
+            param($body, $apiUrl)
+            try {
+                Invoke-RestMethod -Uri "$apiUrl/proxy/session/bind" `
+                    -Method POST `
+                    -Headers @{ "Content-Type" = "application/json" } `
+                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
+                    -TimeoutSec 3 -ErrorAction SilentlyContinue | Out-Null
+            } catch {}
+        } -ArgumentList $bindBody, $MemoryApiUrl | Out-Null
+    }
+}
 
 # ═══════════════════════════════════════════════════════════════════════════
 # LOCAL CACHE: Tier 0 capture (async, non-blocking)
 # Per v1.2 ADDENDUM: Pass instanceId for namespacing
 # ═══════════════════════════════════════════════════════════════════════════
 $captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
-if ($captureCmd -and $rawSessionId -ne "unknown") {
+if ($captureCmd -and $sessionId -ne "unknown") {
     try {
-        # NEW format: ekkos-capture user <instance_id> <session_id> <session_name> <turn_id> <query> [project_path]
         $queryBase64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($userQuery))
-        $projectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+        $captureProjectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
 
         Start-Job -ScriptBlock {
-            param($instanceId, $sessionId, $sessionName, $turnNum, $queryB64, $projectPath)
+            param($instanceId, $sid, $sname, $turnNum, $queryB64, $projPath)
             try {
                 $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($queryB64))
-                & ekkos-capture user $instanceId $sessionId $sessionName $turnNum $decoded $projectPath 2>&1 | Out-Null
+                & ekkos-capture user $instanceId $sid $sname $turnNum $decoded $projPath 2>&1 | Out-Null
             } catch {}
-        } -ArgumentList $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $queryBase64, $projectRoot | Out-Null
+        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName, $turnNumber, $queryBase64, $captureProjectRoot | Out-Null
     } catch {}
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # WORKING MEMORY: Fast capture to API (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
-$configFile = Join-Path $EkkosConfigDir "config.json"
-if (Test-Path $configFile) {
+if ($authToken) {
     try {
-        $config = Get-Content $configFile -Raw | ConvertFrom-Json
-        $captureToken = $config.hookApiKey
-        if (-not $captureToken) { $captureToken = $config.apiKey }
-
-        if ($captureToken) {
-            # Async capture using Start-Job (non-blocking)
-            Start-Job -ScriptBlock {
-                param($token, $instanceId, $sessionId, $sessionName, $turnNum, $query)
-                $body = @{
-                    session_id = $sessionId
-                    session_name = $sessionName
-                    instance_id = $instanceId
-                    turn = $turnNum
-                    query = $query
-                } | ConvertTo-Json -Depth 10
-
-                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/fast-capture" `
+        Start-Job -ScriptBlock {
+            param($token, $instanceId, $sid, $sname, $turnNum, $query, $apiUrl)
+            $body = @{
+                session_id    = $sid
+                session_name  = $sname
+                instance_id   = $instanceId
+                turn          = $turnNum
+                query         = $query
+            } | ConvertTo-Json -Depth 10
+            try {
+                Invoke-RestMethod -Uri "$apiUrl/api/v1/working/fast-capture" `
                     -Method POST `
-                    -Headers @{ Authorization = "Bearer $token" } `
-                    -ContentType "application/json" `
-                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue
-            } -ArgumentList $captureToken, $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $userQuery | Out-Null
-        }
+                    -Headers @{ Authorization = "Bearer $token"; "Content-Type" = "application/json" } `
+                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
+                    -TimeoutSec 3 -ErrorAction SilentlyContinue | Out-Null
+            } catch {}
+        } -ArgumentList $authToken, $EkkosInstanceId, $sessionId, $sessionName, $turnNumber, $userQuery, $MemoryApiUrl | Out-Null
     } catch {}
 }
 
-$timestamp = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt") + " EST"
-
 # ═══════════════════════════════════════════════════════════════════════════
 # DASHBOARD HINT FILE: write session info for ekkos dashboard --wait-for-new
 # On Windows, active-sessions.json is never populated (hook PIDs are dead).
@@ -296,12 +459,12 @@ $timestamp = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt") + " EST"
 # ═══════════════════════════════════════════════════════════════════════════
 if ($sessionName -ne "unknown-session") {
     try {
-        $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+        $hintProjectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
         $hintFile = Join-Path $EkkosConfigDir "hook-session-hint.json"
         $hint = @{
             sessionName = $sessionName
-            sessionId   = $rawSessionId
-            projectPath = $projectPath
+            sessionId   = $sessionId
+            projectPath = $hintProjectPath
             ts          = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
         } | ConvertTo-Json -Depth 10 -Compress
         Set-Content -Path $hintFile -Value $hint -Force
@@ -309,24 +472,251 @@ if ($sessionName -ne "unknown-session") {
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# OUTPUT SYSTEM REMINDER
+# "/continue" COMMAND: Run AFTER /clear to restore last 5 turns
 # ═══════════════════════════════════════════════════════════════════════════
-$esc = [char]27
-$header = "${esc}[0;36m${esc}[1m🧠 ekkOS Memory${esc}[0m ${esc}[2m| $sessionName | $timestamp${esc}[0m"
+$queryLowerTrimmed = $queryLower.Trim()
+
+if ($queryLowerTrimmed -eq "/continue" -or $queryLowerTrimmed -match '^/continue\s' -or $queryLowerTrimmed -eq "continue" -or $queryLowerTrimmed -eq "continue.") {
+    if ($authToken) {
+        try {
+            $restoreBody = @{
+                session_id = "current"
+                last_n     = 5
+                format     = "detailed"
+            } | ConvertTo-Json -Depth 10 -Compress
+            $restoreBodyBytes = [System.Text.Encoding]::UTF8.GetBytes($restoreBody)
+
+            $restoreResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/turns/recall" `
+                -Method POST `
+                -Headers @{ Authorization = "Bearer $authToken"; "Content-Type" = "application/json" } `
+                -Body $restoreBodyBytes `
+                -TimeoutSec 5 -ErrorAction Stop
+        } catch {
+            $restoreResponse = @{ turns = @() }
+        }
+
+        $restoreJson = $restoreResponse | ConvertTo-Json -Depth 20 -Compress
+        $restoredCount = 0
+        $lastTask = "unknown task"
+        $lastResponse = ""
+
+        try {
+            $restoredCount = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+console.log((d.turns || []).length);
+" $restoreJson 2>$null
+            $restoredCount = [int]$restoredCount
+        } catch { $restoredCount = 0 }
+
+        try {
+            $lastTask = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+const turns = d.turns || [];
+console.log((turns[turns.length-1]?.user_query || 'unknown task').substring(0, 200));
+" $restoreJson 2>$null
+        } catch { $lastTask = "unknown task" }
+
+        try {
+            $lastResponse = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+const turns = d.turns || [];
+console.log((turns[turns.length-1]?.assistant_response || '').substring(0, 500));
+" $restoreJson 2>$null
+        } catch { $lastResponse = "" }
+
+        Write-Output ""
+        Write-Output "${GREEN}${BOLD}Session continued${RESET} ${DIM}(${restoredCount} turns restored)${RESET}"
+        Write-Output ""
+
+        $continueOutput = @"
+<system-reminder>
+$("=" * 75)
+CONTEXT RESTORED - Resume seamlessly. DO NOT ask 'what were we doing?'
+$("=" * 75)
+
+## Last User Request:
+$lastTask
 
-$output = @"
-$header
+## Your Last Response (truncated):
+$lastResponse
 
 "@
 
-if ($skillReminders.Count -gt 0) {
-    $output += "${esc}[0;35m${esc}[1m" + ($skillReminders -join "`n") + "${esc}[0m`n"
+        if ($restoredCount -gt 1) {
+            $continueOutput += "## Recent Context (older -> newer):`n"
+            try {
+                $recentContext = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+const turns = d.turns || [];
+turns.slice(0, -1).forEach(t => {
+    const q = (t.user_query || '...').substring(0, 100);
+    console.log('- Turn ' + (t.turn_number || '?') + ': ' + q + '...');
+});
+" $restoreJson 2>$null
+                $continueOutput += "$recentContext`n"
+            } catch {}
+            $continueOutput += "`n"
+        }
+
+        $continueOutput += @"
+$("=" * 75)
+INSTRUCTION: Start your response with 'Continuing -' then pick up
+exactly where you left off. If mid-task, continue it. If done, ask what's next.
+$("=" * 75)
+</system-reminder>
+"@
+
+        Write-Output $continueOutput
+        Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| ${timestamp}${RESET}"
+        exit 0
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# COMPACTION DETECTION: If context dropped dramatically, auto-restore
+# Was >50% last turn, now <15% = compaction happened
+# ═══════════════════════════════════════════════════════════════════════════
+if ($prevContextPercent -gt 50 -and $tokenPercent -lt 15 -and $authToken) {
+    Write-Output ""
+    Write-Output "${GREEN}${BOLD}CONTEXT RESTORED${RESET} ${DIM}| Compaction detected | Auto-loading recent turns...${RESET}"
+
+    try {
+        $compactBody = @{
+            session_id = $sessionId
+            last_n     = 10
+            format     = "summary"
+        } | ConvertTo-Json -Depth 10 -Compress
+        $compactBodyBytes = [System.Text.Encoding]::UTF8.GetBytes($compactBody)
+
+        $compactResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/turns/recall" `
+            -Method POST `
+            -Headers @{ Authorization = "Bearer $authToken"; "Content-Type" = "application/json" } `
+            -Body $compactBodyBytes `
+            -TimeoutSec 5 -ErrorAction Stop
+    } catch {
+        $compactResponse = @{ turns = @() }
+    }
+
+    $compactJson = $compactResponse | ConvertTo-Json -Depth 20 -Compress
+    $compactRestoredCount = 0
+    try {
+        $compactRestoredCount = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+console.log((d.turns || []).length);
+" $compactJson 2>$null
+        $compactRestoredCount = [int]$compactRestoredCount
+    } catch { $compactRestoredCount = 0 }
+
+    if ($compactRestoredCount -gt 0) {
+        Write-Output "${GREEN}   Restored ${compactRestoredCount} turns from Layer 2${RESET}"
+        Write-Output ""
+        Write-Output "${MAGENTA}${BOLD}## Recent Context (auto-restored)${RESET}"
+        Write-Output ""
+
+        try {
+            $compactTurns = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+(d.turns || []).forEach(t => {
+    const q = (t.user_query || '...').substring(0, 120);
+    const a = (t.assistant_response || '...').substring(0, 250);
+    console.log('**Turn ' + (t.turn_number || '?') + '**: ' + q + '...\n> ' + a + '...\n');
+});
+" $compactJson 2>$null
+            Write-Output $compactTurns
+        } catch {}
+
+        Write-Output ""
+        Write-Output "${DIM}Full history: `"turns 1-${turnNumber}`" or `"recall yesterday`"${RESET}"
+    }
+
+    Write-Output ""
+    Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| ${sessionName} | ${timestamp}${RESET}"
+
+} elseif ($postClearDetected -and $authToken) {
+    # /clear detected - show visible restoration banner
+    $separator = "${GREEN}" + ("=" * 78) + "${RESET}"
+
+    Write-Output $separator
+    Write-Output "${GREEN}${BOLD}SESSION CONTINUED${RESET} ${DIM}| ${turnNumber} turns preserved | Restoring context...${RESET}"
+    Write-Output $separator
+
+    # Also write to stderr for visibility
+    [Console]::Error.WriteLine("${GREEN}${BOLD}SESSION CONTINUED${RESET} ${DIM}| ${turnNumber} turns preserved | Context restored${RESET}")
+
+    try {
+        $clearBody = @{
+            session_id = $sessionId
+            last_n     = 10
+            format     = "summary"
+        } | ConvertTo-Json -Depth 10 -Compress
+        $clearBodyBytes = [System.Text.Encoding]::UTF8.GetBytes($clearBody)
+
+        $clearResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/turns/recall" `
+            -Method POST `
+            -Headers @{ Authorization = "Bearer $authToken"; "Content-Type" = "application/json" } `
+            -Body $clearBodyBytes `
+            -TimeoutSec 5 -ErrorAction Stop
+    } catch {
+        $clearResponse = @{ turns = @() }
+    }
+
+    $clearJson = $clearResponse | ConvertTo-Json -Depth 20 -Compress
+    $clearRestoredCount = 0
+    try {
+        $clearRestoredCount = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+console.log((d.turns || []).length);
+" $clearJson 2>$null
+        $clearRestoredCount = [int]$clearRestoredCount
+    } catch { $clearRestoredCount = 0 }
+
+    if ($clearRestoredCount -gt 0) {
+        Write-Output "${GREEN}   Restored ${clearRestoredCount} recent turns${RESET}"
+        Write-Output ""
+
+        try {
+            $clearTurns = node -e "
+const d = JSON.parse(process.argv[1] || '{}');
+(d.turns || []).forEach(t => {
+    const q = (t.query_preview || t.user_query || '...').substring(0, 80);
+    const a = (t.response_preview || t.assistant_response || '...').substring(0, 150);
+    console.log('**Turn ' + (t.turn_number || '?') + '**: ' + q + '...\n> ' + a + '...\n');
+});
+" $clearJson 2>$null
+            Write-Output $clearTurns
+        } catch {}
+    } else {
+        Write-Output "${GREEN}   History preserved (${turnNumber} turns)${RESET}"
+    }
+
+    Write-Output ""
+    Write-Output "${DIM}Full history: `"recall`" or `"turns 1-${turnNumber}`"${RESET}"
+    Write-Output $separator
+    Write-Output ""
+    Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| ${sessionName} | ${timestamp}${RESET}"
+
+} elseif ($tokenPercent -ge 50) {
+    # High context - show IPC percent
+    Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| ~${ipcPercent}% IPC | ${sessionName} | ${timestamp}${RESET}"
+
+} else {
+    # Normal output - session name + timestamp
+    Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| ${sessionName} | ${timestamp}${RESET}"
 }
 
-$output += @"
+# ═══════════════════════════════════════════════════════════════════════════
+# Output skill reminders if detected
+# ═══════════════════════════════════════════════════════════════════════════
+if ($skillReminders.Count -gt 0) {
+    Write-Output ""
+    Write-Output "${MAGENTA}${BOLD}$($skillReminders -join "`n")${RESET}"
+}
 
-<footer-format>End responses with: Claude Code ({Model}) · 🧠 ekkOS_™ · $sessionName · $timestamp</footer-format>
-<footer-note>Do not include a turn counter in the footer.</footer-note>
-"@
+# ═══════════════════════════════════════════════════════════════════════════
+# FOOTER FORMAT HINT
+# ═══════════════════════════════════════════════════════════════════════════
+Write-Output ""
+Write-Output "<footer-format>End responses with: Claude Code ({Model}) · ekkOS_ · $sessionName · $timestamp</footer-format>"
+Write-Output "<footer-note>Do not include a turn counter in the footer.</footer-note>"
 
-Write-Output $output
+exit 0