@ekkos/cli 1.0.36 → 1.1.0

package/templates/hooks/session-start.ps1

@@ -1,27 +1,28 @@
 # ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: SessionStart - MINIMAL + TIME MACHINE + DIRECTIVES (Windows)
+# ekkOS_ Hook: SessionStart - Initialize session (Windows)
 # MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
 # EKKOS_MANAGED=1
-# ═══════════════════════════════════════════════════════════════════════════
-# This hook does THREE things:
-# 1. Check for pending Time Machine "Continue from here" requests
-# 2. Initialize session tracking + Golden Loop
-# 3. Fetch and inject user directives (MUST/NEVER/PREFER/AVOID)
+# EKKOS_MANIFEST_SHA256=<computed-at-build>
+# EKKOS_TEMPLATE_VERSION=1.0.0
 #
-# Per spec v1.2 Addendum: NO hardcoded arrays, uses session-words.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"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS
+# 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"
-$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
-$MemoryApiUrl = "https://api.ekkos.dev"
+# ═══════════════════════════════════════════════════════════════════════════
+# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
+# ═══════════════════════════════════════════════════════════════════════════
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Load session words from JSON file - NO HARDCODED ARRAYS
@@ -30,22 +31,41 @@ $script:SessionWords = $null
 
 function Load-SessionWords {
     $wordsFile = $SessionWordsJson
-    if (-not (Test-Path $wordsFile)) { $wordsFile = $SessionWordsDefault }
-    if (-not (Test-Path $wordsFile)) { return $null }
+
+    if (-not (Test-Path $wordsFile)) {
+        $wordsFile = $SessionWordsDefault
+    }
+
+    if (-not (Test-Path $wordsFile)) {
+        return $null
+    }
+
     try {
         $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
-    } catch { return $null }
+    } catch {
+        return $null
+    }
 }
 
 function Convert-UuidToWords {
     param([string]$uuid)
-    if (-not $script:SessionWords) { Load-SessionWords }
-    if (-not $script:SessionWords) { return "unknown-session" }
+
+    if (-not $script:SessionWords) {
+        Load-SessionWords
+    }
+
+    if (-not $script:SessionWords) {
+        return "unknown-session"
+    }
 
     $adjectives = $script:SessionWords.adjectives
     $nouns = $script:SessionWords.nouns
     $verbs = $script:SessionWords.verbs
-    if (-not $adjectives -or -not $nouns -or -not $verbs) { return "unknown-session" }
+
+    if (-not $adjectives -or -not $nouns -or -not $verbs) {
+        return "unknown-session"
+    }
+
     if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
     $clean = $uuid -replace "-", ""
@@ -55,116 +75,36 @@ function Convert-UuidToWords {
         $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" }
+    } catch {
+        return "unknown-session"
+    }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
 # READ INPUT
 # ═══════════════════════════════════════════════════════════════════════════
 $inputJson = [Console]::In.ReadToEnd()
+
 try {
     $input = $inputJson | ConvertFrom-Json
     $sessionId = $input.session_id
 } catch {
     $sessionId = "unknown"
 }
-if (-not $sessionId) { $sessionId = "unknown" }
 
 $sessionName = Convert-UuidToWords $sessionId
 
 # ═══════════════════════════════════════════════════════════════════════════
-# LOAD AUTH
-# ═══════════════════════════════════════════════════════════════════════════
-$authToken = ""
-$userId = ""
-$configFile = Join-Path $EkkosConfigDir "config.json"
-if (Test-Path $configFile) {
-    try {
-        $config = Get-Content $configFile -Raw | ConvertFrom-Json
-        $authToken = $config.hookApiKey
-        if (-not $authToken) { $authToken = $config.apiKey }
-        $userId = $config.userId
-    } catch {}
-}
-if (-not $authToken) { exit 0 }
-
-# ═══════════════════════════════════════════════════════════════════════════
-# TIME MACHINE: Check for pending "Continue from here" requests
+# INITIALIZE STATE DIRECTORY
 # ═══════════════════════════════════════════════════════════════════════════
-$timeMachineSession = ""
-$timeMachineFromTurn = ""
-$timeMachineToTurn = ""
-$restoreRequestId = $env:EKKOS_RESTORE
-
-if (-not $timeMachineSession -and $userId) {
-    try {
-        $headers = @{ "Authorization" = "Bearer $authToken" }
-        $pendingResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/context/restore-request/pending?user_id=$userId" `
-            -Method GET -Headers $headers -TimeoutSec 3
-
-        if ($pendingResponse.pending -eq $true -and $pendingResponse.request) {
-            $timeMachineSession = $pendingResponse.request.session_id
-            $timeMachineFromTurn = $pendingResponse.request.from_turn
-            $timeMachineToTurn = $pendingResponse.request.to_turn
-            $restoreRequestId = $pendingResponse.request.request_id
-
-            if ($timeMachineSession) {
-                $esc = [char]27
-                [Console]::Error.WriteLine("")
-                [Console]::Error.WriteLine("${esc}[0;35m------------------------------------------------------------------------${esc}[0m")
-                [Console]::Error.WriteLine("${esc}[0;35m${esc}[1m  TIME MACHINE${esc}[0m ${esc}[2m| Restoring session from web request...${esc}[0m")
-                [Console]::Error.WriteLine("${esc}[0;35m------------------------------------------------------------------------${esc}[0m")
-
-                $consumeBody = @{ request_id = $restoreRequestId } | ConvertTo-Json -Depth 10
-                try {
-                    Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/context/restore-request/consume" `
-                        -Method POST -Headers @{ "Authorization" = "Bearer $authToken"; "Content-Type" = "application/json" } `
-                        -Body ([System.Text.Encoding]::UTF8.GetBytes($consumeBody)) -TimeoutSec 3 | Out-Null
-                } catch {}
-            }
-        }
-    } catch {}
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# SESSION PERSISTENCE - PROJECT-LOCAL for isolation
-# ═══════════════════════════════════════════════════════════════════════════
-$projectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
 $stateDir = Join-Path $env:USERPROFILE ".claude\state"
-$projectSessionDir = Join-Path $stateDir "sessions"
-
-if (-not (Test-Path $stateDir)) { New-Item -ItemType Directory -Path $stateDir -Force | Out-Null }
-if (-not (Test-Path $projectSessionDir)) { New-Item -ItemType Directory -Path $projectSessionDir -Force | Out-Null }
-
-$savedTurnCount = 0
-$mostRecentSession = ""
-
-if ($sessionId -ne "unknown") {
-    $turnFile = Join-Path $projectSessionDir "$sessionId.turn"
-    if (Test-Path $turnFile) {
-        try { $savedTurnCount = [int](Get-Content $turnFile -Raw).Trim() } catch { $savedTurnCount = 0 }
-        $mostRecentSession = $sessionId
-    } else {
-        $mostRecentFile = Get-ChildItem "$projectSessionDir\*.turn" -ErrorAction SilentlyContinue |
-            Sort-Object LastWriteTime -Descending | Select-Object -First 1
-        if ($mostRecentFile) {
-            $mostRecentSession = $mostRecentFile.BaseName
-            try { $savedTurnCount = [int](Get-Content $mostRecentFile.FullName -Raw).Trim() } catch { $savedTurnCount = 0 }
-        }
-    }
+if (-not (Test-Path $stateDir)) {
+    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
 }
 
-$sessionFile = Join-Path $stateDir "current-session.json"
-$sessionData = @{
-    session_id = $sessionId
-    session_name = $sessionName
-    instance_id = $EkkosInstanceId
-    timestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-    project_root = $projectRoot
-} | ConvertTo-Json -Depth 10
-Set-Content -Path $sessionFile -Value $sessionData -Force
-
+# Reset turn counter for new session
 $stateFile = Join-Path $stateDir "hook-state.json"
 $state = @{
     turn = 0
@@ -173,137 +113,34 @@ $state = @{
     instance_id = $EkkosInstanceId
     started_at = (Get-Date).ToString("o")
 } | ConvertTo-Json -Depth 10
-Set-Content -Path $stateFile -Value $state -Force
 
-# ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: Initialize session tracking file
-# ═══════════════════════════════════════════════════════════════════════════
-$ekkosDir = Join-Path $projectRoot ".ekkos"
-if (-not (Test-Path $ekkosDir)) { New-Item -ItemType Directory -Path $ekkosDir -Force | Out-Null }
+Set-Content -Path $stateFile -Value $state -Force
 
-$goldenLoopFile = Join-Path $ekkosDir "golden-loop-current.json"
-$goldenLoop = @{
-    phase = "idle"
-    turn = 0
-    session = $sessionId
-    timestamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-    stats = @{ retrieved = 0; applied = 0; forged = 0 }
+# Save session ID for other hooks
+$sessionFile = Join-Path $stateDir "current-session.json"
+$sessionData = @{
+    session_id = $sessionId
+    session_name = $sessionName
+    instance_id = $EkkosInstanceId
 } | ConvertTo-Json -Depth 10
-Set-Content -Path $goldenLoopFile -Value $goldenLoop -Force
+
+Set-Content -Path $sessionFile -Value $sessionData -Force
 
 # ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Initialize session
+# LOCAL CACHE: Initialize session in Tier 0 cache
+# Per v1.2 ADDENDUM: Pass instanceId for namespacing
 # ═══════════════════════════════════════════════════════════════════════════
 $captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
 if ($captureCmd -and $sessionId -ne "unknown") {
     try {
+        # NEW format: ekkos-capture init <instance_id> <session_id> <session_name>
         Start-Job -ScriptBlock {
             param($instanceId, $sessId, $sessName)
-            try { & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null } catch {}
+            try {
+                & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null
+            } catch {}
         } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName | Out-Null
     } catch {}
 }
 
-# ═══════════════════════════════════════════════════════════════════════════
-# 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"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# TIME MACHINE RESTORATION
-# ═══════════════════════════════════════════════════════════════════════════
-if ($timeMachineSession) {
-    [Console]::Error.WriteLine("")
-    $tmPreview = $timeMachineSession.Substring(0, [Math]::Min(12, $timeMachineSession.Length))
-    [Console]::Error.WriteLine("${MAGENTA}${BOLD}  TIME MACHINE${RESET} ${DIM}| Restoring past session: ${tmPreview}...${RESET}")
-
-    $recallBody = @{ session_id = $timeMachineSession; last_n = 15; format = "summary" }
-    if ($timeMachineFromTurn -and $timeMachineToTurn) {
-        $recallBody = @{ session_id = $timeMachineSession; from_turn = [int]$timeMachineFromTurn; to_turn = [int]$timeMachineToTurn; format = "summary" }
-    } elseif ($timeMachineFromTurn) {
-        $recallBody = @{ session_id = $timeMachineSession; from_turn = [int]$timeMachineFromTurn; format = "summary" }
-    }
-
-    $recallJson = $recallBody | ConvertTo-Json -Depth 10
-    try {
-        $restoreResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/turns/recall" `
-            -Method POST `
-            -Headers @{ "Authorization" = "Bearer $authToken"; "Content-Type" = "application/json" } `
-            -Body ([System.Text.Encoding]::UTF8.GetBytes($recallJson)) -TimeoutSec 5
-
-        $restoredCount = ($restoreResponse.turns | Measure-Object).Count
-        if ($restoredCount -gt 0) {
-            [Console]::Error.WriteLine("${MAGENTA}   ✓${RESET} Restored $restoredCount turns from past session")
-            [Console]::Error.WriteLine("")
-
-            $turnsOutput = ""
-            foreach ($t in $restoreResponse.turns) {
-                $q = if ($t.user_query) { $t.user_query.Substring(0, [Math]::Min(100, $t.user_query.Length)) } else { "..." }
-                $r = if ($t.assistant_response) { $t.assistant_response.Substring(0, [Math]::Min(200, $t.assistant_response.Length)) } else { "..." }
-                $turnLine = "**Turn $($t.turn_number)**: $q..."
-                [Console]::Error.WriteLine($turnLine)
-                [Console]::Error.WriteLine("> $r...")
-                [Console]::Error.WriteLine("")
-                $turnsOutput += "$turnLine`n> $r...`n`n"
-            }
-            Write-Output $turnsOutput
-
-            [Console]::Error.WriteLine("${DIM}You've traveled to a past session. Continue from here!${RESET}")
-            [Console]::Error.WriteLine("")
-        }
-    } catch {}
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# DIRECTIVE RETRIEVAL: Fetch user's MUST/NEVER/PREFER/AVOID rules
-# ═══════════════════════════════════════════════════════════════════════════
-if ($authToken) {
-    try {
-        $directivesResponse = Invoke-RestMethod -Uri "$MemoryApiUrl/api/v1/memory/directives?limit=20" `
-            -Method GET -Headers @{ "Authorization" = "Bearer $authToken" } -TimeoutSec 3
-
-        $directiveCount = $directivesResponse.count
-        if ($directiveCount -gt 0) {
-            Write-Output "<system-reminder>"
-            Write-Output "USER DIRECTIVES (FOLLOW THESE):"
-            Write-Output ""
-
-            foreach ($type in @("MUST", "NEVER", "PREFER", "AVOID")) {
-                $rules = $directivesResponse.$type
-                if ($rules -and ($rules | Measure-Object).Count -gt 0) {
-                    Write-Output "${type}:"
-                    $rules | Select-Object -First 5 | ForEach-Object { Write-Output "  - $($_.rule)" }
-                }
-            }
-
-            Write-Output "</system-reminder>"
-            [Console]::Error.WriteLine("${GREEN}  $directiveCount directives loaded${RESET}")
-        }
-    } catch {}
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# STATUS DISPLAY
-# ═══════════════════════════════════════════════════════════════════════════
-if ($savedTurnCount -gt 0) {
-    [Console]::Error.WriteLine("")
-    [Console]::Error.WriteLine("${CYAN}${BOLD}  ekkOS${RESET} ${DIM}|${RESET} Session: $sessionId ${DIM}|${RESET} ${GREEN}$savedTurnCount turns${RESET}")
-}
-
-if ($timeMachineSession) {
-    $tmP = $timeMachineSession.Substring(0, [Math]::Min(12, $timeMachineSession.Length))
-    [Console]::Error.WriteLine("${MAGENTA}------------------------------------------------------------------------${RESET}")
-    [Console]::Error.WriteLine("${MAGENTA}  ${RESET} Time Machine active - Restored from session ${tmP}...")
-    [Console]::Error.WriteLine("${MAGENTA}------------------------------------------------------------------------${RESET}")
-} elseif ($savedTurnCount -gt 0) {
-    [Console]::Error.WriteLine("${GREEN}------------------------------------------------------------------------${RESET}")
-    [Console]::Error.WriteLine("${GREEN}✓${RESET} Session continued - $savedTurnCount turns preserved - Ready to resume")
-    [Console]::Error.WriteLine("${GREEN}------------------------------------------------------------------------${RESET}")
-} else {
-    [Console]::Error.WriteLine("${CYAN}✓${RESET} New session started")
-}
-[Console]::Error.WriteLine("")
-
-exit 0
+Write-Output "ekkOS session initialized"

package/templates/hooks/session-start.sh

@@ -78,7 +78,7 @@ fi
 
 [ -z "$AUTH_TOKEN" ] && exit 0
 
-MEMORY_API_URL="https://api.ekkos.dev"
+MEMORY_API_URL="https://mcp.ekkos.dev"
 
 # ═══════════════════════════════════════════════════════════════════════════
 # TIME MACHINE: Check for pending "Continue from here" requests