@ekkos/cli 1.0.35 → 1.1.0

package/templates/hooks/session-start.ps1

@@ -1,446 +1,146 @@
 # ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: SessionStart - MINIMAL + AUTO-RESTORE + TIME MACHINE CONTINUE
+# 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
-# 3. Auto-restore from L2 if recent turns exist (FAST TRIM support)
-#
-# TIME MACHINE FLOW:
-# User clicks "Continue from here" on web -> API queues request ->
-# User runs `claude` -> This hook detects pending request ->
-# Restores THAT session's context -> Seamless time travel!
-#
-# FAST TRIM FLOW:
-# User runs /clear -> session-start detects fresh session ->
-# Checks L2 for recent turns -> Auto-injects last 15 turns -> Seamless continuity
+# EKKOS_MANIFEST_SHA256=<computed-at-build>
+# EKKOS_TEMPLATE_VERSION=1.0.0
 #
-# Per spec v1.2 Addendum: NO jq dependency
+# 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"
 
-$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" }
-$JsonParseHelper = Join-Path $EkkosConfigDir ".helpers\json-parse.cjs"
-
-$INPUT = [Console]::In.ReadToEnd()
+$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"
 
 # ═══════════════════════════════════════════════════════════════════════════
-# JSON parsing helper (no jq) - pipes JSON to node, extracts dot-path value
+# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
 # ═══════════════════════════════════════════════════════════════════════════
-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 ""
-    }
-}
-
-$SESSION_ID = Parse-JsonValue $INPUT ".session_id"
-if (-not $SESSION_ID) { $SESSION_ID = "unknown" }
-
-$TRANSCRIPT_PATH = Parse-JsonValue $INPUT ".transcript_path"
-$SOURCE = Parse-JsonValue $INPUT ".source"
-if (-not $SOURCE) { $SOURCE = "unknown" }
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load auth
+# Load session words from JSON file - NO HARDCODED ARRAYS
 # ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_CONFIG = Join-Path $env:USERPROFILE ".ekkos\config.json"
-$AUTH_TOKEN = ""
-$USER_ID = ""
+$script:SessionWords = $null
 
-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
-}
+function Load-SessionWords {
+    $wordsFile = $SessionWordsJson
 
-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 (Test-Path $wordsFile)) {
+        $wordsFile = $SessionWordsDefault
     }
-}
-
-if (-not $AUTH_TOKEN) { exit 0 }
-
-$MEMORY_API_URL = "https://mcp.ekkos.dev"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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"
 
-# ═══════════════════════════════════════════════════════════════════════════
-# TIME MACHINE: Check for pending "Continue from here" requests
-# ═══════════════════════════════════════════════════════════════════════════
-$RESTORE_REQUEST_ID = $env:EKKOS_RESTORE
-$TIME_MACHINE_SESSION = ""
-$TIME_MACHINE_FROM_TURN = ""
-$TIME_MACHINE_TO_TURN = ""
-
-# Check via env var first, then API
-if ($RESTORE_REQUEST_ID) {
-    [Console]::Error.WriteLine("$MAGENTA  Time Machine request detected: $RESTORE_REQUEST_ID$RESET")
-}
+    if (-not (Test-Path $wordsFile)) {
+        return $null
+    }
 
