@ekkos/cli 1.0.34 → 1.0.35

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

@@ -1,332 +1,656 @@
 # ═══════════════════════════════════════════════════════════════════════════
 # 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=1.0.0
-#
-# Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
-# - All persisted records MUST include: instanceId, sessionId, sessionName
-# - Uses EKKOS_INSTANCE_ID env var for multi-session isolation
+# ═══════════════════════════════════════════════════════════════════════════
+# 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
 # ═══════════════════════════════════════════════════════════════════════════
 
 $ErrorActionPreference = "SilentlyContinue"
 
-# ═══════════════════════════════════════════════════════════════════════════
-# 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"
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
 
 # ═══════════════════════════════════════════════════════════════════════════
-# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
+# CONFIG PATHS - Per spec v1.2 Addendum
 # ═══════════════════════════════════════════════════════════════════════════
-$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
+$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"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load session words from JSON file - NO HARDCODED ARRAYS
+# WORD-BASED SESSION NAMES - Uses external session-words.json
 # ═══════════════════════════════════════════════════════════════════════════
-$script:SessionWords = $null
+$script:ADJECTIVES = @()
+$script:NOUNS = @()
+$script:VERBS = @()
+$script:SESSION_WORDS_LOADED = $false
 
 function Load-SessionWords {
-    $wordsFile = $SessionWordsJson
+    if ($script:SESSION_WORDS_LOADED) { return }
 
-    # Fallback to managed defaults if user file missing/invalid
+    $wordsFile = $SessionWordsJson
     if (-not (Test-Path $wordsFile)) {
         $wordsFile = $SessionWordsDefault
     }
 
-    if (-not (Test-Path $wordsFile)) {
-        return $null
+    if ((-not (Test-Path $wordsFile)) -or (-not (Test-Path $JsonParseHelper))) {
+        $script:ADJECTIVES = @("unknown")
+        $script:NOUNS = @("session")
+        $script:VERBS = @("starts")
+        return
     }
 
     try {
-        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
+        $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 {
-        return $null
+        $script:ADJECTIVES = @("unknown")
+        $script:NOUNS = @("session")
+        $script:VERBS = @("starts")
     }
 }
 
-# Read input from stdin
-$inputJson = [Console]::In.ReadToEnd()
-if (-not $inputJson) { exit 0 }
+function Convert-UuidToWords {
+    param([string]$uuid)
 
-try {
-    $input = $inputJson | ConvertFrom-Json
-} catch {
-    exit 0
+    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"
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 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 "" }
+    } catch {
+        return ""
+    }
 }
 
-$userQuery = $input.query
-if (-not $userQuery) { $userQuery = $input.message }
-if (-not $userQuery) { $userQuery = $input.prompt }
-if (-not $userQuery) { exit 0 }
+# ═══════════════════════════════════════════════════════════════════════════
+# Read input from stdin
+# ═══════════════════════════════════════════════════════════════════════════
+$INPUT = [Console]::In.ReadToEnd()
+if (-not $INPUT) { exit 0 }
 
-$rawSessionId = $input.session_id
-if (-not $rawSessionId -or $rawSessionId -eq "null") { $rawSessionId = "unknown" }
+$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 }
 
-# Fallback: read session_id from saved state
-if ($rawSessionId -eq "unknown") {
+$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"
+
+# Fallback: read session_id from saved state if not in INPUT
+if ($RAW_SESSION_ID -eq "unknown") {
     $stateFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
     if (Test-Path $stateFile) {
-        try {
-            $state = Get-Content $stateFile -Raw | ConvertFrom-Json
-            $rawSessionId = $state.session_id
-        } catch {}
+        $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
+        }
     }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # INTELLIGENT TOOL ROUTER: Multi-trigger skill detection
+# Detects ALL applicable skills/tools and injects as system reminder
 # ═══════════════════════════════════════════════════════════════════════════
-$skillReminders = @()
-$queryLower = $userQuery.ToLower()
+$SKILL_REMINDERS = @()
+$QUERY_LOWER = $USER_QUERY.ToLower()
 
 # Memory First - Debug/Error/Problem solving
-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"
+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"
 }
 
-# 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"
+# 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"
 }
 
-# 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"
+# 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"
 }
 
-# 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"
+# 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"
 }
 
-# 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"
+# 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"
+}
+
+# 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"
+}
+
+# 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"
+}
+
+# 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"
+}
+
+# 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"
+}
+
+# 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"
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# SESSION NAME - Resolve early so it's available for all downstream use
+# Load auth
 # ═══════════════════════════════════════════════════════════════════════════
-function Convert-UuidToWords {
-    param([string]$uuid)
+$EKKOS_CONFIG = Join-Path $env:USERPROFILE ".ekkos\config.json"
+$AUTH_TOKEN = ""
+
+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
+    }
+}
+
+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
+            }
+        }
+    }
+}
 
