@ekkos/cli 1.2.14 → 1.2.16

package/dist/commands/run.js

@@ -439,7 +439,7 @@ let proxyModeEnabled = true;
 /**
  * Generate a unique session UUID and convert to human-readable name
  * Each CLI invocation gets a NEW session (not tied to project path)
- * Uses uuidToWords from state.ts for consistency with hooks
+ * Uses uuidToWords from state.ts for consistency across ekkOS components
  */
 function generateCliSessionName() {
     const sessionUuid = crypto.randomUUID();
@@ -469,12 +469,12 @@ function getEkkosEnv() {
         env.EKKOS_PROXY_MODE = '1';
         // Enable ultra-minimal mode by default (30%→20% eviction for constant-cost infinite context)
         env.EKKOS_ULTRA_MINIMAL = '1';
-        // Use placeholder for session name - will be bound by hook with Claude's real session
-        // This fixes the mismatch where CLI generated one name but Claude Code used another
-        // The hook calls POST /proxy/session/bind with Claude's actual session name
+        // Use a unique pending scope until Claude exposes its real session UUID.
+        // run.ts binds this scope to the real session immediately on transcript detect.
         if (!cliSessionName) {
-            cliSessionName = '_pending'; // Placeholder - hook will bind real name
-            cliSessionId = `pending-${Date.now()}`;
+            const pendingToken = crypto.randomBytes(8).toString('hex');
+            cliSessionName = `_pending-${pendingToken}`;
+            cliSessionId = `pending-${pendingToken}`;
             console.log(chalk_1.default.gray(`  📂 Session: pending (will bind to Claude session)`));
         }
         // Get full userId from config (NOT the truncated version from auth token)
@@ -1085,7 +1085,7 @@ async function run(options) {
     }
     // Check PTY availability early (deterministic, no async race)
     // Windows: SKIP node-pty entirely. ConPTY corrupts Ink's cursor management sequences
-    // (hide/show/move), causing ghost ▊ block cursor artifacts. Use stdio:'inherit' spawn
+    // (hide/show/move), causing ghost block cursor artifacts. Use stdio:'inherit' spawn
     // instead so Ink gets direct terminal access. Hooks still handle session tracking.
     const loadedPty = isWindows ? null : await loadPty();
     const usePty = loadedPty !== null;
@@ -1496,13 +1496,17 @@ async function run(options) {
                     const sessionId = file.replace('.jsonl', '');
                     transcriptPath = fullPath;
                     currentSessionId = sessionId;
+                    currentSession = (0, state_1.uuidToWords)(sessionId);
+                    (0, state_1.updateCurrentProcessSession)(currentSessionId, currentSession);
+                    (0, state_1.updateState)({ sessionId: currentSessionId, sessionName: currentSession });
+                    bindRealSessionToProxy(currentSession, 'fast-transcript', currentSessionId);
                     dlog(`[TRANSCRIPT] FAST DETECT: New transcript found! ${fullPath}`);
                     evictionDebugLog('TRANSCRIPT_SET', 'Fast poll detected new file', {
                         transcriptPath,
                         currentSessionId,
                         elapsedMs: Date.now() - launchTime
                     });
-                    startStreamTailer(transcriptPath, currentSessionId);
+                    startStreamTailer(transcriptPath, currentSessionId, currentSession || undefined);
                     // Stop polling
                     if (transcriptPollInterval) {
                         clearInterval(transcriptPollInterval);
@@ -1516,10 +1520,6 @@ async function run(options) {
             // Project dir doesn't exist yet, keep polling
         }
     }
-    // Start polling immediately
-    transcriptPollInterval = setInterval(pollForNewTranscript, 500);
-    pollForNewTranscript(); // Also run once immediately
-    dlog('[TRANSCRIPT] Fast polling started - looking for new jsonl files');
     // ══════════════════════════════════════════════════════════════════════════
     // SESSION NAME TRACKING (from live TUI output)
     // Claude prints: "· Turn N · groovy-koala-saves · 📅"
@@ -1561,6 +1561,10 @@ async function run(options) {
     let turnEndTimeout = null;
     const TURN_END_STABLE_MS = 500; // Must see idle prompt for 500ms
     let pendingClearAfterEviction = false; // Flag to trigger /clear after eviction
+    // Start polling after session-tracking state is initialized.
+    transcriptPollInterval = setInterval(pollForNewTranscript, 500);
+    pollForNewTranscript(); // Also run once immediately
+    dlog('[TRANSCRIPT] Fast polling started - looking for new jsonl files');
     // Debug log to eviction-debug.log for 400 error diagnosis
     function evictionDebugLog(category, msg, data) {
         try {
@@ -1615,22 +1619,30 @@ async function run(options) {
         dlog(`[TRANSCRIPT] Resolved by session ID (${source}): ${candidate}`);
         startStreamTailer(transcriptPath, currentSessionId, currentSession || undefined);
     }
-    function bindRealSessionToProxy(sessionName, source) {
+    function bindRealSessionToProxy(sessionName, source, sessionIdHint) {
         if (!proxyModeEnabled)
             return;
         if (!sessionName || sessionName === '_pending')
             return;
         if (boundProxySession === sessionName || bindingSessionInFlight === sessionName)
             return;
+        const pendingSession = cliSessionName?.startsWith('_pending') ? cliSessionName : undefined;
+        const bindSessionId = sessionIdHint || currentSessionId || undefined;
         bindingSessionInFlight = sessionName;
         void (async () => {
             const maxAttempts = 3;
             for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                const success = await (0, session_binding_1.bindSession)(sessionName, process.cwd());
+                const success = await (0, session_binding_1.bindSession)({
+                    realSession: sessionName,
+                    projectPath: process.cwd(),
+                    pendingSession,
+                    sessionId: bindSessionId,
+                });
                 if (success) {
                     boundProxySession = sessionName;
                     bindingSessionInFlight = null;
                     cliSessionName = sessionName;
+                    cliSessionId = bindSessionId || cliSessionId;
                     dlog(`[SESSION_BIND] Bound ${sessionName} from ${source} (attempt ${attempt}/${maxAttempts})`);
                     return;
                 }
@@ -2329,7 +2341,7 @@ async function run(options) {
             (0, state_1.updateState)({ sessionId: currentSessionId, sessionName: currentSession });
             dlog(`Session detected from UUID: ${currentSession}`);
             resolveTranscriptFromSessionId('session-id-from-output');
-            bindRealSessionToProxy(currentSession, 'session-id-from-output');
+            bindRealSessionToProxy(currentSession, 'session-id-from-output', currentSessionId || undefined);
         }
         // ════════════════════════════════════════════════════════════════════════
         // SESSION NAME DETECTION (PRIMARY METHOD)
@@ -2363,7 +2375,7 @@ async function run(options) {
                     // Also update global state for backwards compatibility
                     (0, state_1.updateState)({ sessionName: currentSession });
                     dlog(`Session detected from status line: ${currentSession} (observedSessionThisRun=true)`);
-                    bindRealSessionToProxy(currentSession, 'status-line');
+                    bindRealSessionToProxy(currentSession, 'status-line', currentSessionId || undefined);
                     resolveTranscriptFromSessionId('status-line');
                 }
             }
@@ -2371,7 +2383,7 @@ async function run(options) {
                 // Same session, just update timestamp
                 lastSeenSessionAt = Date.now();
                 if (boundProxySession !== detectedSession) {
-                    bindRealSessionToProxy(detectedSession, 'status-line-refresh');
+                    bindRealSessionToProxy(detectedSession, 'status-line-refresh', currentSessionId || undefined);
                 }
             }
         }

package/dist/index.js

@@ -51,6 +51,9 @@ const agent_1 = require("./commands/agent");
 const state_1 = require("./utils/state");
 const index_1 = require("./commands/usage/index");
 const dashboard_1 = require("./commands/dashboard");
+const swarm_1 = require("./commands/swarm");
+const swarm_dashboard_1 = require("./commands/swarm-dashboard");
+const swarm_setup_1 = require("./commands/swarm-setup");
 const chalk_1 = __importDefault(require("chalk"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -76,7 +79,7 @@ commander_1.program
     `  ${chalk_1.default.gray('$')} ${chalk_1.default.white('ekkos run -b')}                       ${chalk_1.default.gray('Launch with bypass permissions mode')}`,
     `  ${chalk_1.default.gray('$')} ${chalk_1.default.white('ekkos doctor --fix')}                 ${chalk_1.default.gray('Check and auto-fix system prerequisites')}`,
     `  ${chalk_1.default.gray('$')} ${chalk_1.default.white('ekkos usage daily')}                  ${chalk_1.default.gray("View today's token usage and costs")}`,
-    `  ${chalk_1.default.gray('$')} ${chalk_1.default.white('ekkos sessions')}                     ${chalk_1.default.gray('List active Claude Code sessions')}`,
+    `  ${chalk_1.default.gray('$')} ${chalk_1.default.white('ekkos swarm launch -t "build X"')}    ${chalk_1.default.gray('Launch parallel workers on a task')}`,
     '',
     chalk_1.default.gray('  Run ') + chalk_1.default.white('ekkos <command> --help') + chalk_1.default.gray(' for detailed options on any command.'),
     '',
@@ -154,7 +157,7 @@ commander_1.program
                 title: 'Running',
                 icon: '▸',
                 commands: [
-                    { name: 'run', desc: 'Start Claude Code with ekkOS memory', note: 'default' },
+                    { name: 'run', desc: 'Launch Claude Code with ekkOS memory + auto-continue', note: 'default' },
                     { name: 'test-claude', desc: 'Launch Claude with proxy only (no ccDNA/PTY) for debugging' },
                     { name: 'sessions', desc: 'List active Claude Code sessions' },
                 ],
@@ -177,6 +180,13 @@ commander_1.program
                     { name: 'agent', desc: 'Manage the remote terminal agent (start, stop, status, logs)' },
                 ],
             },
+            {
+                title: 'Swarm (Multi-Agent)',
+                icon: '▸',
+                commands: [
+                    { name: 'swarm', desc: 'Parallel workers, Q-learning routing, swarm dashboard' },
+                ],
+            },
         ];
         const padCmd = 18;
         let output = '';
@@ -229,7 +239,7 @@ commander_1.program
 // Run command - launches Claude with auto-continue wrapper
 commander_1.program
     .command('run')
-    .description('Start Claude Code with ekkOS memory (default command)')
+    .description('Launch Claude Code with auto-continue (auto /clear + /continue when context is high)')
     .option('-s, --session <name>', 'Session name to restore on clear')
     .option('-b, --bypass', 'Enable bypass permissions mode (dangerously skip all permission checks)')
     .option('-v, --verbose', 'Show debug output')
@@ -342,10 +352,10 @@ hooksCmd
 (0, index_1.registerUsageCommand)(commander_1.program);
 // Dashboard command - live TUI for monitoring session usage
 commander_1.program.addCommand(dashboard_1.dashboardCommand);
-// Sessions command - list active Claude Code sessions
+// Sessions command - list active Claude Code sessions (swarm support)
 commander_1.program
     .command('sessions')
-    .description('List active Claude Code sessions')
+    .description('List active Claude Code sessions (for swarm/multi-session support)')
     .option('-j, --json', 'Output machine-readable JSON')
     .action((options) => {
     const sessions = (0, state_1.getActiveSessions)();
@@ -470,6 +480,59 @@ agentCmd
     .action((options) => {
     (0, agent_1.agentHealth)({ json: options.json });
 });
+// Swarm command - manage Q-learning routing
+const swarmCmd = commander_1.program
+    .command('swarm')
+    .description('Manage Swarm Q-learning model routing');
+swarmCmd
+    .command('status')
+    .description('Show Q-table stats (states, visits, epsilon, top actions)')
+    .action(swarm_1.swarmStatus);
+swarmCmd
+    .command('reset')
+    .description('Clear Q-table from Redis (routing reverts to static rules)')
+    .action(swarm_1.swarmReset);
+swarmCmd
+    .command('export')
+    .description('Export Q-table to .swarm/q-learning-model.json')
+    .action(swarm_1.swarmExport);
+swarmCmd
+    .command('import')
+    .description('Import Q-table from .swarm/q-learning-model.json into Redis')
+    .action(swarm_1.swarmImport);
+swarmCmd
+    .command('launch')
+    .description('Launch parallel workers on a decomposed task (opens wizard if --task is omitted)')
+    .option('-w, --workers <count>', 'Number of parallel workers (2-8)', parseInt)
+    .option('-t, --task <task>', 'Task description to decompose and execute')
+    .option('--no-bypass', 'Disable bypass permissions mode')
+    .option('--no-decompose', 'Skip AI decomposition (send same task to all workers)')
+    .option('--no-queen', 'Skip launching the Python Queen coordinator')
+    .option('--queen-strategy <strategy>', 'Queen strategy (adaptive-default, hierarchical-cascade, mesh-consensus)')
+    .option('-v, --verbose', 'Show debug output')
+    .action((options) => {
+    // Auto-open wizard when --task is missing
+    if (!options.task) {
+        (0, swarm_setup_1.swarmSetup)();
+        return;
+    }
+    (0, swarm_1.swarmLaunch)({
+        workers: options.workers || 4,
+        task: options.task,
+        bypass: options.bypass !== false,
+        noDecompose: options.decompose === false,
+        noQueen: options.queen === false,
+        queenStrategy: options.queenStrategy,
+        verbose: options.verbose,
+    });
+});
+swarmCmd
+    .command('setup')
+    .description('Interactive TUI wizard for configuring and launching a swarm')
+    .action(() => {
+    (0, swarm_setup_1.swarmSetup)();
+});
+swarmCmd.addCommand(swarm_dashboard_1.swarmDashboardCommand);
 // Handle `-help` (single dash) — rewrite to `--help` for Commander compatibility
 const helpIdx = process.argv.indexOf('-help');
 if (helpIdx !== -1) {

package/dist/utils/session-binding.d.ts

@@ -1,5 +1,12 @@
+interface BindSessionPayload {
+    realSession: string;
+    projectPath: string;
+    pendingSession?: string;
+    sessionId?: string;
+}
 /**
  * Bind the real session name to the proxy
- * This replaces the '_pending' placeholder for this user, enabling proper eviction
+ * This replaces the pending placeholder for this user, enabling proper eviction.
  */
-export declare function bindSession(realSession: string, projectPath: string): Promise<boolean>;
+export declare function bindSession({ realSession, projectPath, pendingSession, sessionId, }: BindSessionPayload): Promise<boolean>;
+export {};

package/dist/utils/session-binding.js

@@ -3,42 +3,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bindSession = bindSession;
 const state_1 = require("./state");
 const MEMORY_API_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.dev';
+function extractUserIdFromToken(token) {
+    const normalized = token.trim();
+    if (!normalized)
+        return undefined;
+    if (normalized.startsWith('ekk_')) {
+        const parts = normalized.split('_');
+        if (parts.length >= 2 && parts[1]) {
+            return parts[1];
+        }
+    }
+    const colonParts = normalized.split(':');
+    if (colonParts.length >= 2 && colonParts[0]) {
+        return colonParts[0];
+    }
+    return undefined;
+}
 /**
  * Bind the real session name to the proxy
- * This replaces the '_pending' placeholder for this user, enabling proper eviction
+ * This replaces the pending placeholder for this user, enabling proper eviction.
  */
-async function bindSession(realSession, projectPath) {
+async function bindSession({ realSession, projectPath, pendingSession, sessionId, }) {
     try {
         // Get userId same way as run.ts
         const config = (0, state_1.getConfig)();
+        const authToken = (0, state_1.getAuthToken)();
         let userId = config?.userId;
         if (!userId || userId === 'anonymous') {
-            const token = (0, state_1.getAuthToken)();
-            if (token?.startsWith('ekk_')) {
-                const parts = token.split('_');
-                if (parts.length >= 2) {
-                    userId = parts[1];
-                }
+            if (authToken) {
+                userId = extractUserIdFromToken(authToken);
             }
         }
-        if (!userId || userId === 'anonymous')
+        if (!userId || userId === 'anonymous' || !authToken)
             return false;
+        const bindAuthToken = authToken.startsWith('ekk_')
+            ? authToken
+            : `${userId}:${authToken}`;
+        const body = {
+            userId,
+            realSession,
+            projectPath,
+        };
+        if (pendingSession) {
+            body.pendingSession = pendingSession;
+        }
+        if (sessionId) {
+            body.sessionId = sessionId;
+        }
         // Use global fetch (Node 18+)
         const response = await fetch(`${MEMORY_API_URL}/proxy/session/bind`, {
             method: 'POST',
             signal: AbortSignal.timeout(2500),
             headers: {
-                'Content-Type': 'application/json'
+                'Content-Type': 'application/json',
+                'x-ekkos-auth-token': bindAuthToken,
+                Authorization: `Bearer ${bindAuthToken}`,
             },
-            body: JSON.stringify({
-                userId,
-                realSession,
-                projectPath
-            })
+            body: JSON.stringify(body),
         });
         return response.ok;
     }
-    catch (err) {
+    catch {
         // Fail silently - don't crash CLI
         return false;
     }

package/dist/utils/state.d.ts

@@ -80,7 +80,7 @@ export declare function getMostRecentSession(): {
  */
 export declare function getActiveSessions(): ActiveSession[];
 /**
- * Register a new active session
+ * Register a new active session (for swarm tracking)
  */
 export declare function registerActiveSession(sessionId: string, sessionName: string, projectPath: string): ActiveSession;
 /**

package/dist/utils/state.js

@@ -244,7 +244,7 @@ function getMostRecentSession() {
     }
 }
 // ═══════════════════════════════════════════════════════════════════════════
-// MULTI-SESSION SUPPORT
+// MULTI-SESSION/SWARM SUPPORT
 // Track multiple concurrent Claude Code sessions without state collision
 // ═══════════════════════════════════════════════════════════════════════════
 /**
@@ -271,7 +271,7 @@ function getActiveSessions() {
     }
 }
 /**
- * Register a new active session
+ * Register a new active session (for swarm tracking)
  */
 function registerActiveSession(sessionId, sessionName, projectPath) {
     ensureEkkosDir();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekkos/cli",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {

package/templates/CLAUDE.md

@@ -364,20 +364,21 @@ Call `ekkOS_Directive` when user says:
 **EVERY response MUST end with this footer:**
 ```
 ---
-{IDE} ({Model}) · 🧠 **ekkOS_™** · {SessionName} · 📅 {Timestamp}
+{IDE} ({Model}) · 🧠 **ekkOS_™** · Turn {N} · {SessionName} · 📅 {Timestamp}
 ```
 
 **How to detect values:**
 - **IDE**: Claude Code, Cursor, Windsurf, etc. (from environment)
 - **Model**: Sonnet 4.5, Opus 4.5, etc. (from your model name)
+- **Turn Number**: From hook header (e.g., "Turn 47") - starts at 0 for each new session
 - **Session Name**: From hook header (e.g., "sol-gem-dig") - human-readable session identifier
-- **Timestamp**: From hook header (accurate local time in EST, include time)
+- **Timestamp**: From hook header (accurate local time in EST)
 
 **Examples:**
-- `Claude Code (Opus 4.6) · 🧠 **ekkOS_™** · cosmic-penguin-runs · 📅 2026-01-09 4:50 PM EST`
-- `Cursor (Claude Sonnet 4) · 🧠 **ekkOS_™** · bright-falcon-soars · 📅 2026-01-09 10:15 AM EST`
+- `Claude Code (Sonnet 4.5) · 🧠 **ekkOS_™** · Turn 12 · cosmic-penguin-runs · 📅 2026-01-09 4:50 PM EST`
+- `Cursor (Claude Sonnet 4) · 🧠 **ekkOS_™** · Turn 5 · bright-falcon-soars · 📅 2026-01-09 10:15 AM EST`
 
-**The hook header shows:** `🧠 ekkOS Memory | {SessionName} | {timestamp}`
+**The hook header shows:** `🧠 ekkOS Memory | Turn {N} | {Context%} | {SessionName} | {timestamp}`
 
 ---
 

package/templates/hooks/stop.ps1

@@ -12,6 +12,14 @@
 
 $ErrorActionPreference = "SilentlyContinue"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE DETECTION
+# ═══════════════════════════════════════════════════════════════════════════
+$ProxyMode = $false
+if ($env:ANTHROPIC_BASE_URL -and $env:ANTHROPIC_BASE_URL -like "*proxy.ekkos.dev*") {
+    $ProxyMode = $true
+}
+
 # ═══════════════════════════════════════════════════════════════════════════
 # CONFIG PATHS
 # ═══════════════════════════════════════════════════════════════════════════
@@ -87,6 +95,14 @@ function Convert-UuidToWords {
 # ═══════════════════════════════════════════════════════════════════════════
 $inputJson = [Console]::In.ReadToEnd()
 
+if ($ProxyMode) {
+    $projectState = Join-Path (Join-Path ((Get-Location).Path) ".claude\state") "hook-state.json"
+    $globalState = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
+    if (Test-Path $projectState) { Remove-Item $projectState -Force }
+    if (Test-Path $globalState) { Remove-Item $globalState -Force }
+    exit 0
+}
+
 # Get session ID from state
 $stateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
 $sessionFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
@@ -110,39 +126,37 @@ if ($rawSessionId -eq "unknown" -and (Test-Path $sessionFile)) {
 
 $sessionName = Convert-UuidToWords $rawSessionId
 
+function Get-PendingSessionFromProxyBaseUrl {
+    param([string]$baseUrl)
+    if (-not $baseUrl) { return $null }
+    try {
+        $uri = [System.Uri]$baseUrl
+        $segments = $uri.AbsolutePath.Trim('/') -split '/'
+        if (-not $segments -or $segments.Count -lt 3) { return $null }
+        $proxyIndex = [Array]::IndexOf($segments, 'proxy')
+        if ($proxyIndex -lt 0 -or $segments.Count -le ($proxyIndex + 2)) { return $null }
+        $candidate = [System.Uri]::UnescapeDataString($segments[$proxyIndex + 2])
+        if ($candidate -eq '_pending' -or $candidate -eq 'pending' -or $candidate.StartsWith('_pending-')) {
+            return $candidate
+        }
+    } catch {}
+    return $null
+}
+# Session binding removed — proxy now self-resolves _pending → word-based
+# names inline via uuidToSessionName(). No external bind call needed.
+
 # ═══════════════════════════════════════════════════════════════════════════
-# 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.
-# Mac does this in stop.sh (lines 171-179). Logic is identical.
+# AUTH LOADING (direct mode only)
 # ═══════════════════════════════════════════════════════════════════════════
+$authToken = $null
+$userId = $null
 $configFile = Join-Path $EkkosConfigDir "config.json"
-if ((Test-Path $configFile) -and $sessionName -ne "unknown-session") {
+if (Test-Path $configFile) {
     try {
-        $config = Get-Content $configFile -Raw | ConvertFrom-Json
-        $userId = $config.userId
-        $authToken = if ($config.hookApiKey) { $config.hookApiKey } else { $config.apiKey }
-
-        if ($userId -and $authToken) {
-            $projectPath = (Get-Location).Path
-            $pendingSession = if ($env:EKKOS_PENDING_SESSION) { $env:EKKOS_PENDING_SESSION } else { "_pending" }
-
-            $projectPath = $projectPath -replace '\\', '/'
-            $bindBody = @{
-                userId        = $userId
-                realSession   = $sessionName
-                projectPath   = $projectPath
-                pendingSession = $pendingSession
-            } | ConvertTo-Json -Depth 10
-
-            Start-Job -ScriptBlock {
-                param($body, $token)
-                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/proxy/session/bind" `
-                    -Method POST `
-                    -Headers @{ "Content-Type" = "application/json" } `
-                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue | Out-Null
-            } -ArgumentList $bindBody, $authToken | Out-Null
-        }
+        $cfg = Get-Content $configFile -Raw | ConvertFrom-Json
+        $authToken = $cfg.hookApiKey
+        if (-not $authToken) { $authToken = $cfg.apiKey }
+        $userId = $cfg.userId
     } catch {}
 }
 

package/templates/hooks/stop.sh

@@ -18,6 +18,14 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
 STATE_DIR="$PROJECT_ROOT/.claude/state"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE DETECTION
+# ═══════════════════════════════════════════════════════════════════════════
+PROXY_MODE=false
+if [[ "$ANTHROPIC_BASE_URL" == *"proxy.ekkos.dev"* ]]; then
+  PROXY_MODE=true
+fi
+
 mkdir -p "$STATE_DIR" 2>/dev/null
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -53,6 +61,14 @@ TRANSCRIPT_PATH=$(parse_json_value "$INPUT" '.transcript_path')
 MODEL_USED=$(parse_json_value "$INPUT" '.model')
 [ -z "$MODEL_USED" ] && MODEL_USED="claude-sonnet-4-5"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE: Slim hook path (local cleanup only)
+# ═══════════════════════════════════════════════════════════════════════════
+if [ "$PROXY_MODE" = "true" ]; then
+  rm -f "$STATE_DIR/hook-state.json" "$HOME/.claude/state/hook-state.json" 2>/dev/null || true
+  exit 0
+fi
+
 # ═══════════════════════════════════════════════════════════════════════════
 # Session ID
 # ═══════════════════════════════════════════════════════════════════════════
@@ -163,20 +179,8 @@ fi
 
 MEMORY_API_URL="https://mcp.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.
-# ═══════════════════════════════════════════════════════════════════════════
-if [ -n "$SESSION_NAME" ] && [ "$SESSION_NAME" != "unknown-session-starts" ] && [ -n "$USER_ID" ]; then
-    PROJECT_PATH_FOR_BIND=$(pwd)
-    PENDING_SESSION_FOR_BIND="${EKKOS_PENDING_SESSION:-_pending}"
-    curl -s -X POST "$MEMORY_API_URL/proxy/session/bind" \
-        -H "Content-Type: application/json" \
-        -d "{\"userId\":\"$USER_ID\",\"realSession\":\"$SESSION_NAME\",\"projectPath\":\"$PROJECT_PATH_FOR_BIND\",\"pendingSession\":\"$PENDING_SESSION_FOR_BIND\"}" \
-        --connect-timeout 1 \
-        --max-time 2 >/dev/null 2>&1 &
-fi
+# Session binding removed — proxy now self-resolves _pending → word-based
+# names inline via uuidToSessionName(). No external bind call needed.
 
 # ═══════════════════════════════════════════════════════════════════════════
 # EVICTION: Handled by IPC (In-Place Progressive Compression) in the proxy.

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

@@ -12,6 +12,14 @@
 
 $ErrorActionPreference = "SilentlyContinue"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE DETECTION
+# ═══════════════════════════════════════════════════════════════════════════
+$ProxyMode = $false
+if ($env:ANTHROPIC_BASE_URL -and $env:ANTHROPIC_BASE_URL -like "*proxy.ekkos.dev*") {
+    $ProxyMode = $true
+}
+
 # ═══════════════════════════════════════════════════════════════════════════
 # CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
 # ═══════════════════════════════════════════════════════════════════════════
@@ -77,6 +85,100 @@ if ($rawSessionId -eq "unknown") {
     }
 }
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE: Slim hook path (cosmetic output + local state only)
+# ═══════════════════════════════════════════════════════════════════════════
+if ($ProxyMode) {
+    function Get-ProxySessionName {
+        param([string]$sessionId)
+        if (-not $sessionId -or $sessionId -eq "unknown") { return "unknown-session" }
+        if ($sessionId -notmatch '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$') {
+            return $sessionId
+        }
+
+        if (-not $script:SessionWords) { Load-SessionWords }
+        if (-not $script:SessionWords) { return $sessionId }
+
+        $adjectives = $script:SessionWords.adjectives
+        $nouns = $script:SessionWords.nouns
+        $verbs = $script:SessionWords.verbs
+        if (-not $adjectives -or -not $nouns -or -not $verbs) { return $sessionId }
+
+        $clean = $sessionId -replace "-", ""
+        if ($clean.Length -lt 12) { return $sessionId }
+
+        try {
+            $adj = [Convert]::ToInt32($clean.Substring(0, 4), 16) % $adjectives.Length
+            $noun = [Convert]::ToInt32($clean.Substring(4, 4), 16) % $nouns.Length
+            $verb = [Convert]::ToInt32($clean.Substring(8, 4), 16) % $verbs.Length
+            return "$($adjectives[$adj])-$($nouns[$noun])-$($verbs[$verb])"
+        } catch {
+            return $sessionId
+        }
+    }
+
+    $sessionName = Get-ProxySessionName $rawSessionId
+    $timestampUtc = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    $displayTime = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt zzz")
+    $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
+
+    New-Item -ItemType Directory -Path $EkkosConfigDir -Force | Out-Null
+    New-Item -ItemType Directory -Path (Join-Path $env:USERPROFILE ".claude\state") -Force | Out-Null
+
+    $globalState = @{
+        session_id = $rawSessionId
+        session_name = $sessionName
+        project = $projectPath
+        timestamp = $timestampUtc
+    } | ConvertTo-Json -Depth 10 -Compress
+    Set-Content -Path (Join-Path $EkkosConfigDir "current-session.json") -Value $globalState -Force
+
+    $localState = @{
+        session_id = $rawSessionId
+        session_name = $sessionName
+        timestamp = $timestampUtc
+    } | ConvertTo-Json -Depth 10 -Compress
+    Set-Content -Path (Join-Path $env:USERPROFILE ".claude\state\current-session.json") -Value $localState -Force
+
+    $activeSessionsPath = Join-Path $EkkosConfigDir "active-sessions.json"
+    $sessions = @()
+    if (Test-Path $activeSessionsPath) {
+        try { $sessions = @(Get-Content $activeSessionsPath -Raw | ConvertFrom-Json) } catch { $sessions = @() }
+    }
+
+    $entry = @{
+        sessionId = $rawSessionId
+        sessionName = $sessionName
+        projectPath = $projectPath
+        startedAt = $timestampUtc
+        lastHeartbeat = $timestampUtc
+        pid = 0
+    }
+    $idx = -1
+    for ($i = 0; $i -lt $sessions.Count; $i++) {
+        if ($sessions[$i].sessionId -eq $rawSessionId) { $idx = $i; break }
+    }
+    if ($idx -ge 0) {
+        $entry.startedAt = if ($sessions[$idx].startedAt) { $sessions[$idx].startedAt } else { $timestampUtc }
+        $sessions[$idx] = $entry
+    } else {
+        $sessions += $entry
+    }
+    Set-Content -Path $activeSessionsPath -Value ($sessions | ConvertTo-Json -Depth 10) -Force
+
+    $hint = @{
+        sessionName = $sessionName
+        sessionId = $rawSessionId
+        projectPath = $projectPath
+        ts = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
+    } | ConvertTo-Json -Depth 10 -Compress
+    Set-Content -Path (Join-Path $EkkosConfigDir "hook-session-hint.json") -Value $hint -Force
+
+    $esc = [char]27
+    Write-Output "${esc}[0;36m${esc}[1m🧠 ekkOS Memory${esc}[0m ${esc}[2m| $sessionName | $displayTime${esc}[0m"
+    exit 0
+}
+
 # ═══════════════════════════════════════════════════════════════════════════
 # INTELLIGENT TOOL ROUTER: Multi-trigger skill detection
 # ═══════════════════════════════════════════════════════════════════════════
@@ -139,39 +241,24 @@ function Convert-UuidToWords {
 
 $sessionName = Convert-UuidToWords $rawSessionId
 
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY SESSION BIND: _pending → real session name (fires every turn)
-# Mirrors bash user-prompt-submit.sh lines 319-338.
-# No PTY on Windows so run.ts can't detect session name — hook must bind it.
-# ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session" -and $rawSessionId -ne "unknown") {
-    $configFile = Join-Path $EkkosConfigDir "config.json"
-    if (Test-Path $configFile) {
-        try {
-            $config = Get-Content $configFile -Raw | ConvertFrom-Json
-            $userId = $config.userId
-            if ($userId) {
-                $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
-                $pendingSession = if ($env:EKKOS_PENDING_SESSION) { $env:EKKOS_PENDING_SESSION } else { "_pending" }
-                $projectPath = $projectPath -replace '\\', '/'
-                $bindBody = @{
-                    userId         = $userId
-                    realSession    = $sessionName
-                    projectPath    = $projectPath
-                    pendingSession = $pendingSession
-                } | ConvertTo-Json -Depth 10 -Compress
-
-                Start-Job -ScriptBlock {
-                    param($body)
-                    Invoke-RestMethod -Uri "https://mcp.ekkos.dev/proxy/session/bind" `
-                        -Method POST `
-                        -Headers @{ "Content-Type" = "application/json" } `
-                        -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue | Out-Null
-                } -ArgumentList $bindBody | Out-Null
-            }
-        } catch {}
-    }
+function Get-PendingSessionFromProxyBaseUrl {
+    param([string]$baseUrl)
+    if (-not $baseUrl) { return $null }
+    try {
+        $uri = [System.Uri]$baseUrl
+        $segments = $uri.AbsolutePath.Trim('/') -split '/'
+        if (-not $segments -or $segments.Count -lt 3) { return $null }
+        $proxyIndex = [Array]::IndexOf($segments, 'proxy')
+        if ($proxyIndex -lt 0 -or $segments.Count -le ($proxyIndex + 2)) { return $null }
+        $candidate = [System.Uri]::UnescapeDataString($segments[$proxyIndex + 2])
+        if ($candidate -eq '_pending' -or $candidate -eq 'pending' -or $candidate.StartsWith('_pending-')) {
+            return $candidate
+        }
+    } catch {}
+    return $null
 }
+# Session binding removed — proxy now self-resolves _pending → word-based
+# names inline via uuidToSessionName(). No external bind call needed.
 
 # ═══════════════════════════════════════════════════════════════════════════
 # SESSION CURRENT: Update Redis with current session name
@@ -325,7 +412,8 @@ if ($skillReminders.Count -gt 0) {
 
 $output += @"
 
-<footer-format>End responses with: Claude Code ({Model}) · 🧠 ekkOS_™ · $sessionName · 📅 $timestamp</footer-format>
+<footer-format>End responses with: Claude Code ({Model}) · 🧠 ekkOS_™ · $sessionName · $timestamp</footer-format>
+<footer-note>Do not include a turn counter in the footer.</footer-note>
 "@
 
 Write-Output $output

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

@@ -13,6 +13,14 @@ set +e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE DETECTION
+# ═══════════════════════════════════════════════════════════════════════════
+PROXY_MODE=false
+if [[ "$ANTHROPIC_BASE_URL" == *"proxy.ekkos.dev"* ]]; then
+  PROXY_MODE=true
+fi
+
 # ═══════════════════════════════════════════════════════════════════════════
 # CONFIG PATHS - No jq dependency (v1.2 spec)
 # Session words live in ~/.ekkos/ so they work in ANY project
@@ -64,6 +72,92 @@ if [ "$RAW_SESSION_ID" = "unknown" ] || [ "$RAW_SESSION_ID" = "null" ] || [ -z "
   fi
 fi
 
+# ═══════════════════════════════════════════════════════════════════════════
+# PROXY MODE: Slim hook path (cosmetic output + local state only)
+# ═══════════════════════════════════════════════════════════════════════════
+if [ "$PROXY_MODE" = "true" ]; then
+  SESSION_ID="$RAW_SESSION_ID"
+  UUID_REGEX='^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+  SESSION_NAME="$SESSION_ID"
+
+  if [[ "$SESSION_ID" =~ $UUID_REGEX ]] && [ -f "$JSON_PARSE_HELPER" ]; then
+    SESSION_NAME=$(node -e "
+const fs = require('fs');
+const sid = process.argv[1] || '';
+const wordsFile = process.argv[2];
+const fallbackFile = process.argv[3];
+const helper = process.argv[4];
+let wordsPath = wordsFile;
+if (!fs.existsSync(wordsPath)) wordsPath = fallbackFile;
+if (!fs.existsSync(wordsPath) || !fs.existsSync(helper)) {
+  console.log(sid || 'unknown-session');
+  process.exit(0);
+}
+const cp = require('child_process');
+function readList(path) {
+  const out = cp.spawnSync('node', [helper, wordsPath, path], { encoding: 'utf8' });
+  if (out.status !== 0) return [];
+  return (out.stdout || '').split('\\n').map(s => s.trim()).filter(Boolean);
+}
+const adjectives = readList('.adjectives');
+const nouns = readList('.nouns');
+const verbs = readList('.verbs');
+if (!adjectives.length || !nouns.length || !verbs.length) {
+  console.log(sid);
+  process.exit(0);
+}
+const hex = sid.replace(/-/g, '').slice(0, 12);
+if (!/^[0-9a-fA-F]{12}$/.test(hex)) {
+  console.log(sid);
+  process.exit(0);
+}
+const adj = parseInt(hex.slice(0, 4), 16) % adjectives.length;
+const noun = parseInt(hex.slice(4, 8), 16) % nouns.length;
+const verb = parseInt(hex.slice(8, 12), 16) % verbs.length;
+console.log(adjectives[adj] + '-' + nouns[noun] + '-' + verbs[verb]);
+" "$SESSION_ID" "$SESSION_WORDS_JSON" "$SESSION_WORDS_DEFAULT" "$JSON_PARSE_HELPER" 2>/dev/null || echo "$SESSION_ID")
+  fi
+
+  TIMESTAMP_UTC=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  DISPLAY_TIME=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
+  mkdir -p "$HOME/.ekkos" "$HOME/.claude/state" 2>/dev/null || true
+  echo "{\"session_id\":\"$SESSION_ID\",\"session_name\":\"$SESSION_NAME\",\"project\":\"$PROJECT_ROOT\",\"timestamp\":\"$TIMESTAMP_UTC\"}" > "$HOME/.ekkos/current-session.json" 2>/dev/null || true
+  echo "{\"session_id\":\"$SESSION_ID\",\"session_name\":\"$SESSION_NAME\",\"timestamp\":\"$TIMESTAMP_UTC\"}" > "$HOME/.claude/state/current-session.json" 2>/dev/null || true
+
+  ACTIVE_SESSIONS_FILE="$HOME/.ekkos/active-sessions.json"
+  node -e "
+const fs = require('fs');
+const file = process.argv[1];
+const sid = process.argv[2];
+const sname = process.argv[3];
+const ts = process.argv[4];
+const project = process.argv[5];
+let sessions = [];
+try {
+  if (fs.existsSync(file)) {
+    sessions = JSON.parse(fs.readFileSync(file, 'utf8') || '[]');
+  }
+} catch {}
+const index = sessions.findIndex(s => s.sessionId === sid);
+if (index >= 0) {
+  sessions[index] = { ...sessions[index], sessionName: sname, projectPath: project, lastHeartbeat: ts };
+} else {
+  sessions.push({ sessionId: sid, sessionName: sname, projectPath: project, startedAt: ts, lastHeartbeat: ts, pid: 0 });
+}
+fs.writeFileSync(file, JSON.stringify(sessions, null, 2));
+" "$ACTIVE_SESSIONS_FILE" "$SESSION_ID" "$SESSION_NAME" "$TIMESTAMP_UTC" "$PROJECT_ROOT" 2>/dev/null || true
+
+  # Dashboard/local tooling hint file
+  echo "{\"sessionName\":\"$SESSION_NAME\",\"sessionId\":\"$SESSION_ID\",\"projectPath\":\"$PROJECT_ROOT\",\"ts\":$(date +%s)000}" > "$HOME/.ekkos/hook-session-hint.json" 2>/dev/null || true
+
+  CYAN='\033[0;36m'
+  DIM='\033[2m'
+  BOLD='\033[1m'
+  RESET='\033[0m'
+  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${DISPLAY_TIME}${RESET}"
+  exit 0
+fi
+
 # ═══════════════════════════════════════════════════════════════════════════
 # SKILL AUTO-FIRE: Detect keywords and inject skill reminders
 # ═══════════════════════════════════════════════════════════════════════════
@@ -138,7 +232,6 @@ echo "{\"session_id\": \"$SESSION_ID\", \"timestamp\": \"$(date -u +%Y-%m-%dT%H:
 PROJECT_SESSION_DIR="$STATE_DIR/sessions"
 mkdir -p "$PROJECT_SESSION_DIR" 2>/dev/null || true
 TURN_COUNTER_FILE="$PROJECT_SESSION_DIR/${SESSION_ID}.turn"
-CONTEXT_SIZE_FILE="$PROJECT_SESSION_DIR/${SESSION_ID}.context"
 
 # Count API round-trips from transcript to match TUI turn counter
 TURN_NUMBER=1
@@ -159,28 +252,7 @@ fi
 
 echo "$TURN_NUMBER" > "$TURN_COUNTER_FILE"
 
-# ═══════════════════════════════════════════════════════════════════════════
-# Context size tracking - Uses tokenizer script (single source)
-# ═══════════════════════════════════════════════════════════════════════════
-PREV_CONTEXT_PERCENT=0
-[ -f "$CONTEXT_SIZE_FILE" ] && PREV_CONTEXT_PERCENT=$(cat "$CONTEXT_SIZE_FILE" 2>/dev/null || echo "0")
-
-TOKEN_PERCENT=0
-MAX_TOKENS=200000
-TOKENIZER_SCRIPT="$SCRIPT_DIR/lib/count-tokens.cjs"
-
-if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ] && [ -f "$TOKENIZER_SCRIPT" ]; then
-  TOKEN_COUNT=$(node "$TOKENIZER_SCRIPT" "$TRANSCRIPT_PATH" 2>/dev/null || echo "0")
-  if [[ "$TOKEN_COUNT" =~ ^[0-9]+$ ]] && [ "$TOKEN_COUNT" -gt 0 ]; then
-    TOKEN_PERCENT=$((TOKEN_COUNT * 100 / MAX_TOKENS))
-    [ "$TOKEN_PERCENT" -gt 100 ] && TOKEN_PERCENT=100
-    # In proxy mode, IPC compresses ~65-70% — show estimated post-compression %
-    IPC_PERCENT=$((TOKEN_PERCENT * 30 / 100))
-    [ "$IPC_PERCENT" -lt 1 ] && IPC_PERCENT=1
-  fi
-fi
 
-echo "$TOKEN_PERCENT" > "$CONTEXT_SIZE_FILE"
 
 # ═══════════════════════════════════════════════════════════════════════════
 # COLORS
@@ -311,32 +383,8 @@ try {
             --max-time 3 >/dev/null 2>&1 &
     fi
 
-    # 6. CRITICAL: Bind session name to proxy for R2 eviction paths - No jq
-    EKKOS_USER_ID=""
-    if [ -f "$HOME/.ekkos/config.json" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-        EKKOS_USER_ID=$(node "$JSON_PARSE_HELPER" "$HOME/.ekkos/config.json" '.userId' 2>/dev/null || echo "")
-    fi
-    if [ -n "$EKKOS_USER_ID" ] && [ -n "$SESSION_NAME" ]; then
-        PENDING_SESSION="${EKKOS_PENDING_SESSION:-_pending}"
-        node -e "
-const https = require('https');
-const body = JSON.stringify({
-    userId: process.argv[1],
-    realSession: process.argv[2],
-    projectPath: process.argv[3],
-    pendingSession: process.argv[4]
-});
-const req = https.request({
-    hostname: 'mcp.ekkos.dev',
-    path: '/proxy/session/bind',
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body)}
-}, () => {});
-req.on('error', () => {});
-req.write(body);
-req.end();
-" "$EKKOS_USER_ID" "$SESSION_NAME" "$PROJECT_ROOT" "$PENDING_SESSION" 2>/dev/null &
-    fi
+    # Session binding removed — proxy now self-resolves _pending → word-based
+    # names inline via uuidToSessionName(). No external bind call needed.
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -410,49 +458,7 @@ turns.slice(0, -1).forEach(t => {
   fi
 fi
 
-# ═══════════════════════════════════════════════════════════════════════════
-# COMPACTION DETECTION: If context dropped dramatically, auto-restore
-# Was >50% last turn, now <15% = compaction happened
-# ═══════════════════════════════════════════════════════════════════════════
-if [ "$PREV_CONTEXT_PERCENT" -gt 50 ] && [ "$TOKEN_PERCENT" -lt 15 ] && [ -n "$AUTH_TOKEN" ]; then
-  echo ""
-  echo -e "${GREEN}${BOLD}🔄 CONTEXT RESTORED${RESET} ${DIM}| Compaction detected | Auto-loading recent turns...${RESET}"
-
-  RESTORE_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/turns/recall" \
-    -H "Authorization: Bearer $AUTH_TOKEN" \
-    -H "Content-Type: application/json" \
-    -d "{\"session_id\": \"${SESSION_ID}\", \"last_n\": 10, \"format\": \"summary\"}" \
-    --connect-timeout 3 \
-    --max-time 5 2>/dev/null || echo '{"turns":[]}')
-
-  RESTORED_COUNT=$(echo "$RESTORE_RESPONSE" | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-console.log((d.turns || []).length);
-" 2>/dev/null || echo "0")
-
-  if [ "$RESTORED_COUNT" -gt 0 ]; then
-    echo -e "${GREEN}   ✓${RESET} Restored ${RESTORED_COUNT} turns from Layer 2"
-    echo ""
-    echo -e "${MAGENTA}${BOLD}## Recent Context (auto-restored)${RESET}"
-    echo ""
-
-    echo "$RESTORE_RESPONSE" | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-(d.turns || []).forEach(t => {
-    const q = (t.user_query || '...').substring(0, 120);
-    const a = (t.assistant_response || '...').substring(0, 250);
-    console.log('**Turn ' + (t.turn_number || '?') + '**: ' + q + '...\n> ' + a + '...\n');
-});
-" 2>/dev/null || true
-
-    echo ""
-    echo -e "${DIM}Full history: \"turns 1-${TURN_NUMBER}\" or \"recall yesterday\"${RESET}"
-  fi
-
-  echo ""
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
-
-elif [ "$POST_CLEAR_DETECTED" = true ] && [ -n "$AUTH_TOKEN" ]; then
+if [ "$POST_CLEAR_DETECTED" = true ] && [ -n "$AUTH_TOKEN" ]; then
   # /clear detected - show visible restoration banner
   echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}" >&2
   echo -e "${GREEN}${BOLD}🔄 SESSION CONTINUED${RESET} ${DIM}| ${TURN_NUMBER} turns preserved | Context restored${RESET}" >&2
@@ -497,9 +503,6 @@ const d = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
   echo ""
   echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
 
-elif [ "$TOKEN_PERCENT" -ge 50 ]; then
-  echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ~${IPC_PERCENT:-0}% IPC | ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
-
 else
   echo -e "${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| ${SESSION_NAME} | ${CURRENT_TIME}${RESET}"
 fi