-# Check API for pending requests (if we have user_id)
-if ((-not $TIME_MACHINE_SESSION) -and $USER_ID) {
-    $PENDING_RESPONSE_RAW = ""
     try {
-        $PENDING_RESPONSE_RAW = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/context/restore-request/pending?user_id=$USER_ID" `
-            -Method GET `
-            -Headers @{ Authorization = "Bearer $AUTH_TOKEN" } `
-            -TimeoutSec 3 `
-            -ErrorAction Stop
+        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
     } catch {
-        $PENDING_RESPONSE_RAW = ""
+        return $null
     }
+}
 
-    if ($PENDING_RESPONSE_RAW) {
-        # Convert response object to JSON string for Parse-JsonValue
-        $PENDING_JSON = ""
-        if ($PENDING_RESPONSE_RAW -is [string]) {
-            $PENDING_JSON = $PENDING_RESPONSE_RAW
-        } else {
-            try {
-                $PENDING_JSON = $PENDING_RESPONSE_RAW | ConvertTo-Json -Depth 10 -Compress
-            } catch {
-                $PENDING_JSON = "{}"
-            }
-        }
+function Convert-UuidToWords {
+    param([string]$uuid)
 
-        $IS_PENDING = Parse-JsonValue $PENDING_JSON ".pending"
+    if (-not $script:SessionWords) {
+        Load-SessionWords
+    }
 
-        if ($IS_PENDING -eq "true" -or $IS_PENDING -eq "True") {
-            $TIME_MACHINE_SESSION = Parse-JsonValue $PENDING_JSON ".request.session_id"
-            $TIME_MACHINE_FROM_TURN = Parse-JsonValue $PENDING_JSON ".request.from_turn"
-            $TIME_MACHINE_TO_TURN = Parse-JsonValue $PENDING_JSON ".request.to_turn"
-            $RESTORE_REQUEST_ID = Parse-JsonValue $PENDING_JSON ".request.request_id"
+    if (-not $script:SessionWords) {
+        return "unknown-session"
+    }
 
-            if ($TIME_MACHINE_SESSION) {
-                [Console]::Error.WriteLine("")
-                [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-                [Console]::Error.WriteLine("$MAGENTA${BOLD}  TIME MACHINE$RESET $DIM| Restoring session from web request...$RESET")
-                [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
+    $adjectives = $script:SessionWords.adjectives
+    $nouns = $script:SessionWords.nouns
+    $verbs = $script:SessionWords.verbs
 
-                # Mark request as consumed (background, non-blocking)
-                $consumeBody = "{`"request_id`": `"$RESTORE_REQUEST_ID`"}"
-                Start-Job -ScriptBlock {
-                    param($url, $token, $body)
-                    try {
-                        Invoke-RestMethod -Uri "$url/api/v1/context/restore-request/consume" `
-                            -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, $AUTH_TOKEN, $consumeBody | Out-Null
-            }
-        }
+    if (-not $adjectives -or -not $nouns -or -not $verbs) {
+        return "unknown-session"
     }
-}
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Session ID persistence - PROJECT-LOCAL for isolation
-# ═══════════════════════════════════════════════════════════════════════════
-$STATE_DIR = Join-Path $ProjectRoot ".claude\state"
-if (-not (Test-Path $STATE_DIR)) {
-    New-Item -ItemType Directory -Path $STATE_DIR -Force | Out-Null
-}
-$SESSION_FILE = Join-Path $STATE_DIR "current-session.json"
-
-# Project-local session storage (isolated per project)
-$PROJECT_SESSION_DIR = Join-Path $STATE_DIR "sessions"
-if (-not (Test-Path $PROJECT_SESSION_DIR)) {
-    New-Item -ItemType Directory -Path $PROJECT_SESSION_DIR -Force | Out-Null
-}
+    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
-# Use Claude's RAW_SESSION_ID directly (from session_id field)
-$CURRENT_SESSION_ID = $SESSION_ID
+    $clean = $uuid -replace "-", ""
+    if ($clean.Length -lt 12) { return "unknown-session" }
 
-# Find most recent session in THIS PROJECT for auto-restore
-$MOST_RECENT_SESSION = ""
-$SAVED_TURN_COUNT = 0
+    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
 
-if ($CURRENT_SESSION_ID -and $CURRENT_SESSION_ID -ne "unknown") {
-    # Check if THIS session has saved turns (for /clear continuity)
-    $TURN_COUNTER_FILE = Join-Path $PROJECT_SESSION_DIR "$CURRENT_SESSION_ID.turn"
-    if (Test-Path $TURN_COUNTER_FILE) {
-        try {
-            $SAVED_TURN_COUNT = [int](Get-Content $TURN_COUNTER_FILE -Raw).Trim()
-        } catch {
-            $SAVED_TURN_COUNT = 0
-        }
-        $MOST_RECENT_SESSION = $CURRENT_SESSION_ID
-    } else {
-        # Fresh start: find most recent session in project
-        $turnFiles = Get-ChildItem -Path $PROJECT_SESSION_DIR -Filter "*.turn" -ErrorAction SilentlyContinue |
-            Sort-Object LastWriteTime -Descending |
-            Select-Object -First 1
-        if ($turnFiles) {
-            $MOST_RECENT_SESSION = [System.IO.Path]::GetFileNameWithoutExtension($turnFiles.Name)
-            try {
-                $SAVED_TURN_COUNT = [int](Get-Content $turnFiles.FullName -Raw).Trim()
-            } catch {
-                $SAVED_TURN_COUNT = 0
-            }
-        }
+        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
+    } catch {
+        return "unknown-session"
     }
 }
 
-# Save current session info
-if ($CURRENT_SESSION_ID) {
-    $TIMESTAMP_UTC = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-    $projectRootNorm = $ProjectRoot -replace '\\', '/'
-    $sessionInfoJson = "{`"session_id`": `"$CURRENT_SESSION_ID`", `"timestamp`": `"$TIMESTAMP_UTC`", `"project_root`": `"$projectRootNorm`"}"
-    Set-Content -Path $SESSION_FILE -Value $sessionInfoJson -Force
-}
-
 # ═══════════════════════════════════════════════════════════════════════════
-# GOLDEN LOOP: Initialize session tracking file
+# READ INPUT
 # ═══════════════════════════════════════════════════════════════════════════
-$EKKOS_DIR = Join-Path $ProjectRoot ".ekkos"
-if (-not (Test-Path $EKKOS_DIR)) {
-    New-Item -ItemType Directory -Path $EKKOS_DIR -Force | Out-Null
-}
-$GOLDEN_LOOP_FILE = Join-Path $EKKOS_DIR "golden-loop-current.json"
+$inputJson = [Console]::In.ReadToEnd()
 
-# Initialize with session start state using Node (no jq)
-$glPathEscaped = $GOLDEN_LOOP_FILE -replace '\\', '\\\\'
 try {
-    node -e "
-const fs = require('fs');
-const data = {
-    phase: 'idle',
-    turn: 0,
-    session: '$CURRENT_SESSION_ID',
-    timestamp: new Date().toISOString(),
-    stats: { retrieved: 0, applied: 0, forged: 0 }
-};
-fs.writeFileSync('$glPathEscaped', JSON.stringify(data, null, 2));
-" 2>$null
-} catch {}
+    $input = $inputJson | ConvertFrom-Json
+    $sessionId = $input.session_id
+} catch {
+    $sessionId = "unknown"
+}
+
+$sessionName = Convert-UuidToWords $sessionId
 
 # ═══════════════════════════════════════════════════════════════════════════
-# AUTO-RESTORE REMOVED: Manual /continue only (saves 79% token burn!)
-# ═══════════════════════════════════════════════════════════════════════════
-# WHY REMOVED:
-# - Auto-restore burned 5,000 tokens per turn on session start
-# - Manual /continue: one-time cost + clean slate (79% token savings!)
-# - Manual /continue is 10x more powerful (Bash + multi-source + narrative)
-#
-# KEPT: Time Machine feature (explicit user request)
+# INITIALIZE STATE DIRECTORY
 # ═══════════════════════════════════════════════════════════════════════════
+$stateDir = Join-Path $env:USERPROFILE ".claude\state"
+if (-not (Test-Path $stateDir)) {
+    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
+}
 
-# Handle Time Machine requests (explicit user action)
-if ($TIME_MACHINE_SESSION) {
-    $tmPreview = $TIME_MACHINE_SESSION
-    if ($tmPreview.Length -gt 12) {
-        $tmPreview = $tmPreview.Substring(0, 12)
-    }
-
-    [Console]::Error.WriteLine("")
-    [Console]::Error.WriteLine("$MAGENTA${BOLD}  TIME MACHINE$RESET $DIM| Restoring past session: ${tmPreview}...$RESET")
-
-    # Build recall request with turn range
-    $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"last_n`": 15, `"format`": `"summary`"}"
-
-    if ($TIME_MACHINE_FROM_TURN -and $TIME_MACHINE_TO_TURN) {
-        $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"from_turn`": $TIME_MACHINE_FROM_TURN, `"to_turn`": $TIME_MACHINE_TO_TURN, `"format`": `"summary`"}"
-    } elseif ($TIME_MACHINE_FROM_TURN) {
-        $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"from_turn`": $TIME_MACHINE_FROM_TURN, `"format`": `"summary`"}"
-    }
-
-    # Fetch turns from L2
-    $RESTORE_RESPONSE = $null
-    try {
-        $RESTORE_RESPONSE = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/turns/recall" `
-            -Method POST `
-            -Headers @{ Authorization = "Bearer $AUTH_TOKEN"; "Content-Type" = "application/json" } `
-            -Body ([System.Text.Encoding]::UTF8.GetBytes($RECALL_BODY)) `
-            -TimeoutSec 5 `
-            -ErrorAction Stop
-    } catch {
-        $RESTORE_RESPONSE = $null
-    }
-
-    # Check if we got turns back
-    $RESTORED_COUNT = 0
-    $RESTORED_TURNS = @()
-    if ($RESTORE_RESPONSE -and $RESTORE_RESPONSE.turns) {
-        $RESTORED_TURNS = @($RESTORE_RESPONSE.turns)
-        $RESTORED_COUNT = $RESTORED_TURNS.Count
-    }
-
-    if ($RESTORED_COUNT -gt 0) {
-        [Console]::Error.WriteLine("$MAGENTA   $RESET Restored $RESTORED_COUNT turns from past session")
-        [Console]::Error.WriteLine("")
-        [Console]::Error.WriteLine("$MAGENTA${BOLD}## Time Machine Context$RESET")
-        [Console]::Error.WriteLine("")
+# Reset turn counter for new session
+$stateFile = Join-Path $stateDir "hook-state.json"
+$state = @{
+    turn = 0
+    session_id = $sessionId
+    session_name = $sessionName
+    instance_id = $EkkosInstanceId
+    started_at = (Get-Date).ToString("o")
+} | ConvertTo-Json -Depth 10
 
-        # Build turns output for both stderr (display) and stdout (context injection)
-        $turnsOutput = ""
-        foreach ($t in $RESTORED_TURNS) {
-            $q = ""
-            if ($t.user_query) {
-                $q = $t.user_query
-                if ($q.Length -gt 100) { $q = $q.Substring(0, 100) }
-            }
-            $r = ""
-            if ($t.assistant_response) {
-                $r = $t.assistant_response
-                if ($r.Length -gt 200) { $r = $r.Substring(0, 200) }
-            }
-            $tn = if ($t.turn_number) { $t.turn_number } else { "?" }
+Set-Content -Path $stateFile -Value $state -Force
 
-            $turnLine = "**Turn $tn**: $q..."
-            $responseLine = "> $r..."
-            $turnsOutput += "$turnLine`n$responseLine`n`n"
-        }
+# 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
 
-        # Output to stderr (visible in terminal)
-        [Console]::Error.WriteLine($turnsOutput)
-        # Output to stdout (injected into context)
-        Write-Output $turnsOutput
-
-        [Console]::Error.WriteLine("")
-        [Console]::Error.WriteLine("${DIM}You've traveled to a past session. Continue from here!$RESET")
-        [Console]::Error.WriteLine("")
-    }
-}
+Set-Content -Path $sessionFile -Value $sessionData -Force
 
 # ═══════════════════════════════════════════════════════════════════════════
-# DIRECTIVE RETRIEVAL: Fetch user's MUST/NEVER/PREFER/AVOID rules
+# LOCAL CACHE: Initialize session in Tier 0 cache
+# Per v1.2 ADDENDUM: Pass instanceId for namespacing
 # ═══════════════════════════════════════════════════════════════════════════
-$DIRECTIVES_INJECTED = $false
-$DIRECTIVE_COUNT = 0
-
-# Only fetch if we have auth
-if ($AUTH_TOKEN) {
-    # Fetch directives (top 20 by priority to avoid token bloat)
-    $DIRECTIVES_RESPONSE_RAW = $null
+$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
+if ($captureCmd -and $sessionId -ne "unknown") {
     try {
-        $DIRECTIVES_RESPONSE_RAW = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/memory/directives?limit=20" `
-            -Method GET `
-            -Headers @{ Authorization = "Bearer $AUTH_TOKEN" } `
-            -TimeoutSec 3 `
-            -ErrorAction Stop
-    } catch {
-        $DIRECTIVES_RESPONSE_RAW = $null
-    }
-
-    if ($DIRECTIVES_RESPONSE_RAW) {
-        # Convert response object to JSON string for Parse-JsonValue / Node
-        $DIRECTIVES_JSON = ""
-        if ($DIRECTIVES_RESPONSE_RAW -is [string]) {
-            $DIRECTIVES_JSON = $DIRECTIVES_RESPONSE_RAW
-        } else {
+        # NEW format: ekkos-capture init <instance_id> <session_id> <session_name>
+        Start-Job -ScriptBlock {
+            param($instanceId, $sessId, $sessName)
             try {
-                $DIRECTIVES_JSON = $DIRECTIVES_RESPONSE_RAW | ConvertTo-Json -Depth 10 -Compress
-            } catch {
-                $DIRECTIVES_JSON = "{}"
-            }
-        }
-
-        $DIRECTIVE_COUNT_STR = Parse-JsonValue $DIRECTIVES_JSON ".count"
-        if ($DIRECTIVE_COUNT_STR -match '^\d+$') {
-            $DIRECTIVE_COUNT = [int]$DIRECTIVE_COUNT_STR
-        }
-
-        if ($DIRECTIVE_COUNT -gt 0) {
-            $DIRECTIVES_INJECTED = $true
-
-            # Extract MUST/NEVER/PREFER/AVOID arrays using Node
-            Write-Output "<system-reminder>"
-            Write-Output "USER DIRECTIVES (FOLLOW THESE):"
-            Write-Output ""
-
-            $directiveOutput = $DIRECTIVES_JSON | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const types = ['MUST', 'NEVER', 'PREFER', 'AVOID'];
-types.forEach(type => {
-    const rules = (d[type] || []).slice(0, 5);
-    if (rules.length > 0) {
-        console.log(type + ':');
-        rules.forEach(r => console.log('  - ' + (r.rule || '')));
-    }
-});
-" 2>$null
-
-            if ($directiveOutput) {
-                Write-Output $directiveOutput
-            }
-
-            Write-Output "</system-reminder>"
-            [Console]::Error.WriteLine("$GREEN  $DIRECTIVE_COUNT directives loaded$RESET")
-        }
-    }
-}
-
-# Simple status display (no auto-restore)
-if ($SAVED_TURN_COUNT -gt 0) {
-    [Console]::Error.WriteLine("")
-    $displaySessionId = if ($CURRENT_SESSION_ID) { $CURRENT_SESSION_ID } else { $SESSION_ID }
-    [Console]::Error.WriteLine("$CYAN${BOLD}  ekkOS$RESET $DIM|$RESET Session: $displaySessionId $DIM|$RESET $GREEN$SAVED_TURN_COUNT turns$RESET")
-}
-
-# Final confirmation that's always visible
-if ($TIME_MACHINE_SESSION) {
-    $tmFinalPreview = $TIME_MACHINE_SESSION
-    if ($tmFinalPreview.Length -gt 12) {
-        $tmFinalPreview = $tmFinalPreview.Substring(0, 12)
-    }
-    [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-    [Console]::Error.WriteLine("$MAGENTA  $RESET Time Machine active - Restored from session ${tmFinalPreview}...")
-    [Console]::Error.WriteLine("$MAGENTA------------------------------------------------------------------------$RESET")
-} elseif ($SAVED_TURN_COUNT -gt 0) {
-    [Console]::Error.WriteLine("$GREEN------------------------------------------------------------------------$RESET")
-    [Console]::Error.WriteLine("${GREEN}$RESET Session continued - $SAVED_TURN_COUNT turns preserved - Ready to resume")
-    [Console]::Error.WriteLine("$GREEN------------------------------------------------------------------------$RESET")
-} else {
-    [Console]::Error.WriteLine("${CYAN}$RESET New session started")
+                & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null
+            } catch {}
+        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName | Out-Null
+    } catch {}
 }
-[Console]::Error.WriteLine("")
 
-exit 0
+Write-Output "ekkOS session initialized"