-    if (-not $script:SessionWords) { Load-SessionWords }
-    if (-not $script:SessionWords) { return "unknown-session" }
+$MEMORY_API_URL = "https://mcp.ekkos.dev"
 
-    $adjectives = $script:SessionWords.adjectives
-    $nouns = $script:SessionWords.nouns
-    $verbs = $script:SessionWords.verbs
+# ═══════════════════════════════════════════════════════════════════════════
+# Session ID - NEW ID per conversation (not persisted 24h anymore)
+# ═══════════════════════════════════════════════════════════════════════════
+$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"
+
+$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
+}
 
-    if (-not $adjectives -or -not $nouns -or -not $verbs) { return "unknown-session" }
-    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
+# 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
 
-    $clean = $uuid -replace "-", ""
-    if ($clean.Length -lt 12) { return "unknown-session" }
+# ═══════════════════════════════════════════════════════════════════════════
+# Turn counter - PROJECT-LOCAL storage
+# ═══════════════════════════════════════════════════════════════════════════
+$ProjectSessionDir = Join-Path $StateDir "sessions"
+if (-not (Test-Path $ProjectSessionDir)) {
+    New-Item -ItemType Directory -Path $ProjectSessionDir -Force | Out-Null
+}
+$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)) {
     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])"
+        $transcriptContent = Get-Content $TRANSCRIPT_PATH -Raw
+        $TURN_NUMBER = ([regex]::Matches($transcriptContent, '"type":"user"')).Count
+        if ($TURN_NUMBER -eq 0) { $TURN_NUMBER = 1 }
     } catch {
-        return "unknown-session"
+        $TURN_NUMBER = 1
     }
 }
 
-$sessionName = Convert-UuidToWords $rawSessionId
+# 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
+
+if (Test-Path $TURN_COUNTER_FILE) {
+    try {
+        $SAVED_TURN_COUNT = [int](Get-Content $TURN_COUNTER_FILE -Raw).Trim()
+    } catch {
+        $SAVED_TURN_COUNT = 0
+    }
+}
+
+if ($SAVED_TURN_COUNT -gt $TURN_NUMBER) {
+    # Post-clear: INCREMENT from saved count
+    $TURN_NUMBER = $SAVED_TURN_COUNT + 1
+    $POST_CLEAR_DETECTED = $true
+}
+Set-Content -Path $TURN_COUNTER_FILE -Value "$TURN_NUMBER" -Force
 
 # ═══════════════════════════════════════════════════════════════════════════
-# 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.
+# WORKING MEMORY: Fast capture each turn (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
-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 {}
+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 ($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`"}"
+        Start-Job -ScriptBlock {
+            param($url, $token, $body)
+            try {
+                Invoke-RestMethod -Uri "$url/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 $MEMORY_API_URL, $CAPTURE_TOKEN, $captureBody | Out-Null
     }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# SESSION CURRENT: Update Redis with current session name
+# LOCAL CACHE: Tier 0 capture for instant /continue (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session" -and $rawSessionId -ne "unknown") {
-    $configFile2 = Join-Path $EkkosConfigDir "config.json"
-    if (Test-Path $configFile2) {
+$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)
         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
-            }
+            & ekkos-capture user $sessionId $sessionName $turnNum $query $projRoot 2>$null | Out-Null
         } catch {}
-    }
+    } -ArgumentList $RAW_SESSION_ID, $SESSION_NAME_FOR_CAPTURE, $TURN_NUMBER, $USER_QUERY, $projectRootNorm | Out-Null
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# TURN TRACKING & STATE MANAGEMENT
+# GOLDEN LOOP: CAPTURE PHASE - Track turn start
 # ═══════════════════════════════════════════════════════════════════════════
-$stateDir = Join-Path $env:USERPROFILE ".claude\state"
-if (-not (Test-Path $stateDir)) {
-    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
+$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"
 
-$stateFile = Join-Path $stateDir "hook-state.json"
-$turn = 0
-$contextPercent = ""
+# 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 {}
 
-if (Test-Path $stateFile) {
-    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
+# ═══════════════════════════════════════════════════════════════════════════
+# 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
+}
+
+$RETRIEVED_PATTERNS = ""
+$PATTERN_COUNT = 0
+$RETRIEVED_DIRECTIVES = ""
+$DIRECTIVE_COUNT = 0
+
+# ═══════════════════════════════════════════════════════════════════════════
+# DIRECTIVE CACHE: Local cache to avoid API calls every turn
+# ═══════════════════════════════════════════════════════════════════════════
+$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
+}
+
+# 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
+}
+
+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
+
+        if ($cacheAge -lt $DIRECTIVE_CACHE_TTL -and -not $DIRECTIVE_TRIGGER_DETECTED) {
+            $DIRECTIVE_CACHE_VALID = $true
         }
-    } catch {
-        $turn = 0
     }
 }
 
-# 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
+# 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
+}
 
-Set-Content -Path $stateFile -Value $newState -Force
+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 {}
 
-# ═══════════════════════════════════════════════════════════════════════════
-# 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") {
+    # Build sources array - always include patterns, conditionally include directives
+    if ($DIRECTIVE_CACHE_VALID) {
+        $searchSources = '["patterns"]'
+    } else {
+        $searchSources = '["patterns", "directives"]'
+    }
+
+    # Escape user query for JSON
+    $queryJsonEscaped = $USER_QUERY -replace '\\', '\\\\' -replace '"', '\"' -replace "`n", '\n' -replace "`r", '' -replace "`t", '\t'
+
+    # Call ekkOS MCP gateway
+    $SEARCH_RESPONSE_RAW = $null
     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 }
