@ekkos/cli 1.0.35 → 1.0.36

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

@@ -1,11 +1,18 @@
 # ═══════════════════════════════════════════════════════════════════════════
 # ekkOS_ Hook: UserPromptSubmit - SEAMLESS CONTEXT CONTINUITY (Windows)
-# ═══════════════════════════════════════════════════════════════════════════
+# 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
-# Per spec v1.2 Addendum: NO jq dependency, uses Node.js for JSON
+#
+# 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"
@@ -14,643 +21,702 @@ $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
 
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - Per spec v1.2 Addendum
+# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
 # ═══════════════════════════════════════════════════════════════════════════
-$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { Join-Path $env:USERPROFILE ".ekkos" }
-$SessionWordsJson = Join-Path $EkkosConfigDir "session-words.json"
-$SessionWordsDefault = Join-Path $EkkosConfigDir ".defaults\session-words.json"
-$JsonParseHelper = Join-Path $EkkosConfigDir ".helpers\json-parse.cjs"
+$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { "$env:USERPROFILE\.ekkos" }
+$SessionWordsJson = "$EkkosConfigDir\session-words.json"
+$SessionWordsDefault = "$EkkosConfigDir\.defaults\session-words.json"
+$JsonParseHelper = "$EkkosConfigDir\.helpers\json-parse.cjs"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORD-BASED SESSION NAMES - Uses external session-words.json
+# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
 # ═══════════════════════════════════════════════════════════════════════════
