@ekkos/cli 0.2.16 → 0.2.18

package/dist/agent/daemon.d.ts

@@ -21,6 +21,11 @@ export declare class AgentDaemon {
     private ptyRunner;
     private currentSessionId;
     private running;
+    private outputBuffer;
+    private currentSessionName;
+    private isAutoClearInProgress;
+    private lastContextWallTime;
+    private readonly CONTEXT_WALL_COOLDOWN;
     constructor(config: DaemonConfig);
     /**
      * Start the daemon
@@ -63,9 +68,21 @@ export declare class AgentDaemon {
      */
     private handlePTYExit;
     /**
-     * Send PTY output to server
+     * Send PTY output to server (with auto-continue detection)
      */
     private sendOutput;
+    /**
+     * Trigger auto /clear + /continue when context wall is hit
+     */
+    private triggerAutoContinue;
+    /**
+     * Wait for Claude's idle prompt ("> ")
+     */
+    private waitForIdlePrompt;
+    /**
+     * Sleep helper
+     */
+    private sleep;
     /**
      * Handle WebSocket close
      */

package/dist/agent/daemon.js

@@ -51,9 +51,15 @@ const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const pty_runner_1 = require("./pty-runner");
-const RELAY_URL = process.env.RELAY_WS_URL || 'wss://mcp.ekkos.dev';
+const RELAY_URL = process.env.RELAY_WS_URL || 'wss://ekkos-relay-production.up.railway.app';
 const HEARTBEAT_INTERVAL = 30000; // 30 seconds
 const RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 16000, 32000, 60000]; // Exponential backoff
