@ekkos/cli 1.0.35 → 1.0.36

package/templates/hooks/stop.ps1

@@ -1,6 +1,14 @@
 # ═══════════════════════════════════════════════════════════════════════════
 # ekkOS_ Hook: Stop - Captures turns to BOTH Working (Redis) and Episodic (Supabase)
 # NO jq dependency - uses Node.js for all JSON parsing
+# 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
 # ═══════════════════════════════════════════════════════════════════════════
 # This hook captures every turn to:
 # 1. Working Sessions (Redis) - Fast hot cache for /continue
@@ -13,6 +21,9 @@
 
 $ErrorActionPreference = "SilentlyContinue"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# CONFIG PATHS
+# ═══════════════════════════════════════════════════════════════════════════
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
 $StateDir = Join-Path $ProjectRoot ".claude\state"
@@ -21,218 +32,197 @@ if (-not (Test-Path $StateDir)) {
     New-Item -ItemType Directory -Path $StateDir -Force | Out-Null
 }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No jq dependency (v1.2 spec)
-# Session words live in ~/.ekkos/ so they work in ANY project
-# ═══════════════════════════════════════════════════════════════════════════
-$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"
-
-$INPUT = [Console]::In.ReadToEnd()
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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 ""
-    }
-}
-
-$RAW_SESSION_ID = Parse-JsonValue $INPUT ".session_id"
-if (-not $RAW_SESSION_ID) { $RAW_SESSION_ID = "unknown" }
-$TRANSCRIPT_PATH = Parse-JsonValue $INPUT ".transcript_path"
-$MODEL_USED = Parse-JsonValue $INPUT ".model"
-if (-not $MODEL_USED) { $MODEL_USED = "claude-sonnet-4-5" }
+$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"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Session ID
+# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
 # ═══════════════════════════════════════════════════════════════════════════
-$SESSION_ID = $RAW_SESSION_ID
-
-if (-not $SESSION_ID -or $SESSION_ID -eq "unknown" -or $SESSION_ID -eq "null") {
-    exit 0
-}
-
-# Check if SESSION_ID is a UUID (8-4-4-4-12 format)
-$IS_UUID = $false
-if ($SESSION_ID -match '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$') {
-    $IS_UUID = $true
-}
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORD-BASED SESSION NAMES - No jq, uses ~/.ekkos/ config (works in ANY project)
+# Load session words from JSON file - NO HARDCODED ARRAYS
 # ═══════════════════════════════════════════════════════════════════════════
-$script:ADJECTIVES = @()
-$script:NOUNS = @()
-$script:VERBS = @()
-$script:SESSION_WORDS_LOADED = $false
+$script:SessionWords = $null
 
 function Load-SessionWords {
-    if ($script:SESSION_WORDS_LOADED) { return }
-
     $wordsFile = $SessionWordsJson
+
     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
+    if (-not (Test-Path $wordsFile)) {
+        return $null
     }
 
     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
+        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
     } catch {
-        $script:ADJECTIVES = @("unknown")
-        $script:NOUNS = @("session")
-        $script:VERBS = @("starts")
+        return $null
     }
 }
 
 function Convert-UuidToWords {
     param([string]$uuid)
 
-    Load-SessionWords
+    if (-not $script:SessionWords) {
+        Load-SessionWords
+    }
+
+    if (-not $script:SessionWords) {
+        return "unknown-session"
+    }
 
-    $hex = $uuid -replace "-", ""
-    $hex = $hex.Substring(0, [Math]::Min(12, $hex.Length))
-    if ($hex -notmatch '^[0-9a-fA-F]+$') { return "unknown-session-starts" }
+    $adjectives = $script:SessionWords.adjectives
+    $nouns = $script:SessionWords.nouns
+    $verbs = $script:SessionWords.verbs
 
-    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)
+    if (-not $adjectives -or -not $nouns -or -not $verbs) {
+        return "unknown-session"
+    }
 
-        $adjIdx = $adjSeed % $script:ADJECTIVES.Count
-        $nounIdx = $nounSeed % $script:NOUNS.Count
-        $verbIdx = $verbSeed % $script:VERBS.Count
+    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
-        return "$($script:ADJECTIVES[$adjIdx])-$($script:NOUNS[$nounIdx])-$($script:VERBS[$verbIdx])"
+    $clean = $uuid -replace "-", ""
+    if ($clean.Length -lt 12) { return "unknown-session" }
+
+    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-starts"
+        return "unknown-session"
     }
 }
 
