@ekkos/cli 1.3.1 → 1.3.2

package/dist/commands/run.js

@@ -43,6 +43,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
+const session_bridge_1 = require("../synk/session-bridge");
 // ═══════════════════════════════════════════════════════════════════════════
 // ccDNA AUTO-LOAD: Apply Claude Code patches before spawning
 // ═══════════════════════════════════════════════════════════════════════════
@@ -428,9 +429,7 @@ const PINNED_CLAUDE_VERSION = 'latest';
 // Opus 4.5 supports up to 64k - set EKKOS_MAX_OUTPUT_TOKENS=32768 or =65536 to use higher limits
 // Configurable via environment variable
 const EKKOS_MAX_OUTPUT_TOKENS = process.env.EKKOS_MAX_OUTPUT_TOKENS || '16384';
-// Default proxy URL for context eviction
-// eslint-disable-next-line no-restricted-syntax -- Config URL, not API key
-const EKKOS_PROXY_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.dev';
+const proxy_url_1 = require("../utils/proxy-url");
 // Track proxy mode for getEkkosEnv (set by run() based on options)
 let proxyModeEnabled = true;
 // ═══════════════════════════════════════════════════════════════════════════
@@ -459,7 +458,14 @@ function getEkkosEnv() {
     /* eslint-disable no-restricted-syntax -- System env spreading, not API key access */
     const env = {
         ...process.env,
-        // Let Claude Code use its own default max_tokens (don't override)
+        // Disable Claude's built-in auto-memory — ekkOS replaces it with 11-layer memory.
+        // This env var overrides all other settings (settings.json, /memory toggle).
+        // Saves ~1K tokens/turn of redundant context and avoids duplicate memory writes.
+        CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
+        // Disable auto-compact — ekkOS handles context preservation via PreserveContext/RestoreContext.
+        // Native autocompact would compact without ekkOS saving state first, causing knowledge loss.
+        // Only ekkOS-wrapped sessions get this; vanilla `claude` keeps autocompact on.
+        DISABLE_AUTO_COMPACT: 'true',
     };
     /* eslint-enable no-restricted-syntax */
     // Check if proxy is disabled via env var or options
@@ -493,13 +499,8 @@ function getEkkosEnv() {
         }
         // CRITICAL: Embed user/session in URL path since ANTHROPIC_HEADERS doesn't work
         // Claude Code SDK doesn't forward custom headers, but it DOES use ANTHROPIC_BASE_URL
-        // Format: https://mcp.ekkos.dev/proxy/{userId}/{sessionName}?project={base64(cwd)}
         // Gateway extracts from URL: /proxy/{userId}/{sessionName}/v1/messages
-        // Project path is base64-encoded to handle special chars safely
-        const projectPath = process.cwd();
-        const projectPathEncoded = Buffer.from(projectPath).toString('base64url');
-        const userTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        const proxyUrl = `${EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/${encodeURIComponent(cliSessionName)}?project=${projectPathEncoded}&sid=${encodeURIComponent(cliSessionId)}&tz=${encodeURIComponent(userTz)}`;
+        const proxyUrl = (0, proxy_url_1.buildProxyUrl)(userId, cliSessionName, process.cwd(), cliSessionId);
         env.ANTHROPIC_BASE_URL = proxyUrl;
         // Proxy URL contains userId + project path — don't leak to terminal
     }