-$script:ADJECTIVES = @()
-$script:NOUNS = @()
-$script:VERBS = @()
-$script:SESSION_WORDS_LOADED = $false
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
-function Load-SessionWords {
-    if ($script:SESSION_WORDS_LOADED) { return }
+# ═══════════════════════════════════════════════════════════════════════════
+# API URL
+# ═══════════════════════════════════════════════════════════════════════════
+$MemoryApiUrl = "https://api.ekkos.dev"
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Load session words from JSON file - 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)) -or (-not (Test-Path $JsonParseHelper))) {
-        $script:ADJECTIVES = @("unknown")
-        $script:NOUNS = @("session")
-        $script:VERBS = @("starts")
-        return
-    }
-
-    try {
-        $adjRaw = & node $JsonParseHelper $wordsFile ".adjectives" 2>$null
-        $nounRaw = & node $JsonParseHelper $wordsFile ".nouns" 2>$null
-        $verbRaw = & node $JsonParseHelper $wordsFile ".verbs" 2>$null
-
-        $script:ADJECTIVES = @()
-        $script:NOUNS = @()
-        $script:VERBS = @()
-
-        if ($adjRaw) { $script:ADJECTIVES = @($adjRaw -split "`n" | Where-Object { $_ }) }
-        if ($nounRaw) { $script:NOUNS = @($nounRaw -split "`n" | Where-Object { $_ }) }
-        if ($verbRaw) { $script:VERBS = @($verbRaw -split "`n" | Where-Object { $_ }) }
-
-        if ($script:ADJECTIVES.Count -eq 0) { $script:ADJECTIVES = @("unknown") }
-        if ($script:NOUNS.Count -eq 0) { $script:NOUNS = @("session") }
-        if ($script:VERBS.Count -eq 0) { $script:VERBS = @("starts") }
-
-        $script:SESSION_WORDS_LOADED = $true
-    } catch {
-        $script:ADJECTIVES = @("unknown")
-        $script:NOUNS = @("session")
-        $script:VERBS = @("starts")
-    }
-}
-
-function Convert-UuidToWords {
-    param([string]$uuid)
-
-    Load-SessionWords
-
-    $hex = $uuid -replace "-", ""
-    $hex = $hex.Substring(0, [Math]::Min(12, $hex.Length))
-    if ($hex -notmatch '^[0-9a-fA-F]+$') { return "unknown-session-starts" }
-
-    try {
-        $adjSeed = [Convert]::ToInt32($hex.Substring(0, 4), 16)
-        $nounSeed = [Convert]::ToInt32($hex.Substring(4, 4), 16)
-        $verbSeed = [Convert]::ToInt32($hex.Substring(8, 4), 16)
-
-        $adjIdx = $adjSeed % $script:ADJECTIVES.Count
-        $nounIdx = $nounSeed % $script:NOUNS.Count
-        $verbIdx = $verbSeed % $script:VERBS.Count
-
-        return "$($script:ADJECTIVES[$adjIdx])-$($script:NOUNS[$nounIdx])-$($script:VERBS[$verbIdx])"
-    } catch {
-        return "unknown-session-starts"
+    if (-not (Test-Path $wordsFile)) {
+        return $null
     }
-}
 
-# ═══════════════════════════════════════════════════════════════════════════
-# JSON parsing helper (no jq) - pipes JSON to node, extracts dot-path value
-# ═══════════════════════════════════════════════════════════════════════════
-function Parse-JsonValue {
-    param(
-        [string]$Json,
-        [string]$Path
-    )
-    if (-not $Json) { return "" }
     try {
-        $result = $Json | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const path = '$Path'.replace(/^\./,'').split('.').filter(Boolean);
-let result = data;
-for (const p of path) {
-    if (result === undefined || result === null) { result = undefined; break; }
-    result = result[p];
-}
-if (result !== undefined && result !== null) console.log(result);
-" 2>$null
-        if ($result) { return $result.Trim() } else { return "" }
+        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
     } catch {
-        return ""
+        return $null
     }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Read input from stdin
 # ═══════════════════════════════════════════════════════════════════════════
-$INPUT = [Console]::In.ReadToEnd()
-if (-not $INPUT) { exit 0 }
+$inputJson = [Console]::In.ReadToEnd()
+if (-not $inputJson) { exit 0 }
 
-$USER_QUERY = Parse-JsonValue $INPUT ".query"
-if (-not $USER_QUERY) { $USER_QUERY = Parse-JsonValue $INPUT ".message" }
-if (-not $USER_QUERY) { $USER_QUERY = Parse-JsonValue $INPUT ".prompt" }
-if (-not $USER_QUERY -or $USER_QUERY -eq "null") { exit 0 }
+try {
+    $input = $inputJson | ConvertFrom-Json
+} catch {
+    exit 0
+}
+
+$userQuery = $input.query
+if (-not $userQuery) { $userQuery = $input.message }
+if (-not $userQuery) { $userQuery = $input.prompt }
+if (-not $userQuery) { exit 0 }
 
-$RAW_SESSION_ID = Parse-JsonValue $INPUT ".session_id"
-if (-not $RAW_SESSION_ID -or $RAW_SESSION_ID -eq "null") { $RAW_SESSION_ID = "unknown" }
-$TRANSCRIPT_PATH = Parse-JsonValue $INPUT ".transcript_path"
+$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 not in INPUT
-if ($RAW_SESSION_ID -eq "unknown") {
+# Fallback: read session_id from saved state
+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) {
-        $savedState = Get-Content $stateFile -Raw
-        $savedId = Parse-JsonValue $savedState ".session_id"
-        if ($savedId -and $savedId -ne "unknown" -and $savedId -ne "null") {
-            $RAW_SESSION_ID = $savedId
+    if ((Test-Path $stateFile) -and (Test-Path $JsonParseHelper)) {
+        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)
+    }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # INTELLIGENT TOOL ROUTER: Multi-trigger skill detection
-# Detects ALL applicable skills/tools and injects as system reminder
 # ═══════════════════════════════════════════════════════════════════════════
-$SKILL_REMINDERS = @()
-$QUERY_LOWER = $USER_QUERY.ToLower()
+$skillReminders = @()
+$queryLower = $userQuery.ToLower()
 
 # Memory First - Debug/Error/Problem solving
-if ($QUERY_LOWER -match '(how do i|debug|error|bug|fix|not working|broken|fails|issue|problem|wrong|crash)') {
-    $SKILL_REMINDERS += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Memory_First`") FIRST before debugging"
+if ($queryLower -match '(how do i|debug|error|bug|fix|not working|broken|fails|issue|problem|wrong|crash)') {
+    $skillReminders += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Memory_First`") FIRST before debugging"
 }
 
-# Recall Triggers (Time-based memory)
-if ($QUERY_LOWER -match '(yesterday|last week|last month|remember when|what did we|where did we leave|before|earlier|previous|ago)') {
-    $SKILL_REMINDERS += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Deep_Recall`") for time-based memory"
+# Recall Triggers - Time-based memory
+if ($queryLower -match '(yesterday|last week|last month|remember when|what did we|where did we leave|before|earlier|previous|ago)') {
+    $skillReminders += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Deep_Recall`") for time-based memory"
 }
 
-# Directive Triggers (User preferences)
-if ($QUERY_LOWER -match '(always |never |i prefer|i like |dont |don.t |avoid |remember that |from now on)') {
-    $SKILL_REMINDERS += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Preferences`") to capture directive"
+# Directive Triggers - User preferences
+if ($queryLower -match '(always |never |i prefer|i like |dont |don.t |avoid |remember that |from now on)') {
+    $skillReminders += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Preferences`") to capture directive"
 }
 
-# Safety Triggers (Destructive actions)
-if ($QUERY_LOWER -match '(delete|drop |rm -rf|deploy|push.*main|push.*master|production|migrate|rollback)') {
-    $SKILL_REMINDERS += "SAFETY REQUIRED: Call ekkOS_Conflict before this destructive action"
+# Safety Triggers - Destructive actions
+if ($queryLower -match '(delete|drop |rm -rf|deploy|push.*main|push.*master|production|migrate|rollback)') {
+    $skillReminders += "SAFETY REQUIRED: Call ekkOS_Conflict before this destructive action"
 }
 
-# Schema Triggers (Database operations)
-if ($QUERY_LOWER -match '(sql|query|supabase|prisma|database|table|column|select |insert |update |where )') {
-    $SKILL_REMINDERS += "SCHEMA REQUIRED: Call ekkOS_GetSchema for correct field names"
+# Schema Triggers - Database operations
+if ($queryLower -match '(sql|query|supabase|prisma|database|table|column|select |insert |update |where )') {
+    $skillReminders += "SCHEMA REQUIRED: Call ekkOS_GetSchema for correct field names"
 }
 
-# Secret Triggers (API keys, credentials)
-if ($QUERY_LOWER -match '(api key|token|password|credential|secret|my.*key|store.*key)') {
-    $SKILL_REMINDERS += "SECRETS: Use ekkOS_StoreSecret to securely save credentials"
+# ═══════════════════════════════════════════════════════════════════════════
+# 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 {}
 }
 
-# Plan Triggers (Complex multi-step tasks)
-if ($QUERY_LOWER -match '(implement|build|create.*feature|refactor|migrate|set up|architecture)') {
-    $SKILL_REMINDERS += "PLAN REQUIRED: Call ekkOS_Plan for complex multi-step tasks"
-}
+# ═══════════════════════════════════════════════════════════════════════════
+# SESSION NAME - Resolve early so it's available for all downstream use
+# ═══════════════════════════════════════════════════════════════════════════
+function Convert-UuidToWords {
+    param([string]$uuid)
 
-# Learn Triggers (User expressing success/failure)
-if ($QUERY_LOWER -match '(that worked|thanks|perfect|great|awesome|nailed it|solved|fixed it)') {
-    $SKILL_REMINDERS += "LEARN: Consider calling ekkOS_Forge to capture this solution as a pattern"
-}
+    if (-not $script:SessionWords) { Load-SessionWords }
+    if (-not $script:SessionWords) { return "unknown-session" }
 
-# Codebase Triggers (Project-specific code search)
-if ($QUERY_LOWER -match '(where is|find.*file|search.*code|in this project|in the codebase)') {
-    $SKILL_REMINDERS += "CODEBASE: Use ekkOS_Codebase for project-specific code search"
-}
+    $adjectives = $script:SessionWords.adjectives
+    $nouns = $script:SessionWords.nouns
+    $verbs = $script:SessionWords.verbs
 
-# Combine skill reminders (only take first 3 to avoid noise)
-$SKILL_REMINDER = ""
-$reminderCount = $SKILL_REMINDERS.Count
-if ($reminderCount -gt 0) {
-    $maxReminders = [Math]::Min(3, $reminderCount)
-    $SKILL_REMINDER = ($SKILL_REMINDERS | Select-Object -First $maxReminders) -join "`n"
-}
+    if (-not $adjectives -or -not $nouns -or -not $verbs) { return "unknown-session" }
+    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Load auth
-# ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_CONFIG = Join-Path $env:USERPROFILE ".ekkos\config.json"
-$AUTH_TOKEN = ""
+    $clean = $uuid -replace "-", ""
+    if ($clean.Length -lt 12) { return "unknown-session" }
 
-if ((Test-Path $EKKOS_CONFIG) -and (Test-Path $JsonParseHelper)) {
-    $AUTH_TOKEN = & node $JsonParseHelper $EKKOS_CONFIG ".hookApiKey" 2>$null
-    if (-not $AUTH_TOKEN) {
-        $AUTH_TOKEN = & node $JsonParseHelper $EKKOS_CONFIG ".apiKey" 2>$null
+    try {
+        $a = [Convert]::ToInt32($clean.Substring(0,4), 16) % $adjectives.Length
+        $n = [Convert]::ToInt32($clean.Substring(4,4), 16) % $nouns.Length
+        $an = [Convert]::ToInt32($clean.Substring(8,4), 16) % $verbs.Length
+        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
+    } catch {
+        return "unknown-session"
     }
 }
 
-if (-not $AUTH_TOKEN) {
-    $envLocalFile = Join-Path $ProjectRoot ".env.local"
-    if (Test-Path $envLocalFile) {
-        $envLines = Get-Content $envLocalFile
-        foreach ($line in $envLines) {
-            if ($line -match '^SUPABASE_SECRET_KEY=(.+)$') {
-                $AUTH_TOKEN = $Matches[1].Trim('"', "'", ' ', "`r")
-                break
-            }
-        }
-    }
+$sessionId = $rawSessionId
+if (-not $sessionId -or $sessionId -eq "unknown" -or $sessionId -eq "null") {
+    exit 0
 }
 
-$MEMORY_API_URL = "https://mcp.ekkos.dev"
+# 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
+}
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Session ID - NEW ID per conversation (not persisted 24h anymore)
+# STATE DIRECTORIES
 # ═══════════════════════════════════════════════════════════════════════════
-$StateDir = Join-Path $ProjectRoot ".claude\state"
-if (-not (Test-Path $StateDir)) {
-    New-Item -ItemType Directory -Path $StateDir -Force | Out-Null
+$stateDir = Join-Path $ProjectRoot ".claude\state"
+if (-not (Test-Path $stateDir)) {
+    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
 }
-$SESSION_FILE = Join-Path $StateDir "current-session.json"
+$sessionFile = Join-Path $stateDir "current-session.json"
 
-$SESSION_ID = $RAW_SESSION_ID
-
-# Skip if no valid session ID from Claude
-if (-not $SESSION_ID -or $SESSION_ID -eq "unknown" -or $SESSION_ID -eq "null") {
-    exit 0
+$projectSessionDir = Join-Path $stateDir "sessions"
+if (-not (Test-Path $projectSessionDir)) {
+    New-Item -ItemType Directory -Path $projectSessionDir -Force | Out-Null
 }
-
-# Save for other hooks to reference
-$timestampUtc = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-Set-Content -Path $SESSION_FILE -Value "{`"session_id`": `"$SESSION_ID`", `"timestamp`": `"$timestampUtc`"}" -Force
+$turnCounterFile = Join-Path $projectSessionDir "$sessionId.turn"
+$contextSizeFile = Join-Path $projectSessionDir "$sessionId.context"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Turn counter - PROJECT-LOCAL storage
+# Turn counter - TRANSCRIPT-BASED (source of truth)
+# Count "type":"user" entries in transcript JSONL
 # ═══════════════════════════════════════════════════════════════════════════
-$ProjectSessionDir = Join-Path $StateDir "sessions"
-if (-not (Test-Path $ProjectSessionDir)) {
-    New-Item -ItemType Directory -Path $ProjectSessionDir -Force | Out-Null
+$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
+    }
 }
-$TURN_COUNTER_FILE = Join-Path $ProjectSessionDir "$SESSION_ID.turn"
 
-# Count actual user messages in transcript for accurate turn number
-$TURN_NUMBER = 1
-if ($TRANSCRIPT_PATH -and (Test-Path $TRANSCRIPT_PATH)) {
+# Detect post-clear: saved count higher than transcript means /clear happened
+$savedTurnCount = 0
+if (Test-Path $turnCounterFile) {
     try {
-        $transcriptContent = Get-Content $TRANSCRIPT_PATH -Raw
-        $TURN_NUMBER = ([regex]::Matches($transcriptContent, '"type":"user"')).Count
-        if ($TURN_NUMBER -eq 0) { $TURN_NUMBER = 1 }
+        $savedTurnCount = [int](Get-Content $turnCounterFile -Raw).Trim()
     } catch {
-        $TURN_NUMBER = 1
+        $savedTurnCount = 0
     }
 }
 
-# PRESERVE HISTORY: Don't overwrite if saved count is higher (after /clear)
-$SAVED_TURN_COUNT = 0
-$TRANSCRIPT_TURN_COUNT = $TURN_NUMBER
-$POST_CLEAR_DETECTED = $false
+$postClearDetected = $false
+if ($savedTurnCount -gt $turnNumber) {
+    $postClearDetected = $true
+    $turnNumber = $savedTurnCount + 1
+}
+
+# Save current turn count
+Set-Content -Path $turnCounterFile -Value $turnNumber -Force
 
-if (Test-Path $TURN_COUNTER_FILE) {
+# ═══════════════════════════════════════════════════════════════════════════
+# Context size tracking - Uses tokenizer script (single source)
+# ═══════════════════════════════════════════════════════════════════════════
+$prevContextPercent = 0
+if (Test-Path $contextSizeFile) {
     try {
-        $SAVED_TURN_COUNT = [int](Get-Content $TURN_COUNTER_FILE -Raw).Trim()
+        $prevContextPercent = [int](Get-Content $contextSizeFile -Raw).Trim()
     } catch {
-        $SAVED_TURN_COUNT = 0
+        $prevContextPercent = 0
     }
 }
 
-if ($SAVED_TURN_COUNT -gt $TURN_NUMBER) {
-    # Post-clear: INCREMENT from saved count
-    $TURN_NUMBER = $SAVED_TURN_COUNT + 1
-    $POST_CLEAR_DETECTED = $true
+$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 $TURN_COUNTER_FILE -Value "$TURN_NUMBER" -Force
+
+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"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORKING MEMORY: Fast capture each turn (async, non-blocking)
+# SINGLE SOURCE OF TRUTH: Update ALL session tracking systems
 # ═══════════════════════════════════════════════════════════════════════════
-if (Test-Path $EKKOS_CONFIG) {
-    $CAPTURE_TOKEN = ""
-    if (Test-Path $JsonParseHelper) {
-        $CAPTURE_TOKEN = & node $JsonParseHelper $EKKOS_CONFIG ".hookApiKey" 2>$null
-        if (-not $CAPTURE_TOKEN) {
-            $CAPTURE_TOKEN = & node $JsonParseHelper $EKKOS_CONFIG ".apiKey" 2>$null
+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 {}
 
-    if ($CAPTURE_TOKEN -and $CAPTURE_TOKEN -ne "null") {
-        # Async capture to Redis/Supabase - doesn't block hook execution
-        $queryEscaped = $USER_QUERY -replace '"', '\"' -replace '\\', '\\\\'
-        $captureBody = "{`"session_id`":`"$RAW_SESSION_ID`",`"turn`":$TURN_NUMBER,`"query`":`"$queryEscaped`"}"
+    # 5. Update Redis via API (async)
+    if ($authToken) {
+        $sessionBody = @{ session_name = $sessionName } | ConvertTo-Json -Depth 10 -Compress
         Start-Job -ScriptBlock {
-            param($url, $token, $body)
+            param($body, $token, $apiUrl)
             try {
-                Invoke-RestMethod -Uri "$url/api/v1/working/fast-capture" `
+                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
+                    -TimeoutSec 3 -ErrorAction SilentlyContinue | Out-Null
             } catch {}
-        } -ArgumentList $MEMORY_API_URL, $CAPTURE_TOKEN, $captureBody | Out-Null
+        } -ArgumentList $sessionBody, $authToken, $MemoryApiUrl | Out-Null
     }
-}
 
-# ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Tier 0 capture for instant /continue (async, non-blocking)
-# ═══════════════════════════════════════════════════════════════════════════
-$ekkosCapturePath = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
-if ($ekkosCapturePath) {
-    $SESSION_NAME_FOR_CAPTURE = Convert-UuidToWords $RAW_SESSION_ID
-    $projectRootNorm = $ProjectRoot -replace '\\', '/'
-    Start-Job -ScriptBlock {
-        param($sessionId, $sessionName, $turnNum, $query, $projRoot)
+    # 6. CRITICAL: Bind session name to proxy for R2 eviction paths
+    $ekkosUserId = ""
+    if ((Test-Path $EkkosConfig) -and (Test-Path $JsonParseHelper)) {
         try {
-            & ekkos-capture user $sessionId $sessionName $turnNum $query $projRoot 2>$null | Out-Null
+            $ekkosUserId = node $JsonParseHelper $EkkosConfig '.userId' 2>$null
         } catch {}
-    } -ArgumentList $RAW_SESSION_ID, $SESSION_NAME_FOR_CAPTURE, $TURN_NUMBER, $USER_QUERY, $projectRootNorm | Out-Null
+    }
+    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
+    }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: CAPTURE PHASE - Track turn start
+# LOCAL CACHE: Tier 0 capture (async, non-blocking)
+# Per v1.2 ADDENDUM: Pass instanceId for namespacing
 # ═══════════════════════════════════════════════════════════════════════════
-$EkkosDir = Join-Path $ProjectRoot ".ekkos"
-if (-not (Test-Path $EkkosDir)) {
-    New-Item -ItemType Directory -Path $EkkosDir -Force | Out-Null
-}
-$GOLDEN_LOOP_FILE = Join-Path $EkkosDir "golden-loop-current.json"
+$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
+if ($captureCmd -and $sessionId -ne "unknown") {
+    try {
+        $queryBase64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($userQuery))
+        $captureProjectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
 
-# Write current phase to file (extension watches this for real-time updates)
-$glPathEscaped = $GOLDEN_LOOP_FILE -replace '\\', '\\\\'
-try {
-    node -e "
-const fs = require('fs');
-const data = {
-    phase: 'capture',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: 0, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$glPathEscaped', JSON.stringify(data, null, 2));
-" 2>$null
-} catch {}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: RETRIEVE PHASE - Auto-retrieve patterns from ekkOS
-# ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_API_KEY = ""
-$hookApiKeyFile = Join-Path $env:USERPROFILE ".ekkos\.hookApiKey"
-if (Test-Path $hookApiKeyFile) {
-    $EKKOS_API_KEY = (Get-Content $hookApiKeyFile -Raw).Trim()
-} elseif ((Test-Path $EKKOS_CONFIG) -and (Test-Path $JsonParseHelper)) {
-    $EKKOS_API_KEY = & node $JsonParseHelper $EKKOS_CONFIG ".hookApiKey" 2>$null
+        Start-Job -ScriptBlock {
+            param($instanceId, $sid, $sname, $turnNum, $queryB64, $projPath)
+            try {
+                $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($queryB64))
+                & ekkos-capture user $instanceId $sid $sname $turnNum $decoded $projPath 2>&1 | Out-Null
+            } catch {}
+        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName, $turnNumber, $queryBase64, $captureProjectRoot | Out-Null
+    } catch {}
 }
 
-$RETRIEVED_PATTERNS = ""
-$PATTERN_COUNT = 0
-$RETRIEVED_DIRECTIVES = ""
-$DIRECTIVE_COUNT = 0
-
 # ═══════════════════════════════════════════════════════════════════════════
-# DIRECTIVE CACHE: Local cache to avoid API calls every turn
+# WORKING MEMORY: Fast capture to API (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
-$DirectiveCacheDir = Join-Path $env:USERPROFILE ".ekkos\cache"
-$DirectiveCacheFile = Join-Path $DirectiveCacheDir "directives.json"
-$DIRECTIVE_CACHE_TTL = 3600  # 1 hour in seconds
-if (-not (Test-Path $DirectiveCacheDir)) {
-    New-Item -ItemType Directory -Path $DirectiveCacheDir -Force | Out-Null
+if ($authToken) {
+    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" `
+                    -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
+    } catch {}
 }
 
-# Check if we need to refresh directive cache
-$DIRECTIVE_CACHE_VALID = $false
-$DIRECTIVE_TRIGGER_DETECTED = $false
-
-if ($QUERY_LOWER -match '(always |never |i prefer|i like |dont |don.t |avoid |remember that |from now on|directive|preference)') {
-    $DIRECTIVE_TRIGGER_DETECTED = $true
+# ═══════════════════════════════════════════════════════════════════════════
+# DASHBOARD HINT FILE: write session info for ekkos dashboard --wait-for-new
+# On Windows, active-sessions.json is never populated (hook PIDs are dead).
+# The dashboard reads this file instead to locate the JSONL path.
+# ═══════════════════════════════════════════════════════════════════════════
+if ($sessionName -ne "unknown-session") {
+    try {
+        $hintProjectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+        $hintFile = Join-Path $EkkosConfigDir "hook-session-hint.json"
+        $hint = @{
+            sessionName = $sessionName
+            sessionId   = $sessionId
+            projectPath = $hintProjectPath
+            ts          = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
+        } | ConvertTo-Json -Depth 10 -Compress
+        Set-Content -Path $hintFile -Value $hint -Force
+    } catch {}
 }
 
-if (Test-Path $DirectiveCacheFile) {
-    $cacheContent = Get-Content $DirectiveCacheFile -Raw
-    $cacheTimestampStr = Parse-JsonValue $cacheContent ".cached_at"
-    if ($cacheTimestampStr -match '^\d+$') {
-        $cacheTimestamp = [int64]$cacheTimestampStr
-        $currentTimestamp = [int64]([DateTimeOffset]::UtcNow.ToUnixTimeSeconds())
-        $cacheAge = $currentTimestamp - $cacheTimestamp
+# ═══════════════════════════════════════════════════════════════════════════
+# "/continue" COMMAND: Run AFTER /clear to restore last 5 turns
+# ═══════════════════════════════════════════════════════════════════════════
+$queryLowerTrimmed = $queryLower.Trim()
 
-        if ($cacheAge -lt $DIRECTIVE_CACHE_TTL -and -not $DIRECTIVE_TRIGGER_DETECTED) {
-            $DIRECTIVE_CACHE_VALID = $true
+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 = @() }
         }
-    }
-}
 
-# Decide whether to inject directives this turn
-$SHOULD_INJECT_DIRECTIVES = $false
-if ($TURN_NUMBER -eq 1 -or $POST_CLEAR_DETECTED -or $DIRECTIVE_TRIGGER_DETECTED) {
-    $SHOULD_INJECT_DIRECTIVES = $true
-}
+        $restoreJson = $restoreResponse | ConvertTo-Json -Depth 20 -Compress
+        $restoredCount = 0
+        $lastTask = "unknown task"
+        $lastResponse = ""
 
-if ($EKKOS_API_KEY -and $USER_QUERY) {
-    # Update phase to RETRIEVE
-    try {
-        node -e "
-const fs = require('fs');
-const data = {
-    phase: 'retrieve',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: 0, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$glPathEscaped', JSON.stringify(data, null, 2));
-" 2>$null
-    } catch {}
+        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 }
 
-    # Build sources array - always include patterns, conditionally include directives
-    if ($DIRECTIVE_CACHE_VALID) {
-        $searchSources = '["patterns"]'
-    } else {
-        $searchSources = '["patterns", "directives"]'
-    }
+        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" }
 
-    # Escape user query for JSON
-    $queryJsonEscaped = $USER_QUERY -replace '\\', '\\\\' -replace '"', '\"' -replace "`n", '\n' -replace "`r", '' -replace "`t", '\t'
+        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 = "" }
 
-    # Call ekkOS MCP gateway
-    $SEARCH_RESPONSE_RAW = $null
-    try {
-        $searchBody = "{`"tool`": `"ekkOS_Search`", `"arguments`": {`"query`": `"$queryJsonEscaped`", `"limit`": 5, `"sources`": $searchSources}}"
-        $SEARCH_RESPONSE_RAW = Invoke-RestMethod -Uri "https://api.ekkos.dev/api/v1/mcp/call" `
-            -Method POST `
-            -Headers @{ Authorization = "Bearer $EKKOS_API_KEY"; "Content-Type" = "application/json" } `
-            -Body ([System.Text.Encoding]::UTF8.GetBytes($searchBody)) `
-            -TimeoutSec 2 `
-            -ErrorAction Stop
-    } catch {
-        $SEARCH_RESPONSE_RAW = $null
-    }
+        Write-Output ""
+        Write-Output "${GREEN}${BOLD}Session continued${RESET} ${DIM}(${restoredCount} turns restored)${RESET}"
+        Write-Output ""
 
-    if ($SEARCH_RESPONSE_RAW) {
-        # Convert to JSON string for Node parsing
-        $SEARCH_JSON = ""
-        if ($SEARCH_RESPONSE_RAW -is [string]) {
-            $SEARCH_JSON = $SEARCH_RESPONSE_RAW
-        } else {
-            try {
-                $SEARCH_JSON = $SEARCH_RESPONSE_RAW | ConvertTo-Json -Depth 20 -Compress
-            } catch {
-                $SEARCH_JSON = '{}'
-            }
-        }
+        $continueOutput = @"
+<system-reminder>
+$("=" * 75)
+CONTEXT RESTORED - Resume seamlessly. DO NOT ask 'what were we doing?'
+$("=" * 75)
 
-        # Count patterns retrieved
-        $patternCountStr = $SEARCH_JSON | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const patterns = (d.result && d.result.results && d.result.results.patterns) || [];
-console.log(patterns.length);
-" 2>$null
-        if ($patternCountStr -match '^\d+$') {
-            $PATTERN_COUNT = [int]$patternCountStr
-        }
+## Last User Request:
+$lastTask
 
-        # Update golden loop with retrieved count
-        if ($PATTERN_COUNT -gt 0) {
-            try {
-                node -e "
-const fs = require('fs');
-const data = {
-    phase: 'inject',
-    turn: $TURN_NUMBER,
-    session: '$SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: $PATTERN_COUNT, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$glPathEscaped', JSON.stringify(data, null, 2));
-" 2>$null
-            } catch {}
+## Your Last Response (truncated):
+$lastResponse
 
-            # Format patterns for injection
-            $RETRIEVED_PATTERNS = $SEARCH_JSON | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const patterns = (d.result && d.result.results && d.result.results.patterns) || [];
-patterns.forEach(p => {
-    console.log('**' + (p.title || '') + '**');
-    console.log(p.problem || p.guidance || '');
-    console.log('');
-    console.log('## Solution');
-    console.log(p.solution || p.content || '');
-    console.log('');
-    console.log('Success Rate: ' + ((p.success_rate || 0) * 100) + '%');
-    console.log('Applied: ' + (p.applied_count || 0) + ' times');
-    console.log('');
-});
-" 2>$null
-        }
+"@
 
-        # ═══════════════════════════════════════════════════════════════════
-        # DIRECTIVE HANDLING: Use cache if valid, otherwise process response
-        # ═══════════════════════════════════════════════════════════════════
-        if ($DIRECTIVE_CACHE_VALID) {
-            # Load directives from cache
-            $cacheContent = Get-Content $DirectiveCacheFile -Raw
-            $dcStr = Parse-JsonValue $cacheContent ".count"
-            if ($dcStr -match '^\d+$') { $DIRECTIVE_COUNT = [int]$dcStr }
-            $RETRIEVED_DIRECTIVES = Parse-JsonValue $cacheContent ".formatted"
-        } else {
-            # Extract and format DIRECTIVES from API response
-            $directiveResult = $SEARCH_JSON | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const directives = (d.result && d.result.results && d.result.results.directives) || [];
-const count = directives.length;
-if (count === 0) { console.log(JSON.stringify({count: 0, formatted: ''})); process.exit(0); }
-
-const grouped = {MUST: [], NEVER: [], PREFER: [], AVOID: []};
-directives.forEach(d => {
-    if (grouped[d.type]) grouped[d.type].push(d.rule);
+        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"
+        }
 
-let formatted = 'USER DIRECTIVES (FOLLOW THESE):';
-for (const [type, rules] of Object.entries(grouped)) {
-    if (rules.length > 0) {
-        formatted += '\n\n' + type + ':';
-        rules.forEach(r => { formatted += '\n  - ' + r; });
+        $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
     }
 }
 
-console.log(JSON.stringify({count, formatted}));
+# ═══════════════════════════════════════════════════════════════════════════
+# 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}"
 
-// Save to cache
-const cacheData = {count, formatted, cached_at: Math.floor(Date.now() / 1000)};
-try {
-    const fs = require('fs');
-    fs.mkdirSync(process.argv[1], {recursive: true});
-    fs.writeFileSync(process.argv[2], JSON.stringify(cacheData));
-} catch(e) {}
-" -- "$DirectiveCacheDir" "$DirectiveCacheFile" 2>$null
+    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 = @() }
+    }
 
-            if ($directiveResult) {
-                $dcStr = $directiveResult | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.count||0)" 2>$null
-                if ($dcStr -match '^\d+$') { $DIRECTIVE_COUNT = [int]$dcStr }
-                $RETRIEVED_DIRECTIVES = $directiveResult | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.formatted||'')" 2>$null
-            }
-        }
+    $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}"
     }
-}
 
-# ═══════════════════════════════════════════════════════════════════════════
-# COLORS (ANSI escape sequences via [char]27)
-# ═══════════════════════════════════════════════════════════════════════════
-$ESC = [char]27
-$CYAN = "$ESC[0;36m"
-$GREEN = "$ESC[0;32m"
-$YELLOW = "$ESC[1;33m"
-$MAGENTA = "$ESC[0;35m"
-$DIM = "$ESC[2m"
-$BOLD = "$ESC[1m"
-$RESET = "$ESC[0m"
+    Write-Output ""
+    Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| ${sessionName} | ${timestamp}${RESET}"
 
-$CURRENT_TIME = Get-Date -Format "yyyy-MM-dd hh:mm:ss tt K"
+} elseif ($postClearDetected -and $authToken) {
+    # /clear detected - show visible restoration banner
+    $separator = "${GREEN}" + ("=" * 78) + "${RESET}"
 
-# Generate session name
-$SESSION_NAME = ""
-if ($SESSION_ID -and $SESSION_ID -ne "unknown" -and $SESSION_ID -ne "null") {
-    $SESSION_NAME = Convert-UuidToWords $SESSION_ID
-}
+    Write-Output $separator
+    Write-Output "${GREEN}${BOLD}SESSION CONTINUED${RESET} ${DIM}| ${turnNumber} turns preserved | Restoring context...${RESET}"
+    Write-Output $separator
 
-# ═══════════════════════════════════════════════════════════════════════════
-# "/continue" COMMAND: Delegated to Skill system (DO NOT INTERCEPT)
-# ═══════════════════════════════════════════════════════════════════════════
-# REMOVED: Hook used to intercept /continue and do simple restoration
-# NOW: Let /continue Skill handle it - supports session names + intelligent narrative
+    # Also write to stderr for visibility
+    [Console]::Error.WriteLine("${GREEN}${BOLD}SESSION CONTINUED${RESET} ${DIM}| ${turnNumber} turns preserved | Context restored${RESET}")
 
-# ═══════════════════════════════════════════════════════════════════════════
-# AUTO-RESTORE REMOVED: Manual /continue only (saves 79% token burn!)
-# ═══════════════════════════════════════════════════════════════════════════
+    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 = @() }
+    }
 
-# Simple status line - no context warnings, Claude handles its own context
-Write-Output "${CYAN}${BOLD}ekkOS Memory${RESET} ${DIM}| Turn ${TURN_NUMBER} | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
+    $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 }
 
-# Output skill reminder if detected
-if ($SKILL_REMINDER) {
-    Write-Output ""
-    Write-Output "${MAGENTA}${BOLD}${SKILL_REMINDER}${RESET}"
-}
+    if ($clearRestoredCount -gt 0) {
+        Write-Output "${GREEN}   Restored ${clearRestoredCount} recent turns${RESET}"
+        Write-Output ""
 
-# GOLDEN LOOP: INJECT PHASE - Inject directives FIRST (highest priority)
-# SMART INJECTION: Only on Turn 1, post-clear, or directive trigger
-if ($SHOULD_INJECT_DIRECTIVES -and $RETRIEVED_DIRECTIVES -and $DIRECTIVE_COUNT -gt 0) {
-    Write-Output ""
-    Write-Output "<system-reminder>"
-    Write-Output "$RETRIEVED_DIRECTIVES"
-    Write-Output "</system-reminder>"
-}
+        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}"
+    }
 
-# GOLDEN LOOP: INJECT PHASE - Inject retrieved patterns into context
-if ($RETRIEVED_PATTERNS -and $PATTERN_COUNT -gt 0) {
     Write-Output ""
-    Write-Output "<system-reminder>"
-    Write-Output "RETRIEVED PATTERNS FROM ekkOS MEMORY ($PATTERN_COUNT patterns found)"
+    Write-Output "${DIM}Full history: `"recall`" or `"turns 1-${turnNumber}`"${RESET}"
+    Write-Output $separator
     Write-Output ""
-    Write-Output "$RETRIEVED_PATTERNS"
-    Write-Output ""
-    Write-Output "These patterns were automatically retrieved based on your query. Review and apply relevant solutions."
-    Write-Output "</system-reminder>"
-    Write-Output ""
-    Write-Output "MANDATORY PATTERN ACKNOWLEDGMENT (PatternGuard):"
-    Write-Output "You MUST acknowledge ALL $PATTERN_COUNT patterns above - either SELECT or SKIP each one."
-    Write-Output ""
-    Write-Output "For patterns you USE:"
-    Write-Output "[ekkOS_SELECT]"
-    Write-Output "- id: <pattern_id>"
-    Write-Output "  reason: <1-line why using>"
-    Write-Output "  confidence: <0.0-1.0>"
-    Write-Output "[/ekkOS_SELECT]"
-    Write-Output ""
-    Write-Output "For patterns NOT relevant:"
-    Write-Output "[ekkOS_SKIP]"
-    Write-Output "- id: <pattern_id>"
-    Write-Output "  reason: <1-line why not relevant>"
-    Write-Output "[/ekkOS_SKIP]"
-    Write-Output ""
-    Write-Output "AUTOMATIC APPLICATION: When pattern matches your task, APPLY IT immediately without asking."
-    Write-Output "Track outcome after: ekkOS_Outcome({success: true/false})"
-    Write-Output ""
-    Write-Output "100% coverage required. This is how the system learns what works."
+    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}"
 }
 
-# Inject footer format reminder (helps Claude remember session name)
-if ($SESSION_NAME -and $SESSION_NAME -ne "unknown-session") {
+# ═══════════════════════════════════════════════════════════════════════════
+# Output skill reminders if detected
+# ═══════════════════════════════════════════════════════════════════════════
+if ($skillReminders.Count -gt 0) {
     Write-Output ""
-    Write-Output "<footer-format>End responses with: Claude Code ({Model}) · ekkOS_ · Turn ${TURN_NUMBER} · ${SESSION_NAME} · ${CURRENT_TIME}</footer-format>"
+    Write-Output "${MAGENTA}${BOLD}$($skillReminders -join "`n")${RESET}"
 }
 
+# ═══════════════════════════════════════════════════════════════════════════
+# 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>"
+
 exit 0