-if ($IS_UUID) {
-    $SESSION_NAME = Convert-UuidToWords $SESSION_ID
+# ═══════════════════════════════════════════════════════════════════════════
+# READ INPUT
+# ═══════════════════════════════════════════════════════════════════════════
+$inputJson = [Console]::In.ReadToEnd()
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Parse input JSON for session_id, transcript_path, model
+# ═══════════════════════════════════════════════════════════════════════════
+$rawSessionId = "unknown"
+$transcriptPath = ""
+$modelUsed = "claude-sonnet-4-5"
+
+if ($inputJson) {
+    try {
+        $stopInput = $inputJson | ConvertFrom-Json
+        if ($stopInput.session_id) { $rawSessionId = $stopInput.session_id }
+        if ($stopInput.transcript_path) { $transcriptPath = $stopInput.transcript_path }
+        if ($stopInput.model) { $modelUsed = $stopInput.model }
+    } catch {}
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Session ID validation
+# ═══════════════════════════════════════════════════════════════════════════
+if (-not $rawSessionId -or $rawSessionId -eq "unknown" -or $rawSessionId -eq "null") {
+    exit 0
+}
+
+$isUuid = $rawSessionId -match '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+
+if ($isUuid) {
+    $sessionName = Convert-UuidToWords $rawSessionId
 } else {
-    $SESSION_NAME = $SESSION_ID
+    $sessionName = $rawSessionId
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Turn Number - read from turn file written by user-prompt-submit.ps1
 # ═══════════════════════════════════════════════════════════════════════════
-$SessionsDir = Join-Path $StateDir "sessions"
-if (-not (Test-Path $SessionsDir)) {
-    New-Item -ItemType Directory -Path $SessionsDir -Force | Out-Null
+$sessionsDir = Join-Path $StateDir "sessions"
+if (-not (Test-Path $sessionsDir)) {
+    New-Item -ItemType Directory -Path $sessionsDir -Force | Out-Null
 }
-$TURN_FILE = Join-Path $SessionsDir "$SESSION_ID.turn"
-$TURN_NUMBER = 1
-if (Test-Path $TURN_FILE) {
+
+$turnFile = Join-Path $sessionsDir "$rawSessionId.turn"
+$turn = 1
+if (Test-Path $turnFile) {
     try {
-        $TURN_NUMBER = [int](Get-Content $TURN_FILE -Raw).Trim()
+        $turnContent = Get-Content $turnFile -Raw
+        $turn = [int]$turnContent.Trim()
     } catch {
-        $TURN_NUMBER = 1
+        $turn = 1
     }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Load auth - No jq
 # ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_CONFIG = Join-Path $env:USERPROFILE ".ekkos\config.json"
-$AUTH_TOKEN = ""
-$USER_ID = ""
+$configFile = Join-Path $EkkosConfigDir "config.json"
+$authToken = ""
+$userId = ""
 
-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
-    }
-    $USER_ID = & node $JsonParseHelper $EKKOS_CONFIG ".userId" 2>$null
+if ((Test-Path $configFile) -and (Test-Path $JsonParseHelper)) {
+    try {
+        $authToken = & node $JsonParseHelper $configFile '.hookApiKey' 2>$null
+        if (-not $authToken) {
+            $authToken = & node $JsonParseHelper $configFile '.apiKey' 2>$null
+        }
+        $userId = & node $JsonParseHelper $configFile '.userId' 2>$null
+    } catch {}
+} elseif (Test-Path $configFile) {
+    try {
+        $config = Get-Content $configFile -Raw | ConvertFrom-Json
+        $authToken = if ($config.hookApiKey) { $config.hookApiKey } else { $config.apiKey }
+        $userId = $config.userId
+    } catch {}
 }
 
-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 $authToken) {
+    $envLocal = Join-Path $ProjectRoot ".env.local"
+    if (Test-Path $envLocal) {
+        try {
+            $envContent = Get-Content $envLocal -Raw
+            if ($envContent -match 'SUPABASE_SECRET_KEY=["'']?([^"''\r\n]+)') {
+                $authToken = $Matches[1]
             }
-        }
+        } catch {}
     }
 }
 
-if (-not $AUTH_TOKEN) { exit 0 }
+if (-not $authToken) { exit 0 }
 
-$MEMORY_API_URL = "https://mcp.ekkos.dev"
+$memoryApiUrl = "https://api.ekkos.dev"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# SESSION BINDING: Bridge _pending -> real session name for proxy eviction
-# The CLI may be in spawn pass-through mode (no PTY = blind to TUI output),
-# so the stop hook (which IS sighted) must bind the session.
+# SESSION BINDING: Bridge _pending → real session name for proxy eviction
+# Windows has no PTY so run.ts can't detect the session name. The stop hook
+# is the first place we have a confirmed session name, so we bind here.
 # ═══════════════════════════════════════════════════════════════════════════
-if ($SESSION_NAME -and $SESSION_NAME -ne "unknown-session-starts" -and $USER_ID) {
-    $PROJECT_PATH_FOR_BIND = ((Get-Location).Path) -replace '\\', '/'
-    $PENDING_SESSION_FOR_BIND = if ($env:EKKOS_PENDING_SESSION) { $env:EKKOS_PENDING_SESSION } else { "_pending" }
-
-    $bindBody = @{
-        userId         = $USER_ID
-        realSession    = $SESSION_NAME
-        projectPath    = $PROJECT_PATH_FOR_BIND
-        pendingSession = $PENDING_SESSION_FOR_BIND
-    } | ConvertTo-Json -Depth 10 -Compress
-
-    Start-Job -ScriptBlock {
-        param($url, $body)
-        try {
-            Invoke-RestMethod -Uri "$url/proxy/session/bind" `
-                -Method POST `
-                -ContentType "application/json" `
-                -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
-                -TimeoutSec 2 `
-                -ErrorAction SilentlyContinue | Out-Null
-        } catch {}
-    } -ArgumentList $MEMORY_API_URL, $bindBody | Out-Null
+if ($sessionName -and $sessionName -ne "unknown-session" -and $userId) {
+    try {
+        $projectPath = ((Get-Location).Path) -replace '\\', '/'
+        $pendingSession = if ($env:EKKOS_PENDING_SESSION) { $env:EKKOS_PENDING_SESSION } else { "_pending" }
+
+        $bindBody = @{
+            userId         = $userId
+            realSession    = $sessionName
+            projectPath    = $projectPath
+            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 2 `
+                    -ErrorAction SilentlyContinue | Out-Null
+            } catch {}
+        } -ArgumentList $bindBody, $memoryApiUrl | Out-Null
+    } catch {}
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -241,27 +231,49 @@ if ($SESSION_NAME -and $SESSION_NAME -ne "unknown-session-starts" -and $USER_ID)
 # ═══════════════════════════════════════════════════════════════════════════
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Check for interruption - No jq
+# LOCAL CACHE: ACK turn to mark as synced
+# Per v1.2 ADDENDUM: Pass instanceId for namespacing
 # ═══════════════════════════════════════════════════════════════════════════
-$IS_INTERRUPTED = Parse-JsonValue $INPUT ".interrupted"
-if (-not $IS_INTERRUPTED) { $IS_INTERRUPTED = "false" }
-$STOP_REASON = Parse-JsonValue $INPUT ".stop_reason"
+$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
+if ($captureCmd -and $rawSessionId -ne "unknown") {
+    try {
+        Start-Job -ScriptBlock {
+            param($instanceId, $sessionId, $turnNum)
+            try {
+                & ekkos-capture ack $sessionId $turnNum "--instance=$instanceId" 2>&1 | Out-Null
+            } catch {}
+        } -ArgumentList $EkkosInstanceId, $rawSessionId, $turn | Out-Null
+    } catch {}
+}
 
-if ($IS_INTERRUPTED -eq "true" -or $STOP_REASON -eq "user_cancelled" -or $STOP_REASON -eq "interrupted") {
+# ═══════════════════════════════════════════════════════════════════════════
+# CHECK INTERRUPTION - Skip capture if user cancelled
+# ═══════════════════════════════════════════════════════════════════════════
+$isInterrupted = $false
+$stopReason = ""
+if ($inputJson) {
+    try {
+        $stopParsed = $inputJson | ConvertFrom-Json
+        $isInterrupted = $stopParsed.interrupted -eq $true
+        $stopReason = $stopParsed.stop_reason
+    } catch {}
+}
+
+if ($isInterrupted -or $stopReason -eq "user_cancelled" -or $stopReason -eq "interrupted") {
     exit 0
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Extract conversation from transcript using Node (no jq)
+# EXTRACT CONVERSATION FROM TRANSCRIPT
+# Mirrors stop.sh: Extract last user query, assistant response, file changes
 # ═══════════════════════════════════════════════════════════════════════════
-$LAST_USER = ""
-$LAST_ASSISTANT = ""
-$FILE_CHANGES = "[]"
+$lastUser = ""
+$lastAssistant = ""
+$fileChangesJson = "[]"
 
-if ($TRANSCRIPT_PATH -and (Test-Path $TRANSCRIPT_PATH)) {
+if ($transcriptPath -and (Test-Path $transcriptPath)) {
     try {
-        $tpNorm = $TRANSCRIPT_PATH -replace '\\', '/'
-        $EXTRACTION = & node -e @"
+        $extraction = node -e @"
 const fs = require('fs');
 const lines = fs.readFileSync(process.argv[1], 'utf8').split('\n').filter(Boolean);
 const entries = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
@@ -303,7 +315,7 @@ entries.filter(e => e.type === 'assistant').forEach(e => {
     const content = e.message?.content;
     if (Array.isArray(content)) {
         content.filter(c => c.type === 'tool_use' && ['Edit', 'Write', 'Read'].includes(c.name)).forEach(c => {
-            fileChanges.push({tool: c.name, path: c.input?.file_path || c.input?.path, action: c.name.toLowerCase()});
+            fileChanges.push({tool: c.name, path: (c.input?.file_path || c.input?.path || '').replace(/\\\\/g, '/'), action: c.name.toLowerCase()});
         });
     }
 });
@@ -313,162 +325,157 @@ console.log(JSON.stringify({
     assistant: lastAssistant.substring(0, 50000),
     fileChanges: fileChanges.slice(0, 20)
 }));
-"@ -- $tpNorm 2>$null
-
-        if (-not $EXTRACTION) {
-            $EXTRACTION = '{"user":"","assistant":"","fileChanges":[]}'
+"@ $transcriptPath 2>$null
+
+        if ($extraction) {
+            $parsed = $extraction | ConvertFrom-Json
+            $lastUser = $parsed.user
+            $lastAssistant = $parsed.assistant
+            $fileChangesJson = ($parsed.fileChanges | ConvertTo-Json -Depth 10 -Compress)
+            if (-not $fileChangesJson -or $fileChangesJson -eq "null") { $fileChangesJson = "[]" }
         }
-
-        $LAST_USER = $EXTRACTION | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.user||'')" 2>$null
-        $LAST_ASSISTANT = $EXTRACTION | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.assistant||'')" 2>$null
-        $FILE_CHANGES = $EXTRACTION | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(JSON.stringify(d.fileChanges||[]))" 2>$null
-        if (-not $FILE_CHANGES) { $FILE_CHANGES = "[]" }
     } catch {}
 }
 
-if (-not $LAST_USER -or $LAST_USER -match '\[Request interrupted') {
+if (-not $lastUser -or $lastUser -match '\[Request interrupted') {
     exit 0
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Capture to BOTH Working Sessions (Redis) AND Episodic (Supabase) - No jq
+# Extract tools_used and files_referenced from file changes
 # ═══════════════════════════════════════════════════════════════════════════
-if ($LAST_USER -and $LAST_ASSISTANT) {
-    $TIMESTAMP = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+$toolsUsed = @()
+$filesReferenced = @()
 
-    $TOOLS_USED = $FILE_CHANGES | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8') || '[]');
-console.log(JSON.stringify([...new Set(d.map(f => f.tool).filter(Boolean))]));
-" 2>$null
-    if (-not $TOOLS_USED) { $TOOLS_USED = "[]" }
+if ($parsed -and $parsed.fileChanges) {
+    try {
+        $toolsUsed = @($parsed.fileChanges | ForEach-Object { $_.tool } | Where-Object { $_ } | Select-Object -Unique)
+        $filesReferenced = @($parsed.fileChanges | ForEach-Object { $_.path } | Where-Object { $_ } | Select-Object -Unique)
+    } catch {
+        $toolsUsed = @()
+        $filesReferenced = @()
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Token breakdown from tokenizer script
+# ═══════════════════════════════════════════════════════════════════════════
+$totalTokens = 0
+$inputTokens = 0
+$cacheReadTokens = 0
+$cacheCreationTokens = 0
+
+$tokenizerScript = Join-Path $ScriptDir "lib\count-tokens.cjs"
+if ($transcriptPath -and (Test-Path $transcriptPath) -and (Test-Path $tokenizerScript)) {
+    try {
+        $tokenJson = & node $tokenizerScript $transcriptPath --json 2>$null
+        if ($tokenJson) {
+            $tokenData = $tokenJson | ConvertFrom-Json
+            if ($tokenData.total_tokens) { $totalTokens = [int]$tokenData.total_tokens }
+            if ($tokenData.input_tokens) { $inputTokens = [int]$tokenData.input_tokens }
+            if ($tokenData.cache_read_tokens) { $cacheReadTokens = [int]$tokenData.cache_read_tokens }
+            if ($tokenData.cache_creation_tokens) { $cacheCreationTokens = [int]$tokenData.cache_creation_tokens }
+        }
+    } catch {}
+}
 
-    $FILES_REF = $FILE_CHANGES | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8') || '[]');
-console.log(JSON.stringify([...new Set(d.map(f => f.path).filter(Boolean))]));
-" 2>$null
-    if (-not $FILES_REF) { $FILES_REF = "[]" }
+# ═══════════════════════════════════════════════════════════════════════════
+# CAPTURE TO BOTH Working Sessions (Redis) AND Episodic Memory (Supabase)
+# Mirrors stop.sh dual-write at lines 271-356
+# ═══════════════════════════════════════════════════════════════════════════
+if ($lastUser -and $lastAssistant -and $authToken) {
+    $timestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    $projectPath = ((Get-Location).Path) -replace '\\', '/'
 
-    # Token breakdown from tokenizer script
-    $TOTAL_TOKENS = 0
-    $INPUT_TOKENS = 0
-    $CACHE_READ_TOKENS = 0
-    $CACHE_CREATION_TOKENS = 0
-    $TOKENIZER_SCRIPT = Join-Path $ScriptDir "lib\count-tokens.cjs"
+    # Prepare tools_used and files_referenced as JSON strings for passing into jobs
+    $toolsUsedJson = ($toolsUsed | ConvertTo-Json -Depth 5 -Compress)
+    if (-not $toolsUsedJson -or $toolsUsedJson -eq "null") { $toolsUsedJson = "[]" }
+    # Single-element arrays lose their array wrapper in PowerShell ConvertTo-Json
+    if ($toolsUsed.Count -eq 1) { $toolsUsedJson = "[$toolsUsedJson]" }
 
-    if ($TRANSCRIPT_PATH -and (Test-Path $TRANSCRIPT_PATH) -and (Test-Path $TOKENIZER_SCRIPT)) {
-        try {
-            $TOKEN_JSON = & node $TOKENIZER_SCRIPT $TRANSCRIPT_PATH --json 2>$null
-            if ($TOKEN_JSON) {
-                $TOTAL_TOKENS = $TOKEN_JSON | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.total_tokens||0)" 2>$null
-                $INPUT_TOKENS = $TOKEN_JSON | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.input_tokens||0)" 2>$null
-                $CACHE_READ_TOKENS = $TOKEN_JSON | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.cache_read_tokens||0)" 2>$null
-                $CACHE_CREATION_TOKENS = $TOKEN_JSON | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.cache_creation_tokens||0)" 2>$null
-            }
-        } catch {}
-        if ($TOTAL_TOKENS -notmatch '^\d+$') { $TOTAL_TOKENS = 0 }
-        if ($INPUT_TOKENS -notmatch '^\d+$') { $INPUT_TOKENS = 0 }
-        if ($CACHE_READ_TOKENS -notmatch '^\d+$') { $CACHE_READ_TOKENS = 0 }
-        if ($CACHE_CREATION_TOKENS -notmatch '^\d+$') { $CACHE_CREATION_TOKENS = 0 }
-    }
+    $filesRefJson = ($filesReferenced | ConvertTo-Json -Depth 5 -Compress)
+    if (-not $filesRefJson -or $filesRefJson -eq "null") { $filesRefJson = "[]" }
+    if ($filesReferenced.Count -eq 1) { $filesRefJson = "[$filesRefJson]" }
 
-    # 1. WORKING SESSIONS (Redis) - No jq payload building
-    # 2. EPISODIC MEMORY (Supabase) - No jq payload building
-    # Both fire in a single background job (mirrors the bash subshell)
+    # 1. WORKING SESSIONS (Redis)
     Start-Job -ScriptBlock {
-        param(
-            $apiUrl, $authToken,
-            $sessionName, $turnNumber, $lastUser, $lastAssistant, $modelUsed,
-            $toolsUsed, $filesRef, $totalTokens, $inputTokens, $cacheReadTokens, $cacheCreationTokens,
-            $sessionId, $userId, $fileChanges, $timestamp
-        )
-
-        # --- 1. WORKING SESSIONS (Redis) ---
+        param($token, $apiUrl, $sessionName, $turnNum, $userQuery, $agentResponse, $model, $toolsJson, $filesJson, $totalTok, $inputTok, $cacheReadTok, $cacheCreateTok)
         try {
-            $workingPayload = & node -e "
-console.log(JSON.stringify({
-    session_name: process.argv[1],
-    turn_number: parseInt(process.argv[2]),
-    user_query: process.argv[3],
-    agent_response: process.argv[4].substring(0, 50000),
-    model: process.argv[5],
-    tools_used: JSON.parse(process.argv[6] || '[]'),
-    files_referenced: JSON.parse(process.argv[7] || '[]'),
-    total_context_tokens: parseInt(process.argv[8]) || 0,
-    token_breakdown: {
-        input_tokens: parseInt(process.argv[9]) || 0,
-        cache_read_tokens: parseInt(process.argv[10]) || 0,
-        cache_creation_tokens: parseInt(process.argv[11]) || 0
-    }
-}));
-" -- $sessionName $turnNumber $lastUser $lastAssistant $modelUsed $toolsUsed $filesRef $totalTokens $inputTokens $cacheReadTokens $cacheCreationTokens 2>$null
-
-            if ($workingPayload) {
-                Invoke-RestMethod -Uri "$apiUrl/api/v1/working/turn" `
-                    -Method POST `
-                    -Headers @{ Authorization = "Bearer $authToken"; "Content-Type" = "application/json" } `
-                    -Body ([System.Text.Encoding]::UTF8.GetBytes($workingPayload)) `
-                    -TimeoutSec 5 `
-                    -ErrorAction SilentlyContinue | Out-Null
+            $truncated = $agentResponse
+            if ($agentResponse.Length -gt 50000) {
+                $truncated = $agentResponse.Substring(0, 50000)
             }
+            $body = @{
+                session_name        = $sessionName
+                turn_number         = [int]$turnNum
+                user_query          = $userQuery
+                agent_response      = $truncated
+                model               = $model
+                tools_used          = @(($toolsJson | ConvertFrom-Json))
+                files_referenced    = @(($filesJson | ConvertFrom-Json))
+                total_context_tokens = [int]$totalTok
+                token_breakdown     = @{
+                    input_tokens          = [int]$inputTok
+                    cache_read_tokens     = [int]$cacheReadTok
+                    cache_creation_tokens = [int]$cacheCreateTok
+                }
+            } | ConvertTo-Json -Depth 10 -Compress
+
+            Invoke-RestMethod -Uri "$apiUrl/api/v1/working/turn" `
+                -Method POST `
+                -Headers @{ Authorization = "Bearer $token"; "Content-Type" = "application/json" } `
+                -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
+                -TimeoutSec 5 `
+                -ErrorAction SilentlyContinue | Out-Null
         } catch {}
+    } -ArgumentList $authToken, $memoryApiUrl, $sessionName, $turn, $lastUser, $lastAssistant, $modelUsed, $toolsUsedJson, $filesRefJson, $totalTokens, $inputTokens, $cacheReadTokens, $cacheCreationTokens | Out-Null
 
-        # --- 2. EPISODIC MEMORY (Supabase) ---
+    # 2. EPISODIC MEMORY (Supabase)
+    Start-Job -ScriptBlock {
+        param($token, $apiUrl, $userQuery, $agentResponse, $sessionId, $uid, $fileChanges, $model, $ts, $turnNum, $sessionName)
         try {
-            $episodicPayload = & node -e "
-console.log(JSON.stringify({
-    user_query: process.argv[1],
-    assistant_response: process.argv[2],
-    session_id: process.argv[3],
-    user_id: process.argv[4] || 'system',
-    file_changes: JSON.parse(process.argv[5] || '[]'),
-    metadata: {
-        source: 'claude-code',
-        model_used: process.argv[6],
-        captured_at: process.argv[7],
-        turn_number: parseInt(process.argv[8]) || 1,
-        session_name: process.argv[9],
-        minimal_hook: true
-    }
-}));
-" -- $lastUser $lastAssistant $sessionId $userId $fileChanges $modelUsed $timestamp $turnNumber $sessionName 2>$null
-
-            if ($episodicPayload) {
-                Invoke-RestMethod -Uri "$apiUrl/api/v1/memory/capture" `
-                    -Method POST `
-                    -Headers @{ Authorization = "Bearer $authToken"; "Content-Type" = "application/json" } `
-                    -Body ([System.Text.Encoding]::UTF8.GetBytes($episodicPayload)) `
-                    -TimeoutSec 5 `
-                    -ErrorAction SilentlyContinue | Out-Null
-            }
+            $fcArray = @()
+            try { $fcArray = @(($fileChanges | ConvertFrom-Json)) } catch { $fcArray = @() }
+
+            $body = @{
+                user_query          = $userQuery
+                assistant_response  = $agentResponse
+                session_id          = $sessionId
+                user_id             = if ($uid) { $uid } else { "system" }
+                file_changes        = $fcArray
+                metadata            = @{
+                    source       = "claude-code"
+                    model_used   = $model
+                    captured_at  = $ts
+                    turn_number  = [int]$turnNum
+                    session_name = $sessionName
+                    minimal_hook = $true
+                }
+            } | ConvertTo-Json -Depth 10 -Compress
+
+            Invoke-RestMethod -Uri "$apiUrl/api/v1/memory/capture" `
+                -Method POST `
+                -Headers @{ Authorization = "Bearer $token"; "Content-Type" = "application/json" } `
+                -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
+                -TimeoutSec 5 `
+                -ErrorAction SilentlyContinue | Out-Null
         } catch {}
-    } -ArgumentList $MEMORY_API_URL, $AUTH_TOKEN, `
-        $SESSION_NAME, $TURN_NUMBER, $LAST_USER, $LAST_ASSISTANT, $MODEL_USED, `
-        $TOOLS_USED, $FILES_REF, $TOTAL_TOKENS, $INPUT_TOKENS, $CACHE_READ_TOKENS, $CACHE_CREATION_TOKENS, `
-        $SESSION_ID, $USER_ID, $FILE_CHANGES, $TIMESTAMP | Out-Null
+    } -ArgumentList $authToken, $memoryApiUrl, $lastUser, $lastAssistant, $rawSessionId, $userId, $fileChangesJson, $modelUsed, $timestamp, $turn, $sessionName | Out-Null
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Update local .ekkos/current-focus.md (if exists) - SILENT
 # ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_LOCAL_DIR = Join-Path $ProjectRoot ".ekkos"
-if ((Test-Path $EKKOS_LOCAL_DIR) -and $LAST_USER) {
-    $FOCUS_FILE = Join-Path $EKKOS_LOCAL_DIR "current-focus.md"
-    $TASK_SUMMARY = $LAST_USER
-    if ($LAST_USER.Length -gt 100) {
-        $TASK_SUMMARY = $LAST_USER.Substring(0, 100) + "..."
-    }
-    $focusTimestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-
-    $focusContent = @"
----
-last_updated: $focusTimestamp
-session_id: $SESSION_ID
----
-
-# Current Focus
-$TASK_SUMMARY
-"@
-    Set-Content -Path $FOCUS_FILE -Value $focusContent -Force
+$ekkosDir = Join-Path $ProjectRoot ".ekkos"
+if ((Test-Path $ekkosDir) -and $lastUser) {
+    try {
+        $focusFile = Join-Path $ekkosDir "current-focus.md"
+        $taskSummary = $lastUser.Substring(0, [Math]::Min(100, $lastUser.Length))
+        if ($lastUser.Length -gt 100) { $taskSummary += "..." }
+        $focusTimestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+        $focusContent = "---`nlast_updated: $focusTimestamp`nsession_id: $rawSessionId`n---`n`n# Current Focus`n$taskSummary"
+        Set-Content -Path $focusFile -Value $focusContent -Force
+    } catch {}
 }
 
 exit 0