@@ -836,10 +837,12 @@ function writeSessionFiles(sessionId, sessionName) {
 function launchWithDashboard(options) {
     const tmuxSession = `ekkos-${Date.now().toString(36)}`;
     const launchTime = Date.now();
+    // Pre-generate session name so dashboard can start immediately (no polling).
+    // Uses the user-supplied name if provided, otherwise mints a fresh one.
+    const sessionName = options.session || (0, state_1.uuidToWords)(crypto.randomUUID());
     // Build the ekkos run command WITHOUT --dashboard (prevent recursion)
-    const runArgs = ['run'];
-    if (options.session)
-        runArgs.push('-s', options.session);
+    // Always pass -s so run reuses the same session name we gave the dashboard
+    const runArgs = ['run', '-s', sessionName];
     if (options.bypass)
         runArgs.push('-b');
     if (options.verbose)
@@ -858,15 +861,11 @@ function launchWithDashboard(options) {
     const cwd = process.cwd();
     const termCols = process.stdout.columns ?? 160;
     const termRows = process.stdout.rows ?? 48;
-    // Write a marker file with launch timestamp + CWD so dashboard knows to wait for NEW session
-    const markerPath = path.join(state_1.EKKOS_DIR, '.dashboard-launch-ts');
-    try {
-        fs.writeFileSync(markerPath, `${launchTime}\n${cwd}`);
-    }
-    catch { }
-    const runCommand = `node "${ekkosCmd}" ${runArgs.join(' ')}`;
-    // Use --wait-for-new flag to wait for a session that started AFTER this launch
-    const dashCommand = `node "${ekkosCmd}" dashboard --wait-for-new --refresh 2000`;
+    // Write session hint immediately so dashboard can find JSONL as it appears
+    writeSessionFiles(crypto.randomUUID(), sessionName);
+    const runCommand = `EKKOS_NO_SPLASH=1 node "${ekkosCmd}" ${runArgs.join(' ')}`;
+    // Pass session name directly — dashboard starts rendering immediately (lazy JSONL resolution)
+    const dashCommand = `node "${ekkosCmd}" dashboard "${sessionName}" --refresh 2000`;
     try {
         // Pane 0 (left): start with inert command (no interactive shell startup noise).
         // Claude is launched AFTER split so Ink gets final pane geometry at startup.
@@ -881,6 +880,9 @@ function launchWithDashboard(options) {
                 }
             }
         };
+        // Terminal type and escape sequence passthrough for Ink TUI rendering
+        applyTmuxOpt(`set-option -t "${tmuxSession}" default-terminal "xterm-256color"`);
+        applyTmuxOpt(`set-option -sa -t "${tmuxSession}" terminal-overrides ",xterm-256color:Tc:smcup@:rmcup@"`);
         // Session/window isolation and quality-of-life settings
         applyTmuxOpt(`set-option -t "${tmuxSession}" mouse on`);
         applyTmuxOpt(`set-window-option -t "${tmuxSession}" history-limit 100000`);
@@ -917,18 +919,13 @@ function launchWithDashboard(options) {
  */
 function launchWithWindowsTerminal(options) {
     const cwd = process.cwd();
-    const launchTime = Date.now();
-    // Write marker file so dashboard knows to wait for a NEW session
-    const markerPath = path.join(state_1.EKKOS_DIR, '.dashboard-launch-ts');
-    try {
-        fs.writeFileSync(markerPath, `${launchTime}\n${cwd}`);
-    }
-    catch { }
+    // Pre-generate session name so dashboard can start immediately
+    const sessionName = options.session || (0, state_1.uuidToWords)(crypto.randomUUID());
+    // Write session hint immediately
+    writeSessionFiles(crypto.randomUUID(), sessionName);
     // Build ekkos run args WITHOUT --dashboard (prevent recursion)
-    // Uses `ekkos` directly — it's in PATH since user ran `ekkos --dashboard`
-    const runArgs = ['run'];
-    if (options.session)
-        runArgs.push('-s', options.session);
+    // Always pass -s so run reuses the same session name we gave the dashboard
+    const runArgs = ['run', '-s', sessionName];
     if (options.bypass)
         runArgs.push('-b');
     if (options.verbose)
@@ -945,10 +942,10 @@ function launchWithWindowsTerminal(options) {
         runArgs.push('--skip-proxy');
     // Write a temp batch file to avoid all quoting issues
     // wt.exe doesn't resolve PATH for npm global bins — must use `cmd /c`
-    const batPath = path.join(os.tmpdir(), `ekkos-wt-${launchTime}.cmd`);
+    const batPath = path.join(os.tmpdir(), `ekkos-wt-${Date.now()}.cmd`);
     const batContent = [
         '@echo off',
-        `wt --title "Claude Code" -d "${cwd}" cmd /c ekkos ${runArgs.join(' ')} ; split-pane -V -s 0.4 --title "ekkOS Dashboard" -d "${cwd}" cmd /c ekkos dashboard --wait-for-new --refresh 2000`,
+        `wt --title "Claude Code" -d "${cwd}" cmd /c ekkos ${runArgs.join(' ')} ; split-pane -V -s 0.4 --title "ekkOS Dashboard" -d "${cwd}" cmd /c ekkos dashboard "${sessionName}" --refresh 2000`,
     ].join('\r\n');
     try {
         fs.writeFileSync(batPath, batContent);
@@ -990,6 +987,13 @@ async function run(options) {
     const verbose = options.verbose || false;
     const bypass = options.bypass || false;
     const noInject = options.noInject || false;
+    // Honour -s flag: lock the session name before getEkkosEnv() can mint a new one.
+    // This is critical for --dashboard mode where launchWithDashboard() pre-generates
+    // a session name and passes it via -s so the dashboard and run command agree.
+    if (options.session && !cliSessionName) {
+        cliSessionName = options.session;
+        cliSessionId = crypto.randomUUID(); // pair an ID with it
+    }
     // Set proxy mode based on options (used by getEkkosEnv)
     proxyModeEnabled = !(options.noProxy || false);
     if (proxyModeEnabled) {
@@ -1169,7 +1173,7 @@ async function run(options) {
     // ══════════════════════════════════════════════════════════════════════════
     // STARTUP BANNER WITH COLOR PULSE ANIMATION
     // ══════════════════════════════════════════════════════════════════════════
-    const skipFancyIntro = process.env.EKKOS_REMOTE_SESSION === '1' || process.env.EKKOS_NO_SPLASH === '1';
+    const skipFancyIntro = process.env.EKKOS_REMOTE_SESSION === '1' || process.env.EKKOS_NO_SPLASH === '1' || !!process.env.TMUX;
     if (!skipFancyIntro) {
         const logoLines = [
             '                      ▄▄▄▄▄    ▄▄▄▄▄▄▄     ▄▄▄ ▄▄ ▄▄',
@@ -1374,6 +1378,8 @@ async function run(options) {
     // ANIMATION COMPLETE: Mark ready and flush buffered Claude output
     // ══════════════════════════════════════════════════════════════════════════
     animationComplete = true;
+    // Clear terminal to prevent startup banner artifacts bleeding into Claude Code's Ink TUI
+    process.stdout.write('\x1B[2J\x1B[H');
     dlog(`Animation complete. shellReady=${shellReady}, buffered=${bufferedOutput.length} chunks`);
     // Show loading indicator if Claude is still initializing
     if (shellReady && bufferedOutput.length === 0) {
@@ -1401,9 +1407,10 @@ async function run(options) {
     // MULTI-SESSION SUPPORT: Register this process as an active session
     // This prevents state collision when multiple Claude Code instances run
     // ════════════════════════════════════════════════════════════════════════════
-    (0, state_1.registerActiveSession)('pending', // Session ID not yet known
-    currentSession || 'initializing', process.cwd());
-    writeSessionFiles(cliSessionId || 'pending', currentSession || 'initializing');
+    const initialSessionId = cliSessionId || 'pending';
+    const initialSessionName = currentSession || 'initializing';
+    (0, state_1.registerActiveSession)(initialSessionId, initialSessionName, process.cwd());
+    writeSessionFiles(initialSessionId, initialSessionName);
     dlog(`Registered active session (PID ${process.pid})`);
     // Show active sessions count if verbose
     if (verbose) {
@@ -1412,6 +1419,8 @@ async function run(options) {
             console.log(chalk_1.default.cyan(`  📊 Active ekkOS sessions: ${activeSessions.length}`));
         }
     }
+    // Synk bridge — real-time session sync (null when synk not configured)
+    const synkBridge = await session_bridge_1.SynkSessionBridge.create({ cwd: process.cwd(), verbose });
     let isAutoClearInProgress = false;
     let transcriptPath = null;
     let currentSessionId = null;
@@ -1419,9 +1428,9 @@ async function run(options) {
     // PER-TURN BANNER STATE
     // Tracks idle→active transitions to print the session banner once per turn
     // ══════════════════════════════════════════════════════════════════════════
-    let wasIdle = true; // Start as idle (no prompt submitted yet)
-    let _turnCount = 0; // Incremented each time a new turn banner prints (unused beyond banner)
-    let lastBannerTime = 0; // Epoch ms of last banner print (debounce guard)
+    let wasIdle = false; // Start as NOT idle — first idle→active fires after startup
+    let turnCount = 0; // Incremented each time a new turn banner prints
+    let lastBannerTime = Date.now(); // Grace period so startup output doesn't trigger banner
     // Stream tailer for mid-turn context capture (must be declared before polling code)
     let streamTailer = null;
     const streamCacheDir = path.join(os.homedir(), '.ekkos', 'cache', 'sessions', instanceId);
@@ -1866,6 +1875,7 @@ async function run(options) {
         console.log('');
     }
     let shell;
+    const sessionStartTime = Date.now();
     // ══════════════════════════════════════════════════════════════════════════
     // USE EARLY-SPAWNED SHELL OR CREATE NEW ONE
     // If we spawned Claude during animation, reuse it. Otherwise spawn now.
@@ -1973,6 +1983,17 @@ async function run(options) {
     process.stdin.on('data', onStdinData);
     // Helper to get current output buffer (for readiness checks)
     const getOutputBuffer = () => outputBuffer;
+    // Synk remote message injection — receive messages from mobile/web, inject into PTY
+    if (synkBridge) {
+        synkBridge.on('remote-message', async (msg) => {
+            const { ready } = await waitForIdlePrompt(getOutputBuffer, config);
+            if (ready) {
+                shell.write('\x15'); // Ctrl+U clear line
+                await typeSlowly(shell, msg.text, config.charDelayMs);
+                shell.write('\r');
+            }
+        });
+    }
     // Handle context wall detection
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async function handleContextWall() {
@@ -2350,6 +2371,8 @@ async function run(options) {
         if (outputBuffer.length > 5000) {
             outputBuffer = outputBuffer.slice(-2000);
         }
+        // Forward to synk real-time sync (batched internally)
+        synkBridge?.onAgentOutput(data);
         // ══════════════════════════════════════════════════════════════════════════
         // PER-TURN BANNER (replaces hook-based terminal header)
         // Prints once per turn when transitioning from idle → active (AI responding).
@@ -2364,7 +2387,7 @@ async function run(options) {
                 !trimmed.startsWith('❯') &&
                 !trimmed.startsWith('%'); // zsh prompt artefact
             if (isSubstantialOutput && Date.now() - lastBannerTime > 3000) {
-                _turnCount++;
+                turnCount++;
                 const now = new Date();
                 const timeStr = now.toLocaleTimeString('en-US', {
                     hour: 'numeric',
@@ -2382,11 +2405,14 @@ async function run(options) {
                 process.stderr.write(`${chalk_1.default.cyan.bold('🧠 ekkOS Memory')} ${chalk_1.default.dim(`| ${sessionLabel} | ${dateStr} ${timeStr} EST`)}\n`);
                 lastBannerTime = Date.now();
                 wasIdle = false;
+                synkBridge?.onIdleChange(false);
             }
         }
         // Track idle state for the banner (works in both proxy and local mode).
         // We check the raw outputBuffer (stripped) so the idle regex fires reliably.
         if (IDLE_PROMPT_REGEX.test(stripAnsi(outputBuffer))) {
+            if (!wasIdle)
+                synkBridge?.onIdleChange(true);
             wasIdle = true;
         }
         // ══════════════════════════════════════════════════════════════════════════
@@ -2494,6 +2520,7 @@ async function run(options) {
                     dlog(`Session detected from status line: ${currentSession} (observedSessionThisRun=true)`);
                     bindRealSessionToProxy(currentSession, 'status-line', currentSessionId || undefined);
                     resolveTranscriptFromSessionId('status-line');
+                    synkBridge?.onSessionEstablished(currentSession, currentSessionId || 'unknown', { hostPid: process.pid });
                 }
             }
             else {
@@ -2685,10 +2712,99 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
             }
         }, 4000); // Wait 4 seconds for Claude to fully initialize
     }
+    // ══════════════════════════════════════════════════════════════════════════
+    // SESSION-END VALUE REPORT
+    // Prints a boxed summary of session stats before exit.
+    // Fetches savings data from ekkOS API with a 2s timeout — skips silently on failure.
+    // ══════════════════════════════════════════════════════════════════════════
+    async function printSessionEndReport() {
+        try {
+            const sessionName = currentSession || cliSessionName || 'unknown';
+            // Compute duration
+            const elapsedMs = Date.now() - sessionStartTime;
+            const totalSec = Math.floor(elapsedMs / 1000);
+            const hours = Math.floor(totalSec / 3600);
+            const minutes = Math.floor((totalSec % 3600) / 60);
+            const seconds = totalSec % 60;
+            let duration;
+            if (hours > 0) {
+                duration = `${hours}h ${minutes}m ${seconds}s`;
+            }
+            else if (minutes > 0) {
+                duration = `${minutes}m ${seconds}s`;
+            }
+            else {
+                duration = `${seconds}s`;
+            }
+            // Fetch savings stats from ekkOS API (2-second timeout)
+            let patternsRecalled = 0;
+            let tokensSaved = 0;
+            let costSaved = '0.00';
+            try {
+                const mcpUrl = process.env.EKKOS_MCP_URL || MEMORY_API_URL;
+                const authToken = (0, state_1.getAuthToken)();
+                if (authToken) {
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), 2000);
+                    const res = await fetch(`${mcpUrl}/api/v1/savings/me?period=day`, {
+                        method: 'GET',
+                        headers: {
+                            'Authorization': `Bearer ${authToken}`,
+                            'Content-Type': 'application/json',
+                        },
+                        signal: controller.signal,
+                    });
+                    clearTimeout(timeout);
+                    if (res.ok) {
+                        const data = await res.json();
+                        patternsRecalled = data.patterns_recalled || 0;
+                        tokensSaved = data.tokens_saved || 0;
+                        costSaved = (data.cost_saved || 0).toFixed(2);
+                    }
+                }
+            }
+            catch {
+                // Silent fail — API unavailable or timed out, just use defaults
+            }
+            // Format token count with commas
+            const tokensFormatted = tokensSaved.toLocaleString('en-US');
+            // Build the box content
+            const title = `ekkOS_ Session  ·  ${sessionName}`;
+            const line1 = `Duration: ${duration}  |  Turns: ${turnCount}`;
+            const line2 = `Patterns recalled: ${patternsRecalled}`;
+            const line3 = `Tokens saved: ${tokensFormatted} (~$${costSaved})`;
+            // Calculate box width (minimum 49, expand for long content)
+            const contentLines = [title, line1, line2, line3];
+            const maxContent = Math.max(...contentLines.map(l => l.length));
+            const innerWidth = Math.max(47, maxContent + 4);
+            const pad = (text) => {
+                const padding = innerWidth - text.length - 2;
+                return `  ${text}${' '.repeat(Math.max(0, padding))}`;
+            };
+            const top = `╭${'─'.repeat(innerWidth)}╮`;
+            const sep = `├${'─'.repeat(innerWidth)}┤`;
+            const bottom = `╰${'─'.repeat(innerWidth)}╯`;
+            const row = (text) => `│${pad(text)}│`;
+            // Print the box
+            console.log('');
+            console.log(chalk_1.default.dim(top));
+            console.log(chalk_1.default.dim('│') + chalk_1.default.bold(pad(title)) + chalk_1.default.dim('│'));
+            console.log(chalk_1.default.dim(sep));
+            console.log(chalk_1.default.dim('│') + pad(line1) + chalk_1.default.dim('│'));
+            console.log(chalk_1.default.dim(row(line2)));
+            console.log(chalk_1.default.dim('│') + chalk_1.default.green(pad(line3)) + chalk_1.default.dim('│'));
+            console.log(chalk_1.default.dim(bottom));
+            console.log('');
+        }
+        catch {
+            // Never block exit — silently skip the entire report on any error
+        }
+    }
     // Handle PTY exit
-    shell.onExit(({ exitCode }) => {
+    shell.onExit(async ({ exitCode }) => {
         (0, state_1.clearAutoClearFlag)();
         stopStreamTailer(); // Stop stream capture
+        await synkBridge?.shutdown(); // Close synk session
         (0, state_1.unregisterActiveSession)(); // Remove from active sessions registry
         cleanupInstanceFile(instanceId); // Clean up instance file
         // NOTE: No ccDNA restore needed - ekkOS uses separate installation from homebrew
@@ -2698,6 +2814,8 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
             process.stdin.setRawMode(false);
         }
         process.stdin.pause();
+        // Print session-end value report before exiting
+        await printSessionEndReport();
         // Log exit to file (not terminal - TUI already gone at this point)
         dlog(`Claude exited with code ${exitCode}`);
         process.exit(exitCode);
@@ -2706,6 +2824,7 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
     const cleanup = () => {
         (0, state_1.clearAutoClearFlag)();
         stopStreamTailer(); // Stop stream capture
+        synkBridge?.shutdown().catch(() => { }); // Close synk session (best-effort)
         (0, state_1.unregisterActiveSession)(); // Remove from active sessions registry
         cleanupInstanceFile(instanceId); // Clean up instance file
         // NOTE: No ccDNA restore needed - ekkOS uses separate installation from homebrew

package/dist/commands/status.d.ts

@@ -1 +1,4 @@
-export declare function status(): Promise<void>;
+export declare function status(opts?: {
+    watch?: boolean;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/status.js

@@ -11,40 +11,108 @@ const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const EKKOS_API_URL = 'https://mcp.ekkos.dev';
 const CONFIG_FILE = (0, path_1.join)((0, os_1.homedir)(), '.ekkos', 'config.json');
-async function status() {
-    console.log('');
-    console.log(chalk_1.default.cyan.bold('📊 ekkOS Memory Status'));
-    console.log(chalk_1.default.gray('─'.repeat(50)));
-    console.log('');
-    // Check config exists
-    if (!(0, fs_1.existsSync)(CONFIG_FILE)) {
-        console.log(chalk_1.default.red('✗ Not configured'));
-        console.log(chalk_1.default.gray('  Run: npx @ekkos/cli setup'));
-        process.exit(1);
-    }
-    let config;
+const METRICS_FILE = (0, path_1.join)((0, os_1.homedir)(), '.ekkos', 'session-metrics.json');
+/** Age (ms) after which the metrics file is considered stale (no active session). */
+const METRICS_STALE_MS = 5 * 60 * 1000; // 5 minutes
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function readMetrics() {
+    if (!(0, fs_1.existsSync)(METRICS_FILE))
+        return null;
     try {
-        config = JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, 'utf-8'));
+        return JSON.parse((0, fs_1.readFileSync)(METRICS_FILE, 'utf-8'));
     }
     catch {
-        console.log(chalk_1.default.red('✗ Invalid configuration'));
-        process.exit(1);
+        return null;
     }
-    const apiKey = config.apiKey || process.env.EKKOS_API_KEY;
-    if (!apiKey) {
-        console.log(chalk_1.default.red('✗ No API key'));
-        process.exit(1);
+}
+function isMetricsStale(m) {
+    const updatedAt = new Date(m.updated_at).getTime();
+    return Date.now() - updatedAt > METRICS_STALE_MS;
+}
+function formatDuration(isoStart) {
+    const ms = Date.now() - new Date(isoStart).getTime();
+    const totalSec = Math.floor(ms / 1000);
+    const h = Math.floor(totalSec / 3600);
+    const m = Math.floor((totalSec % 3600) / 60);
+    const s = totalSec % 60;
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}
+function formatTokens(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${Math.round(n / 1000)}K`;
+    return String(n);
+}
+// ─── Session panel ────────────────────────────────────────────────────────────
+function printSessionPanel(m) {
+    const sessionLabel = m.session_name || m.session_id;
+    const duration = formatDuration(m.started_at);
+    const turnLabel = m.turn > 0 ? `Turn ${m.turn}` : `${m.tool_calls} calls`;
+    const lines = [
+        `ekkOS Session: ${sessionLabel}`,
+        `Duration: ${duration}  ·  ${turnLabel}`,
+        null, // separator
+        `Patterns recalled:  ${m.patterns_recalled}`,
+        `Patterns forged:    ${m.patterns_forged}`,
+        `Directives active:  ${m.directives_active}`,
+        `Cache: ${m.cache_backend} (${m.cache_patterns} patterns)`,
+        null, // separator
+        `Tokens: ${formatTokens(m.tokens_in)} in  ·  ${formatTokens(m.tokens_out)} out`,
+    ];
+    // Compute box width from longest content line
+    const contentLines = lines.filter(Boolean);
+    const maxLen = Math.max(...contentLines.map(l => l.length));
+    const innerWidth = Math.max(39, maxLen + 4); // 2 spaces padding each side
+    const pad = (text) => {
+        const spaces = innerWidth - text.length - 2;
+        return `  ${text}${' '.repeat(Math.max(0, spaces))}`;
+    };
+    const top = `┌${'─'.repeat(innerWidth)}┐`;
+    const sep = `├${'─'.repeat(innerWidth)}┤`;
+    const bottom = `└${'─'.repeat(innerWidth)}┘`;
+    const row = (text) => `│${pad(text)}│`;
+    const sepRow = sep;
+    console.log('');
+    console.log(chalk_1.default.cyan(top));
+    let firstSep = false;
+    for (const line of lines) {
+        if (line === null) {
+            // Separator after header block, then again before token block
+            if (!firstSep) {
+                console.log(chalk_1.default.cyan(sepRow));
+                firstSep = true;
+            }
+            else {
+                console.log(chalk_1.default.cyan(sepRow));
+            }
+        }
+        else if (!firstSep) {
+            // Header rows — bold
+            console.log(chalk_1.default.cyan('│') + chalk_1.default.bold(pad(line)) + chalk_1.default.cyan('│'));
+        }
+        else {
+            console.log(chalk_1.default.cyan(row(line)));
+        }
     }
+    console.log(chalk_1.default.cyan(bottom));
+    console.log('');
+}
+// ─── Memory API stats (original status content) ───────────────────────────────
+async function printMemoryStats(apiKey, config) {
     const spinner = (0, ora_1.default)('Fetching memory stats...').start();
     try {
-        // Get pattern stats
         const patternsResponse = await fetch(`${EKKOS_API_URL}/api/v1/patterns/query`, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
+                'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ query: '', k: 100 })
+            body: JSON.stringify({ query: '', k: 100 }),
         });
         let patternCount = 0;
         let avgSuccessRate = 0;
@@ -60,13 +128,11 @@ async function status() {
             }
         }
         spinner.stop();
-        // Display stats
         console.log(chalk_1.default.cyan('Patterns:'));
         console.log(`  Total:        ${chalk_1.default.bold(patternCount)}`);
         console.log(`  Success Rate: ${chalk_1.default.bold((avgSuccessRate * 100).toFixed(1) + '%')}`);
         console.log(`  Applications: ${chalk_1.default.bold(totalApplications)}`);
         console.log('');
-        // IDE status
         console.log(chalk_1.default.cyan('Connected IDEs:'));
         const ides = config.installedIDEs || [];
         if (ides.length === 0) {
@@ -78,13 +144,11 @@ async function status() {
             }
         }
         console.log('');
-        // Config info
         console.log(chalk_1.default.cyan('Configuration:'));
         console.log(`  Config File: ${chalk_1.default.gray(CONFIG_FILE)}`);
         console.log(`  Installed:   ${chalk_1.default.gray(config.installedAt || 'Unknown')}`);
         console.log(`  API Key:     ${chalk_1.default.gray(apiKey.substring(0, 10) + '...')}`);
         console.log('');
-        // Golden Loop status
         console.log(chalk_1.default.cyan('Golden Loop:'));
         const loopActive = patternCount > 0 || totalApplications > 0;
         if (loopActive) {
@@ -95,7 +159,6 @@ async function status() {
             console.log(chalk_1.default.yellow('  ○ INITIALIZING - Start coding to build memory'));
         }
         console.log('');
-        // Footer
         console.log(chalk_1.default.gray('─'.repeat(50)));
         console.log('');
         console.log(`Dashboard: ${chalk_1.default.cyan('https://ekkos.dev/dashboard')}`);
@@ -107,3 +170,78 @@ async function status() {
         process.exit(1);
     }
 }
+// ─── Single render pass ───────────────────────────────────────────────────────
+function renderOnce(opts) {
+    const metrics = readMetrics();
+    if (opts.json) {
+        if (!metrics || isMetricsStale(metrics)) {
+            console.log(JSON.stringify({ active: false, reason: 'No active session or session stale' }));
+        }
+        else {
+            console.log(JSON.stringify({ active: true, ...metrics }));
+        }
+        return;
+    }
+    if (!metrics || isMetricsStale(metrics)) {
+        console.log('');
+        console.log(chalk_1.default.gray('  No active ekkOS session detected.'));
+        console.log(chalk_1.default.gray('  Run `ekkos run` to start a session.'));
+        console.log('');
+        return;
+    }
+    printSessionPanel(metrics);
+}
+// ─── Main export ──────────────────────────────────────────────────────────────
+async function status(opts = {}) {
+    // Watch mode: render every 2s, clear between renders
+    if (opts.watch) {
+        // Initial render
+        process.stdout.write('\x1B[2J\x1B[0f'); // clear screen
+        renderOnce({ json: false, skipMemory: true });
+        setInterval(() => {
+            process.stdout.write('\x1B[2J\x1B[0f');
+            renderOnce({ json: false, skipMemory: true });
+        }, 2000);
+        // Keep alive until Ctrl-C
+        return;
+    }
+    // JSON mode: just dump the metrics file
+    if (opts.json) {
+        renderOnce({ json: true, skipMemory: false });
+        return;
+    }
+    // Normal mode: show session panel (if active) then memory stats
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('ekkOS Memory Status'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    // Session panel (live metrics from MCP server)
+    const metrics = readMetrics();
+    if (metrics && !isMetricsStale(metrics)) {
+        printSessionPanel(metrics);
+    }
+    else {
+        console.log('');
+        console.log(chalk_1.default.gray('  No active session'));
+        console.log('');
+    }
+    // Memory API stats (requires config + network)
+    if (!(0, fs_1.existsSync)(CONFIG_FILE)) {
+        console.log(chalk_1.default.red('  ✗ Not configured — run: ekkos init'));
+        console.log('');
+        return;
+    }
+    let config;
+    try {
+        config = JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        console.log(chalk_1.default.red('  ✗ Invalid configuration'));
+        return;
+    }
+    const apiKey = config.apiKey || process.env.EKKOS_API_KEY;
+    if (!apiKey) {
+        console.log(chalk_1.default.red('  ✗ No API key — run: ekkos init'));
+        return;
+    }
+    await printMemoryStats(apiKey, config);
+}

package/dist/commands/synk.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ekkOS_synk commands — remote session sync for Claude Code
+ *
+ * Provides: ekkos synk auth, connect, disconnect, sessions, daemon start/stop/status, doctor
+ */
+import { Command } from 'commander';
+export declare function registerSynkCommands(program: Command): void;