@ekkos/cli 1.0.36 → 1.1.0

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

@@ -3,12 +3,7 @@
 # MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
 # EKKOS_MANAGED=1
 # EKKOS_MANIFEST_SHA256=<computed-at-build>
-# 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
+# EKKOS_TEMPLATE_VERSION=1.0.0
 #
 # Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
 # - All persisted records MUST include: instanceId, sessionId, sessionName
@@ -17,27 +12,18 @@
 
 $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
 # ═══════════════════════════════════════════════════════════════════════════
@@ -62,9 +48,7 @@ function Load-SessionWords {
     }
 }
 
-# ═══════════════════════════════════════════════════════════════════════════
 # Read input from stdin
-# ═══════════════════════════════════════════════════════════════════════════
 $inputJson = [Console]::In.ReadToEnd()
 if (-not $inputJson) { exit 0 }
 
@@ -81,24 +65,15 @@ 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" -or $rawSessionId -eq "null" -or [string]::IsNullOrEmpty($rawSessionId)) {
+if ($rawSessionId -eq "unknown") {
     $stateFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
-    if ((Test-Path $stateFile) -and (Test-Path $JsonParseHelper)) {
+    if (Test-Path $stateFile) {
         try {
-            $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)
+            $state = Get-Content $stateFile -Raw | ConvertFrom-Json
+            $rawSessionId = $state.session_id
+        } catch {}
     }
 }
 
@@ -133,20 +108,6 @@ 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
 # ═══════════════════════════════════════════════════════════════════════════
@@ -176,282 +137,158 @@ function Convert-UuidToWords {
     }
 }
 
-$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
-}
+$sessionName = Convert-UuidToWords $rawSessionId
 
 # ═══════════════════════════════════════════════════════════════════════════
-# STATE DIRECTORIES
+# 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.
 # ═══════════════════════════════════════════════════════════════════════════
-$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"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Turn counter - TRANSCRIPT-BASED (source of truth)
-# Count "type":"user" entries in transcript JSONL
-# ═══════════════════════════════════════════════════════════════════════════
-$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
+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 {}
     }
 }
 
-$postClearDetected = $false
-if ($savedTurnCount -gt $turnNumber) {
-    $postClearDetected = $true
-    $turnNumber = $savedTurnCount + 1
-}
-
-# Save current turn count
-Set-Content -Path $turnCounterFile -Value $turnNumber -Force
-
 # ═══════════════════════════════════════════════════════════════════════════
-# Context size tracking - Uses tokenizer script (single source)
+# SESSION CURRENT: Update Redis with current session name
 # ═══════════════════════════════════════════════════════════════════════════
-$prevContextPercent = 0
-if (Test-Path $contextSizeFile) {
-    try {
-        $prevContextPercent = [int](Get-Content $contextSizeFile -Raw).Trim()
-    } catch {
-        $prevContextPercent = 0
+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 {}
     }
 }
 
-$tokenPercent = 0
-$ipcPercent = 0
-$maxTokens = 200000
-$tokenizerScript = Join-Path $ScriptDir "lib\count-tokens.cjs"
-
-if ($transcriptPath -and (Test-Path $transcriptPath) -and (Test-Path $tokenizerScript)) {
-    try {
-        $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 {}
-}
-
-Set-Content -Path $contextSizeFile -Value $tokenPercent -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
+# TURN TRACKING & STATE MANAGEMENT
 # ═══════════════════════════════════════════════════════════════════════════
-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 '\\', '/'
+$stateDir = Join-Path $env:USERPROFILE ".claude\state"
+if (-not (Test-Path $stateDir)) {
+    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
+}
 
-    # 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 {}
+$stateFile = Join-Path $stateDir "hook-state.json"
+$turn = 0
+$contextPercent = ""
 
-    # 2. Global ekkOS state (for extension LOCAL-FIRST read)
-    $ekkosGlobalState = Join-Path $EkkosConfigDir "current-session.json"
+if (Test-Path $stateFile) {
     try {
-        if (-not (Test-Path $EkkosConfigDir)) {
-            New-Item -ItemType Directory -Path $EkkosConfigDir -Force | Out-Null
+        $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
         }
-        $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
+    } catch {
+        $turn = 0
     }
+}
 
-    # 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
+# 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
 
-        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
-    }
-}
+Set-Content -Path $stateFile -Value $newState -Force
 
 # ═══════════════════════════════════════════════════════════════════════════
 # 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 $sessionId -ne "unknown") {
+if ($captureCmd -and $rawSessionId -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))
-        $captureProjectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+        $projectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
 
         Start-Job -ScriptBlock {
-            param($instanceId, $sid, $sname, $turnNum, $queryB64, $projPath)
+            param($instanceId, $sessionId, $sessionName, $turnNum, $queryB64, $projectPath)
             try {
                 $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($queryB64))
-                & ekkos-capture user $instanceId $sid $sname $turnNum $decoded $projPath 2>&1 | Out-Null
+                & ekkos-capture user $instanceId $sessionId $sessionName $turnNum $decoded $projectPath 2>&1 | Out-Null
             } catch {}
-        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName, $turnNumber, $queryBase64, $captureProjectRoot | Out-Null
+        } -ArgumentList $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $queryBase64, $projectRoot | Out-Null
     } catch {}
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # WORKING MEMORY: Fast capture to API (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
-if ($authToken) {
+$configFile = Join-Path $EkkosConfigDir "config.json"
+if (Test-Path $configFile) {
     try {
-        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" `
+        $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" `
                     -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 $authToken, $EkkosInstanceId, $sessionId, $sessionName, $turnNumber, $userQuery, $MemoryApiUrl | Out-Null
+                    -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
+        }
     } 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).
@@ -459,12 +296,12 @@ if ($authToken) {
 # ═══════════════════════════════════════════════════════════════════════════
 if ($sessionName -ne "unknown-session") {
     try {
-        $hintProjectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+        $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
         $hintFile = Join-Path $EkkosConfigDir "hook-session-hint.json"
         $hint = @{
             sessionName = $sessionName
-            sessionId   = $sessionId
-            projectPath = $hintProjectPath
+            sessionId   = $rawSessionId
+            projectPath = $projectPath
             ts          = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
         } | ConvertTo-Json -Depth 10 -Compress
         Set-Content -Path $hintFile -Value $hint -Force
@@ -472,251 +309,24 @@ if ($sessionName -ne "unknown-session") {
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# "/continue" COMMAND: Run AFTER /clear to restore last 5 turns
+# OUTPUT SYSTEM REMINDER
 # ═══════════════════════════════════════════════════════════════════════════
-$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
-
-## Your Last Response (truncated):
-$lastResponse
-
-"@
+$esc = [char]27
+$header = "${esc}[0;36m${esc}[1m🧠 ekkOS Memory${esc}[0m ${esc}[2m| $sessionName | $timestamp${esc}[0m"
 
-        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"
-        }
+$output = @"
+$header
 
-        $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 skill reminders if detected
-# ═══════════════════════════════════════════════════════════════════════════
 if ($skillReminders.Count -gt 0) {
-    Write-Output ""
-    Write-Output "${MAGENTA}${BOLD}$($skillReminders -join "`n")${RESET}"
+    $output += "${esc}[0;35m${esc}[1m" + ($skillReminders -join "`n") + "${esc}[0m`n"
 }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# 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>"
+$output += @"
+
+<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>
+"@
 
-exit 0
+Write-Output $output