+// Auto-continue: Context wall detection pattern
+const CONTEXT_WALL_REGEX = /context limit reached.*\/(compact|clear)\b.*to continue/i;
+// Session name detection pattern (3-word slug: word-word-word)
+const SESSION_NAME_REGEX = /\b([a-z]+-[a-z]+-[a-z]+)\b/i;
+// Idle prompt detection - Claude shows "> " when ready for input
+const IDLE_PROMPT_REGEX = />\s*$/;
 class AgentDaemon {
     constructor(config) {
         this.ws = null;
@@ -62,6 +68,12 @@ class AgentDaemon {
         this.ptyRunner = null;
         this.currentSessionId = null;
         this.running = false;
+        // Auto-continue state
+        this.outputBuffer = '';
+        this.currentSessionName = null;
+        this.isAutoClearInProgress = false;
+        this.lastContextWallTime = 0;
+        this.CONTEXT_WALL_COOLDOWN = 30000; // 30 seconds between auto-clears
         this.config = config;
     }
     /**
@@ -140,7 +152,7 @@ class AgentDaemon {
                 this.log('Registered with relay');
                 break;
             case 'session_start':
-                this.handleSessionStart(message.sessionId);
+                this.handleSessionStart(message.sessionId, message.cwd);
                 break;
             case 'session_end':
                 this.handleSessionEnd(message.sessionId);
@@ -159,20 +171,26 @@ class AgentDaemon {
     /**
      * Handle session start request
      */
-    handleSessionStart(sessionId) {
-        this.log(`Session start request: ${sessionId}`);
+    handleSessionStart(sessionId, cwd) {
+        this.log(`Session start request: ${sessionId}${cwd ? ` (cwd: ${cwd})` : ''}`);
         // Kill existing session if any
         if (this.ptyRunner) {
             this.ptyRunner.kill();
             this.ptyRunner = null;
         }
         this.currentSessionId = sessionId;
-        // Start PTY with ekkos run -d
+        // Reset auto-continue state
+        this.outputBuffer = '';
+        this.currentSessionName = null;
+        this.isAutoClearInProgress = false;
+        this.lastContextWallTime = 0;
+        // Start PTY with ekkos run (skip -d flag to avoid double init)
         this.ptyRunner = new pty_runner_1.PTYRunner({
             command: 'ekkos',
-            args: ['run', '-d', '-b'], // -d for doctor check, -b for bypass permissions
+            args: ['run', '-b'], // -b for bypass permissions (skip -d to avoid double spawn)
             onData: (data) => this.sendOutput(data),
             onExit: (code) => this.handlePTYExit(code),
+            cwd: cwd || process.env.HOME, // Use specified cwd or fall back to home
             verbose: this.config.verbose,
         });
         this.ptyRunner.start();
@@ -225,14 +243,80 @@ class AgentDaemon {
         this.currentSessionId = null;
     }
     /**
-     * Send PTY output to server
+     * Send PTY output to server (with auto-continue detection)
      */
     sendOutput(data) {
+        // Always forward output to server
         this.sendMessage({
             type: 'output',
             sessionId: this.currentSessionId || undefined,
             data,
         });
+        // Auto-continue: Buffer output and detect context wall
+        this.outputBuffer += data;
+        // Keep buffer manageable (last 2KB)
+        if (this.outputBuffer.length > 2048) {
+            this.outputBuffer = this.outputBuffer.slice(-2048);
+        }
+        // Extract session name from output (e.g., "qix-fox-use" in hook output)
+        const sessionMatch = this.outputBuffer.match(SESSION_NAME_REGEX);
+        if (sessionMatch) {
+            this.currentSessionName = sessionMatch[1];
+        }
+        // Detect context wall
+        if (CONTEXT_WALL_REGEX.test(this.outputBuffer) && !this.isAutoClearInProgress) {
+            const now = Date.now();
+            if (now - this.lastContextWallTime > this.CONTEXT_WALL_COOLDOWN) {
+                this.lastContextWallTime = now;
+                this.triggerAutoContinue();
+            }
+        }
+    }
+    /**
+     * Trigger auto /clear + /continue when context wall is hit
+     */
+    async triggerAutoContinue() {
+        if (this.isAutoClearInProgress || !this.ptyRunner)
+            return;
+        this.isAutoClearInProgress = true;
+        this.log('Auto-continue: Context wall detected, initiating /clear + /continue');
+        // Wait for idle prompt
+        await this.waitForIdlePrompt();
+        // Type /clear
+        this.log('Auto-continue: Sending /clear');
+        this.ptyRunner.write('/clear\n');
+        // Wait for clear to complete
+        await this.sleep(2000);
+        await this.waitForIdlePrompt();
+        // Type /continue with session name
+        const continueCmd = this.currentSessionName
+            ? `/continue ${this.currentSessionName}\n`
+            : '/continue\n';
+        this.log(`Auto-continue: Sending ${continueCmd.trim()}`);
+        this.ptyRunner.write(continueCmd);
+        // Reset state
+        this.outputBuffer = '';
+        this.isAutoClearInProgress = false;
+        this.log('Auto-continue: Complete');
+    }
+    /**
+     * Wait for Claude's idle prompt ("> ")
+     */
+    async waitForIdlePrompt(timeout = 10000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            if (IDLE_PROMPT_REGEX.test(this.outputBuffer)) {
+                return;
+            }
+            await this.sleep(100);
+        }
+        this.log('Auto-continue: Timeout waiting for idle prompt');
+    }
+    /**
+     * Sleep helper
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
     }
     /**
      * Handle WebSocket close

package/dist/agent/pty-runner.d.ts

@@ -11,6 +11,7 @@ interface PTYRunnerConfig {
     onExit: (code: number) => void;
     cols?: number;
     rows?: number;
+    cwd?: string;
     verbose?: boolean;
 }
 export declare class PTYRunner {

package/dist/agent/pty-runner.js

@@ -82,7 +82,7 @@ class PTYRunner {
             name: 'xterm-256color',
             cols: this.config.cols || 80,
             rows: this.config.rows || 24,
-            cwd: process.cwd(),
+            cwd: this.config.cwd || process.cwd(),
             env: {
                 ...process.env,
                 TERM: 'xterm-256color',
@@ -101,11 +101,12 @@ class PTYRunner {
      */
     startWithSpawn() {
         const isWindows = os.platform() === 'win32';
+        const cwd = this.config.cwd || process.cwd();
         if (isWindows) {
             // Windows: Use cmd.exe
             this.spawnProcess = (0, child_process_1.spawn)('cmd.exe', ['/c', this.config.command, ...this.config.args], {
                 stdio: ['pipe', 'pipe', 'pipe'],
-                cwd: process.cwd(),
+                cwd,
                 env: process.env,
             });
         }
@@ -116,7 +117,7 @@ class PTYRunner {
                 : ['-q', '-c', `${this.config.command} ${this.config.args.join(' ')}`, '/dev/null'];
             this.spawnProcess = (0, child_process_1.spawn)('script', scriptArgs, {
                 stdio: ['pipe', 'pipe', 'pipe'],
-                cwd: process.cwd(),
+                cwd,
                 env: {
                     ...process.env,
                     TERM: 'xterm-256color',

package/dist/commands/run.js

@@ -256,15 +256,105 @@ const MEMORY_API_URL = 'https://mcp.ekkos.dev';
 const isWindows = os.platform() === 'win32';
 // Pinned Claude Code version for ekkos run
 // 2.1.6 has the old context calculation (95% of full 200K, not effective window)
+// NOTE: Homebrew global installs may be broken, but npm installs work fine
 const PINNED_CLAUDE_VERSION = '2.1.6';
+// ekkOS-managed Claude installation path
+const EKKOS_CLAUDE_DIR = path.join(os.homedir(), '.ekkos', 'claude-code');
+const EKKOS_CLAUDE_BIN = path.join(EKKOS_CLAUDE_DIR, 'node_modules', '.bin', 'claude');
+/**
+ * Check if a Claude installation matches our required version
+ */
+function checkClaudeVersion(claudePath) {
+    try {
+        const version = (0, child_process_1.execSync)(`"${claudePath}" --version 2>/dev/null`, { encoding: 'utf-8' }).trim();
+        // Version output is like "2.1.6 (Claude Code)" - extract the version number
+        const match = version.match(/^(\d+\.\d+\.\d+)/);
+        if (match) {
+            return match[1] === PINNED_CLAUDE_VERSION;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install Claude Code to ekkOS-managed directory
+ * This gives us full control over the version without npx auto-update messages
+ */
+function installEkkosClaudeVersion() {
+    console.log(chalk_1.default.cyan(`\n📦 Installing Claude Code v${PINNED_CLAUDE_VERSION} to ~/.ekkos/claude-code...`));
+    console.log(chalk_1.default.gray('   (This is a one-time setup for optimal context window behavior)\n'));
+    try {
+        // Create directory if needed
+        if (!fs.existsSync(EKKOS_CLAUDE_DIR)) {
+            fs.mkdirSync(EKKOS_CLAUDE_DIR, { recursive: true });
+        }
+        // Initialize package.json if needed
+        const packageJsonPath = path.join(EKKOS_CLAUDE_DIR, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            fs.writeFileSync(packageJsonPath, JSON.stringify({
+                name: 'ekkos-claude-code',
+                version: '1.0.0',
+                private: true,
+                description: 'ekkOS-managed Claude Code installation'
+            }, null, 2));
+        }
+        // Install specific version
+        (0, child_process_1.execSync)(`npm install @anthropic-ai/claude-code@${PINNED_CLAUDE_VERSION}`, {
+            cwd: EKKOS_CLAUDE_DIR,
+            stdio: 'inherit'
+        });
+        console.log(chalk_1.default.green(`\n✓ Claude Code v${PINNED_CLAUDE_VERSION} installed successfully!`));
+        return true;
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\n✗ Failed to install Claude Code: ${err.message}`));
+        console.log(chalk_1.default.yellow('   Falling back to npx (will show update message)\n'));
+        return false;
+    }
+}
 /**
  * Resolve full path to claude executable
- * Returns 'npx:VERSION' to signal we should use npx with pinned version
+ * Returns direct path if found with correct version, otherwise 'npx:VERSION'
+ *
+ * IMPORTANT: We MUST use version 2.1.6 specifically because Anthropic changed
+ * context window calculation after this version. 2.1.6 uses 95% of full 200K,
+ * newer versions use a different (more restrictive) effective window.
+ *
+ * Priority:
+ * 1. ekkOS-managed installation (~/.ekkos/claude-code) - CLEANEST, auto-installed
+ * 2. Homebrew/global install IF version matches 2.1.6
+ * 3. npx with pinned version (fallback, shows update message)
  */
 function resolveClaudePath() {
-    // PRIORITY 1: Use pinned version via npx
-    // This ensures ekkos run always uses the version with better context behavior
-    // Return special marker that spawn logic will handle
+    // PRIORITY 1: ekkOS-managed installation (cleanest - no update messages)
+    if (fs.existsSync(EKKOS_CLAUDE_BIN) && checkClaudeVersion(EKKOS_CLAUDE_BIN)) {
+        return EKKOS_CLAUDE_BIN;
+    }
+    // PRIORITY 2: Check Homebrew and global installations - only use if version matches
+    const candidatePaths = [
+        // Homebrew
+        '/opt/homebrew/bin/claude', // macOS Apple Silicon
+        '/usr/local/bin/claude', // macOS Intel
+        '/home/linuxbrew/.linuxbrew/bin/claude', // Linux (system)
+        path.join(os.homedir(), '.linuxbrew/bin/claude'), // Linux (user)
+        // Global npm install
+        path.join(os.homedir(), '.npm-global/bin/claude'),
+        path.join(os.homedir(), '.local/bin/claude'),
+    ];
+    for (const p of candidatePaths) {
+        if (fs.existsSync(p) && checkClaudeVersion(p)) {
+            return p; // Direct path with correct version
+        }
+    }
+    // PRIORITY 3: Auto-install to ekkOS-managed directory
+    if (installEkkosClaudeVersion()) {
+        if (fs.existsSync(EKKOS_CLAUDE_BIN)) {
+            return EKKOS_CLAUDE_BIN;
+        }
+    }
+    // PRIORITY 4: Fall back to npx with pinned version (shows update message)
     return `npx:${PINNED_CLAUDE_VERSION}`;
 }
 /**

package/dist/commands/setup-remote.js

@@ -61,7 +61,7 @@ const init_1 = require("./init");
 const pkgPath = path.resolve(__dirname, '../../package.json');
 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 const PLATFORM_URL = process.env.PLATFORM_URL || 'https://platform.ekkos.dev';
-const MEMORY_API_URL = process.env.MEMORY_API_URL || 'https://mcp.ekkos.dev';
+const RELAY_API_URL = process.env.RELAY_URL || 'https://ekkos-relay-production.up.railway.app';
 const POLLING_INTERVAL = 2000; // 2 seconds
 const POLLING_TIMEOUT = 600000; // 10 minutes
 /**
@@ -110,7 +110,7 @@ function getOrCreateDeviceInfo() {
  * Request device pairing code from server
  */
 async function requestPairingCode(deviceInfo, authToken) {
-    const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/pair`, {
+    const response = await fetch(`${RELAY_API_URL}/api/v1/relay/pair`, {
         method: 'POST',
         headers: {
             'Authorization': `Bearer ${authToken}`,
@@ -140,7 +140,7 @@ async function requestPairingCode(deviceInfo, authToken) {
 async function pollForApproval(deviceCode, authToken) {
     const startTime = Date.now();
     while (Date.now() - startTime < POLLING_TIMEOUT) {
-        const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/pair/${deviceCode}`, {
+        const response = await fetch(`${RELAY_API_URL}/api/v1/relay/pair/${deviceCode}`, {
             headers: {
                 'Authorization': `Bearer ${authToken}`,
             },
@@ -338,7 +338,7 @@ async function verifyConnection(deviceInfo, authToken) {
     // Wait a bit for agent to start
     await new Promise(resolve => setTimeout(resolve, 3000));
     // Check device status
-    const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/devices/${(await (0, state_1.getState)())?.userId}`, {
+    const response = await fetch(`${RELAY_API_URL}/api/v1/relay/devices/${(await (0, state_1.getState)())?.userId}`, {
         headers: {
             'Authorization': `Bearer ${authToken}`,
         },

package/dist/commands/setup.js

@@ -10,6 +10,7 @@ const fs_1 = require("fs");
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const ora_1 = __importDefault(require("ora"));
+const hooks_js_1 = require("./hooks.js");
 const EKKOS_API_URL = 'https://mcp.ekkos.dev';
 const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.ekkos');
 const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, 'config.json');
@@ -137,6 +138,7 @@ async function setup(options) {
                 message: 'Which IDE are you setting up?',
                 choices: [
                     { name: 'Claude Code (CLI)', value: 'claude-code' },
+                    { name: 'Claude Desktop (MCP)', value: 'claude-desktop' },
                     { name: 'Cursor', value: 'cursor' },
                     { name: 'Windsurf (Cascade)', value: 'windsurf' },
                     { name: 'VSCode (Copilot)', value: 'vscode' }
@@ -180,6 +182,9 @@ async function setupIDE(ide, apiKey, config) {
             case 'claude-code':
                 await setupClaudeCode(apiKey);
                 break;
+            case 'claude-desktop':
+                await setupClaudeDesktop(apiKey);
+                break;
             case 'cursor':
                 await setupCursor(apiKey);
                 break;
@@ -203,24 +208,74 @@ async function setupIDE(ide, apiKey, config) {
 async function setupClaudeCode(apiKey) {
     const claudeDir = (0, path_1.join)((0, os_1.homedir)(), '.claude');
     const hooksDir = (0, path_1.join)(claudeDir, 'hooks');
-    if (!(0, fs_1.existsSync)(hooksDir)) {
-        (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    const stateDir = (0, path_1.join)(claudeDir, 'state');
+    // Create directories
+    (0, fs_1.mkdirSync)(claudeDir, { recursive: true });
+    (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    (0, fs_1.mkdirSync)(stateDir, { recursive: true });
+    // Check for existing custom hooks (don't have EKKOS_MANAGED=1 marker)
+    const isWindows = (0, os_1.platform)() === 'win32';
+    const hookExt = isWindows ? '.ps1' : '.sh';
+    const hookFiles = ['user-prompt-submit', 'stop', 'session-start', 'assistant-response'];
+    let hasCustomHooks = false;
+    for (const hookName of hookFiles) {
+        const hookPath = (0, path_1.join)(hooksDir, `${hookName}${hookExt}`);
+        if ((0, fs_1.existsSync)(hookPath)) {
+            const content = (0, fs_1.readFileSync)(hookPath, 'utf-8');
+            if (!content.includes('EKKOS_MANAGED=1')) {
+                hasCustomHooks = true;
+                break;
+            }
+        }
+    }
+    if (hasCustomHooks) {
+        // User has custom hooks - don't overwrite, use minimal approach
+        console.log(chalk_1.default.yellow('  Detected custom hooks - preserving your hooks'));
+        console.log(chalk_1.default.gray('  Run `ekkos hooks install --global` to upgrade to managed hooks'));
+        console.log(chalk_1.default.gray('  (This will overwrite existing hooks with full-featured versions)'));
+        // Still save API key for existing hooks to use
     }
+    else {
+        // No custom hooks OR all managed - safe to install full templates
+        try {
+            await (0, hooks_js_1.hooksInstall)({ global: true, verbose: false });
+        }
+        catch (err) {
+            // Fallback: if manifest-driven install fails, generate basic hooks
+            console.log(chalk_1.default.yellow('  Note: Could not install hooks from templates'));
+            console.log(chalk_1.default.gray('  Generating basic hooks instead...'));
+            await generateBasicHooks(hooksDir, apiKey);
+        }
+    }
+    // Save API key to config for hooks to use
+    const ekkosConfigDir = (0, path_1.join)((0, os_1.homedir)(), '.ekkos');
+    (0, fs_1.mkdirSync)(ekkosConfigDir, { recursive: true });
+    const configPath = (0, path_1.join)(ekkosConfigDir, 'config.json');
+    let existingConfig = {};
+    if ((0, fs_1.existsSync)(configPath)) {
+        try {
+            existingConfig = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        }
+        catch { }
+    }
+    // Update config with API key (hookApiKey for hooks, apiKey for compatibility)
+    existingConfig.hookApiKey = apiKey;
+    existingConfig.apiKey = apiKey;
+    existingConfig.updatedAt = new Date().toISOString();
+    (0, fs_1.writeFileSync)(configPath, JSON.stringify(existingConfig, null, 2));
+}
+/**
+ * Generate basic inline hooks as fallback when templates aren't available
+ */
+async function generateBasicHooks(hooksDir, apiKey) {
     const isWindows = (0, os_1.platform)() === 'win32';
     if (isWindows) {
-        // Windows: PowerShell hooks
         const promptSubmitHook = generatePromptSubmitHookPS(apiKey);
-        const promptSubmitPath = (0, path_1.join)(hooksDir, 'user-prompt-submit.ps1');
-        (0, fs_1.writeFileSync)(promptSubmitPath, promptSubmitHook);
+        (0, fs_1.writeFileSync)((0, path_1.join)(hooksDir, 'user-prompt-submit.ps1'), promptSubmitHook);
         const stopHook = generateStopHookPS(apiKey);
-        const stopPath = (0, path_1.join)(hooksDir, 'stop.ps1');
-        (0, fs_1.writeFileSync)(stopPath, stopHook);
-        // Create wrapper batch files for Windows
-        (0, fs_1.writeFileSync)((0, path_1.join)(hooksDir, 'user-prompt-submit.cmd'), `@echo off\npowershell -ExecutionPolicy Bypass -File "%~dp0user-prompt-submit.ps1"`);
-        (0, fs_1.writeFileSync)((0, path_1.join)(hooksDir, 'stop.cmd'), `@echo off\npowershell -ExecutionPolicy Bypass -File "%~dp0stop.ps1"`);
+        (0, fs_1.writeFileSync)((0, path_1.join)(hooksDir, 'stop.ps1'), stopHook);
     }
     else {
-        // Unix: Bash hooks
         const promptSubmitHook = generatePromptSubmitHook(apiKey);
         const promptSubmitPath = (0, path_1.join)(hooksDir, 'user-prompt-submit.sh');
         (0, fs_1.writeFileSync)(promptSubmitPath, promptSubmitHook);
@@ -230,11 +285,6 @@ async function setupClaudeCode(apiKey) {
         (0, fs_1.writeFileSync)(stopPath, stopHook);
         (0, fs_1.chmodSync)(stopPath, '755');
     }
-    // Create state directory
-    const stateDir = (0, path_1.join)(claudeDir, 'state');
-    if (!(0, fs_1.existsSync)(stateDir)) {
-        (0, fs_1.mkdirSync)(stateDir, { recursive: true });
-    }
 }
 async function setupCursor(apiKey) {
     // Cursor uses .cursorrules for system prompt
@@ -320,6 +370,33 @@ async function setupVSCode(apiKey) {
     // Note: Full VSCode integration requires extension
     console.log(chalk_1.default.yellow('  Note: VSCode requires the ekkOS extension for full integration'));
 }
+async function setupClaudeDesktop(apiKey) {
+    // Claude Desktop - configure MCP server
+    const claudeDir = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'Application Support', 'Claude');
+    if (!(0, fs_1.existsSync)(claudeDir)) {
+        (0, fs_1.mkdirSync)(claudeDir, { recursive: true });
+    }
+    // Create/update MCP config
+    const configPath = (0, path_1.join)(claudeDir, 'claude_desktop_config.json');
+    let config = {};
+    if ((0, fs_1.existsSync)(configPath)) {
+        try {
+            config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        }
+        catch { }
+    }
+    // Preserve existing preferences
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers['ekkos-memory'] = {
+        command: 'npx',
+        args: ['-y', '@ekkos/mcp-server@latest'],
+        env: {
+            EKKOS_API_KEY: apiKey
+        }
+    };
+    (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    console.log(chalk_1.default.yellow('  Note: Restart Claude Desktop to load the MCP server'));
+}
 function generatePromptSubmitHook(apiKey) {
     return `#!/bin/bash
 # ekkOS Hook: UserPromptSubmit

package/package.json

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

package/templates/agents/railway-manager.md

@@ -68,10 +68,30 @@ railway variables set KEY=value -s pm2-workers
 
 ## EKKOS SERVICES
 
-### Railway Service: `pm2-workers`
-**Project**: imaginative-vision
+### Railway Project: `imaginative-vision`
 **Environment**: production
 
+There are **3 services** in this Railway project:
+
+| Service | Purpose | Domain |
+|---------|---------|--------|
+| `ekkos-relay` | WebSocket relay for remote terminal | relay.ekkos.dev |
+| `pm2-workers` | PM2-managed background workers | pm2.ekkos.dev |
+| `cloud-terminal` | Cloud PTY service for browser terminals | (internal) |
+
+### Service: `ekkos-relay`
+WebSocket relay server connecting browsers to devices/cloud terminals.
+- Source: `apps/relay/`
+- Health: `/health`
+- Endpoints: `/api/v1/relay/device`, `/api/v1/relay/browser`, `/api/v1/relay/cloud`
+
+```bash
+railway logs -s ekkos-relay --lines 50
+railway up -s ekkos-relay
+railway redeploy -s ekkos-relay
+```
+
+### Service: `pm2-workers`
 PM2-managed workers:
 | Worker | Purpose |
 |--------|---------|
@@ -79,6 +99,22 @@ PM2-managed workers:
 | `working-memory-processor` | WM → DB batch sync |
 | `slow-loop-processor` | Pattern extraction (if enabled) |
 
+```bash
+railway logs -s pm2-workers --lines 50
+railway run -s pm2-workers -- pm2 status
+railway run -s pm2-workers -- pm2 restart all
+```
+
+### Service: `cloud-terminal`
+Cloud-based PTY service for browser terminal access.
+- Source: `apps/cloud-terminal/`
+- Connects to relay via WebSocket
+
+```bash
+railway logs -s cloud-terminal --lines 50
+railway redeploy -s cloud-terminal
+```
+
 ### Vercel Services (NOT on Railway)
 | Service | URL |
 |---------|-----|

package/templates/ekkos-manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://ekkos.dev/schemas/manifest-v1.json",
   "manifestVersion": "1.0.0",
-  "generatedAt": "2026-01-21T08:07:39.857Z",
+  "generatedAt": "2026-01-22T06:19:22.744Z",
   "platforms": {
     "darwin": {
       "configDir": "~/.ekkos",

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

@@ -159,6 +159,12 @@ if [ -z "$RAW_SESSION_ID" ] || [ "$RAW_SESSION_ID" = "unknown" ] || [ "$RAW_SESS
     if [ -f "$STATE_FILE" ] && [ -f "$JSON_PARSE_HELPER" ]; then
         RAW_SESSION_ID=$(node "$JSON_PARSE_HELPER" "$STATE_FILE" '.session_id' 2>/dev/null || echo "unknown")
     fi
+
+    # VSCode extension fallback: Extract session ID from transcript path
+    # Path format: ~/.claude/projects/<project>/<session-uuid>.jsonl
+    if [ "$RAW_SESSION_ID" = "unknown" ] && [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+        RAW_SESSION_ID=$(basename "$TRANSCRIPT_PATH" .jsonl)
+    fi
 fi
 
 # ═══════════════════════════════════════════════════════════════════════════