@ekkos/cli 1.0.33 → 1.0.35

package/templates/hooks/session-start.ps1

@@ -1,146 +1,446 @@
 # ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: SessionStart - Initialize session (Windows)
+# ekkOS_ Hook: SessionStart - MINIMAL + AUTO-RESTORE + TIME MACHINE CONTINUE
 # MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
 # EKKOS_MANAGED=1
-# EKKOS_MANIFEST_SHA256=<computed-at-build>
-# EKKOS_TEMPLATE_VERSION=1.0.0
+# ═══════════════════════════════════════════════════════════════════════════
+# 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
 #
-# 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
+# Per spec v1.2 Addendum: NO jq dependency
 # ═══════════════════════════════════════════════════════════════════════════
 
 $ErrorActionPreference = "SilentlyContinue"
 
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
+
 # ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
+# CONFIG PATHS - 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"
+$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()
 
 # ═══════════════════════════════════════════════════════════════════════════
-# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
+# JSON parsing helper (no jq) - pipes JSON to node, extracts dot-path value
 # ═══════════════════════════════════════════════════════════════════════════
-$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
+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" }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load session words from JSON file - NO HARDCODED ARRAYS
+# Load auth
 # ═══════════════════════════════════════════════════════════════════════════
-$script:SessionWords = $null
-
-function Load-SessionWords {
-    $wordsFile = $SessionWordsJson
+$EKKOS_CONFIG = Join-Path $env:USERPROFILE ".ekkos\config.json"
+$AUTH_TOKEN = ""
+$USER_ID = ""
 
-    if (-not (Test-Path $wordsFile)) {
-        $wordsFile = $SessionWordsDefault
+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 (-not (Test-Path $wordsFile)) {
-        return $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 $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")
+}
+
+# Check API for pending requests (if we have user_id)
+if ((-not $TIME_MACHINE_SESSION) -and $USER_ID) {
+    $PENDING_RESPONSE_RAW = ""
     try {
-        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
+        $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
     } catch {
-        return $null
+        $PENDING_RESPONSE_RAW = ""
     }
-}
 
-function Convert-UuidToWords {
-    param([string]$uuid)
+    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 = "{}"
+            }
+        }
 
-    if (-not $script:SessionWords) {
-        Load-SessionWords
-    }
+        $IS_PENDING = Parse-JsonValue $PENDING_JSON ".pending"
 
-    if (-not $script:SessionWords) {
-        return "unknown-session"
-    }
+        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"
 
-    $adjectives = $script:SessionWords.adjectives
-    $nouns = $script:SessionWords.nouns
-    $verbs = $script:SessionWords.verbs
+            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")
 
-    if (-not $adjectives -or -not $nouns -or -not $verbs) {
-        return "unknown-session"
+                # 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 $uuid -or $uuid -eq "unknown") { 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"
 
-    $clean = $uuid -replace "-", ""
-    if ($clean.Length -lt 12) { return "unknown-session" }
+# 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
+}
 
-    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
+# Use Claude's RAW_SESSION_ID directly (from session_id field)
+$CURRENT_SESSION_ID = $SESSION_ID
 
-        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
-    } catch {
-        return "unknown-session"
+# Find most recent session in THIS PROJECT for auto-restore
+$MOST_RECENT_SESSION = ""
+$SAVED_TURN_COUNT = 0
+
+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
+            }
+        }
     }
 }
 
+# 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
+}
+
 # ═══════════════════════════════════════════════════════════════════════════
-# READ INPUT
+# GOLDEN LOOP: Initialize session tracking file
 # ═══════════════════════════════════════════════════════════════════════════
-$inputJson = [Console]::In.ReadToEnd()
-
-try {
-    $input = $inputJson | ConvertFrom-Json
-    $sessionId = $input.session_id
-} catch {
-    $sessionId = "unknown"
+$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"
 
-$sessionName = Convert-UuidToWords $sessionId
+# 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 {}
 
 # ═══════════════════════════════════════════════════════════════════════════
-# INITIALIZE STATE DIRECTORY
+# AUTO-RESTORE REMOVED: Manual /continue only (saves 79% token burn!)
 # ═══════════════════════════════════════════════════════════════════════════
-$stateDir = Join-Path $env:USERPROFILE ".claude\state"
-if (-not (Test-Path $stateDir)) {
-    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
-}
+# 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)
+# ═══════════════════════════════════════════════════════════════════════════
+
+# 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")
 
-# 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 recall request with turn range
+    $RECALL_BODY = "{`"session_id`": `"$TIME_MACHINE_SESSION`", `"last_n`": 15, `"format`": `"summary`"}"
 
-Set-Content -Path $stateFile -Value $state -Force
+    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
+    }
 
-# 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
+    # 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("")
+
+        # 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 $sessionFile -Value $sessionData -Force
+            $turnLine = "**Turn $tn**: $q..."
+            $responseLine = "> $r..."
+            $turnsOutput += "$turnLine`n$responseLine`n`n"
+        }
+
+        # 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("")
+    }
+}
 
 # ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Initialize session in Tier 0 cache
-# Per v1.2 ADDENDUM: Pass instanceId for namespacing
+# DIRECTIVE RETRIEVAL: Fetch user's MUST/NEVER/PREFER/AVOID rules
 # ═══════════════════════════════════════════════════════════════════════════
-$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
-if ($captureCmd -and $sessionId -ne "unknown") {
+$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
     try {
-        # NEW format: ekkos-capture init <instance_id> <session_id> <session_name>
-        Start-Job -ScriptBlock {
-            param($instanceId, $sessId, $sessName)
+        $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 {
             try {
-                & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null
-            } catch {}
-        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName | Out-Null
-    } catch {}
+                $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")
 }
+[Console]::Error.WriteLine("")
 
-Write-Output "ekkOS session initialized"
+exit 0