+        $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
+    }
 
-        Start-Job -ScriptBlock {
-            param($instanceId, $sessionId, $sessionName, $turnNum, $queryB64, $projectPath)
+    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 = '{}'
+            }
+        }
+
+        # 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
+        }
+
+        # Update golden loop with retrieved count
+        if ($PATTERN_COUNT -gt 0) {
             try {
-                $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($queryB64))
-                & ekkos-capture user $instanceId $sessionId $sessionName $turnNum $decoded $projectPath 2>&1 | Out-Null
+                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 {}
-        } -ArgumentList $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $queryBase64, $projectRoot | Out-Null
-    } catch {}
-}
 
-# ═══════════════════════════════════════════════════════════════════════════
-# WORKING MEMORY: Fast capture to API (async, non-blocking)
-# ═══════════════════════════════════════════════════════════════════════════
-$configFile = Join-Path $EkkosConfigDir "config.json"
-if (Test-Path $configFile) {
-    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" `
-                    -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
+            # 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
         }
-    } catch {}
+
+        # ═══════════════════════════════════════════════════════════════════
+        # 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);
+});
+
+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; });
+    }
 }
 
-$timestamp = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt") + " EST"
+console.log(JSON.stringify({count, formatted}));
+
+// 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
+
+            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
+            }
+        }
+    }
+}
 
 # ═══════════════════════════════════════════════════════════════════════════
-# 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.
+# COLORS (ANSI escape sequences via [char]27)
 # ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session") {
-    try {
-        $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
-        $hintFile = Join-Path $EkkosConfigDir "hook-session-hint.json"
-        $hint = @{
-            sessionName = $sessionName
-            sessionId   = $rawSessionId
-            projectPath = $projectPath
-            ts          = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
-        } | ConvertTo-Json -Depth 10 -Compress
-        Set-Content -Path $hintFile -Value $hint -Force
-    } catch {}
+$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"
+
+$CURRENT_TIME = Get-Date -Format "yyyy-MM-dd hh:mm:ss tt K"
+
+# Generate session name
+$SESSION_NAME = ""
+if ($SESSION_ID -and $SESSION_ID -ne "unknown" -and $SESSION_ID -ne "null") {
+    $SESSION_NAME = Convert-UuidToWords $SESSION_ID
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# OUTPUT SYSTEM REMINDER
+# "/continue" COMMAND: Delegated to Skill system (DO NOT INTERCEPT)
 # ═══════════════════════════════════════════════════════════════════════════
-$esc = [char]27
-$header = "${esc}[0;36m${esc}[1m🧠 ekkOS Memory${esc}[0m ${esc}[2m| $sessionName | $timestamp${esc}[0m"
+# REMOVED: Hook used to intercept /continue and do simple restoration
+# NOW: Let /continue Skill handle it - supports session names + intelligent narrative
 
-$output = @"
-$header
+# ═══════════════════════════════════════════════════════════════════════════
+# AUTO-RESTORE REMOVED: Manual /continue only (saves 79% token burn!)
+# ═══════════════════════════════════════════════════════════════════════════
 
-"@
+# 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}"
 
-if ($skillReminders.Count -gt 0) {
-    $output += "${esc}[0;35m${esc}[1m" + ($skillReminders -join "`n") + "${esc}[0m`n"
+# Output skill reminder if detected
+if ($SKILL_REMINDER) {
+    Write-Output ""
+    Write-Output "${MAGENTA}${BOLD}${SKILL_REMINDER}${RESET}"
 }
 
-$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>"
+}
+
+# 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 ""
+    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."
+}
 
-<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>
-"@
+# Inject footer format reminder (helps Claude remember session name)
+if ($SESSION_NAME -and $SESSION_NAME -ne "unknown-session") {
+    Write-Output ""
+    Write-Output "<footer-format>End responses with: Claude Code ({Model}) · ekkOS_ · Turn ${TURN_NUMBER} · ${SESSION_NAME} · ${CURRENT_TIME}</footer-format>"
+}
 
-Write-Output $output
+exit 0