@ekkos/cli 1.3.1 → 1.3.5

package/dist/commands/scan.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ekkos scan
+ *
+ * Scans the current directory's repo structure, discovers systems,
+ * and seeds them into ekkOS system_registry via the memory API.
+ *
+ * Usage:
+ *   ekkos scan                  Scan cwd and seed registry
+ *   ekkos scan --compile        Also trigger a compile pass after seeding
+ *   ekkos scan --dry-run        Show what would be seeded without calling API
+ *   ekkos scan --path /my/repo  Scan a specific directory
+ *
+ * Reuses discovery logic from apps/memory/workers/context-compiler/registry-seed.ts
+ */
+interface ScanOptions {
+    compile?: boolean;
+    dryRun?: boolean;
+    path?: string;
+}
+export declare function scan(options: ScanOptions): Promise<void>;
+export {};

package/dist/commands/scan.js

@@ -0,0 +1,386 @@
+"use strict";
+/**
+ * ekkos scan
+ *
+ * Scans the current directory's repo structure, discovers systems,
+ * and seeds them into ekkOS system_registry via the memory API.
+ *
+ * Usage:
+ *   ekkos scan                  Scan cwd and seed registry
+ *   ekkos scan --compile        Also trigger a compile pass after seeding
+ *   ekkos scan --dry-run        Show what would be seeded without calling API
+ *   ekkos scan --path /my/repo  Scan a specific directory
+ *
+ * Reuses discovery logic from apps/memory/workers/context-compiler/registry-seed.ts
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scan = scan;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const platform_js_1 = require("../utils/platform.js");
+// ── Excluded directories ─────────────────────────────────────────────────
+const EXCLUDED_DIRS = new Set([
+    'node_modules', '.next', 'dist', 'out', 'build', '.turbo', '.cache',
+    '.git', '.github', '.vscode', '.idea', '.claude', '.windsurf',
+    'coverage', '__pycache__', '.pytest_cache', '.mypy_cache',
+    'vendor', '.vercel', '.svelte-kit', 'target', 'tmp', 'temp',
+    'logs', 'downloads', 'favicon', 'public', 'resources',
+]);
+const EXCLUDED_PREFIXES = ['.', '_'];
+// ── Domain detection ─────────────────────────────────────────────────────
+const DOMAIN_MAP = {
+    apps: 'platform',
+    packages: 'packages',
+    workers: 'workers',
+    extensions: 'extensions',
+    scripts: 'infra',
+    services: 'services',
+    lib: 'memory',
+    supabase: 'infra',
+    'mcp-servers': 'tools',
+    templates: 'tools',
+    docs: 'content',
+    content: 'content',
+    monitoring: 'infra',
+    tests: 'infra',
+    e2e: 'infra',
+    src: 'core',
+    api: 'api',
+    components: 'frontend',
+    pages: 'frontend',
+};
+function detectDomain(dirPath) {
+    const topLevel = dirPath.split('/')[0];
+    return DOMAIN_MAP[topLevel] || 'other';
+}
+// ── System ID generation ─────────────────────────────────────────────────
+function toSystemId(dirPath) {
+    return dirPath
+        .toLowerCase()
+        .replace(/\//g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 64);
+}
+function toHumanName(dirPath) {
+    const parts = dirPath.split('/');
+    return parts[parts.length - 1]
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+// ── Directory scanner ────────────────────────────────────────────────────
+function isIncludable(fullPath) {
+    const name = (0, path_1.basename)(fullPath);
+    if (EXCLUDED_DIRS.has(name))
+        return false;
+    if (EXCLUDED_PREFIXES.some(p => name.startsWith(p)))
+        return false;
+    // Must contain at least 1 source file or meaningful config
+    try {
+        const entries = (0, fs_1.readdirSync)(fullPath);
+        const sourceFiles = entries.filter(e => {
+            const ext = e.split('.').pop()?.toLowerCase();
+            return ['ts', 'tsx', 'js', 'jsx', 'mjs', 'py', 'rs', 'go', 'sql', 'mts'].includes(ext || '');
+        });
+        const configFiles = entries.filter(e => ['package.json', 'tsconfig.json', 'Cargo.toml', 'pyproject.toml', 'wrangler.toml', 'go.mod'].includes(e));
+        return sourceFiles.length >= 1 || configFiles.length >= 1;
+    }
+    catch {
+        return false;
+    }
+}
+// Container directories that always scan children
+const CONTAINER_DIRS = new Set([
+    'apps', 'packages', 'workers', 'extensions', 'services', 'mcp-servers',
+]);
+function scanDirectory(repoRoot, currentPath, depth, maxDepth, parentId) {
+    if (depth > maxDepth)
+        return [];
+    const results = [];
+    const relPath = (0, path_1.relative)(repoRoot, currentPath) || '.';
+    const dirName = (0, path_1.basename)(currentPath);
+    // Skip root — just descend into children
+    if (relPath === '.') {
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(currentPath);
+        }
+        catch {
+            return [];
+        }
+        for (const entry of entries) {
+            const full = (0, path_1.join)(currentPath, entry);
+            try {
+                if ((0, fs_1.statSync)(full).isDirectory() && !EXCLUDED_DIRS.has(entry) && !entry.startsWith('.')) {
+                    results.push(...scanDirectory(repoRoot, full, depth + 1, maxDepth, null));
+                }
+            }
+            catch { /* permission denied, etc. */ }
+        }
+        return results;
+    }
+    // Container directories (apps/, packages/, etc.) — always scan children, never register themselves
+    const isContainer = CONTAINER_DIRS.has(relPath) || CONTAINER_DIRS.has(dirName);
+    if (isContainer && depth <= 1) {
+        try {
+            const entries = (0, fs_1.readdirSync)(currentPath);
+            for (const e of entries) {
+                const full = (0, path_1.join)(currentPath, e);
+                try {
+                    if ((0, fs_1.statSync)(full).isDirectory() && !EXCLUDED_DIRS.has(e) && !e.startsWith('.')) {
+                        results.push(...scanDirectory(repoRoot, full, depth + 1, maxDepth, null));
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+        return results;
+    }
+    if (!isIncludable(currentPath))
+        return [];
+    const systemId = toSystemId(relPath);
+    const domain = detectDomain(relPath);
+    // Detect description from package.json if available
+    let description = `System at ${relPath}`;
+    const pkgPath = (0, path_1.join)(currentPath, 'package.json');
+    if ((0, fs_1.existsSync)(pkgPath)) {
+        try {
+            const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf-8'));
+            if (pkg.description)
+                description = pkg.description;
+        }
+        catch { /* ignore */ }
+    }
+    const entry = {
+        system_id: systemId,
+        name: toHumanName(relPath),
+        description,
+        directory_path: relPath,
+        domain,
+        status: 'active',
+        parent_system_id: parentId,
+        metadata: {},
+        tags: [domain],
+        aliases: [],
+    };
+    results.push(entry);
+    // Scan subdirectories for nested systems
+    const topLevel = relPath.split('/')[0];
+    const isNestedContainer = CONTAINER_DIRS.has(topLevel);
+    if (isNestedContainer && depth <= 3) {
+        try {
+            const entries = (0, fs_1.readdirSync)(currentPath);
+            for (const e of entries) {
+                const full = (0, path_1.join)(currentPath, e);
+                try {
+                    if ((0, fs_1.statSync)(full).isDirectory() && !EXCLUDED_DIRS.has(e) && !e.startsWith('.')) {
+                        results.push(...scanDirectory(repoRoot, full, depth + 1, maxDepth, systemId));
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return results;
+}
+// ── Boundary Precedence ──────────────────────────────────────────────────
+function assignParentSystems(systems) {
+    const sorted = [...systems].sort((a, b) => {
+        const depthA = a.directory_path.split('/').length;
+        const depthB = b.directory_path.split('/').length;
+        if (depthA !== depthB)
+            return depthA - depthB;
+        return a.system_id.localeCompare(b.system_id);
+    });
+    for (let i = 0; i < sorted.length; i++) {
+        const system = sorted[i];
+        if (system.parent_system_id)
+            continue;
+        let nearestParent = null;
+        let nearestDepth = -1;
+        for (let j = 0; j < sorted.length; j++) {
+            if (i === j)
+                continue;
+            const candidate = sorted[j];
+            const candidateDepth = candidate.directory_path.split('/').length;
+            if (system.directory_path.startsWith(candidate.directory_path + '/') &&
+                candidateDepth > nearestDepth) {
+                nearestParent = candidate;
+                nearestDepth = candidateDepth;
+            }
+        }
+        if (nearestParent) {
+            system.parent_system_id = nearestParent.system_id;
+        }
+    }
+    return sorted;
+}
+// ── Load API key from config ─────────────────────────────────────────────
+function loadApiKey() {
+    try {
+        if ((0, fs_1.existsSync)(platform_js_1.EKKOS_CONFIG)) {
+            const config = JSON.parse((0, fs_1.readFileSync)(platform_js_1.EKKOS_CONFIG, 'utf-8'));
+            return config.apiKey || null;
+        }
+    }
+    catch { /* ignore */ }
+    // Fall back to env var
+    return process.env.EKKOS_API_KEY || null;
+}
+// ── Detect git repo root ─────────────────────────────────────────────────
+function findGitRoot(startPath) {
+    let current = (0, path_1.resolve)(startPath);
+    while (current !== '/') {
+        if ((0, fs_1.existsSync)((0, path_1.join)(current, '.git'))) {
+            return current;
+        }
+        const parent = (0, path_1.resolve)(current, '..');
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+// ── Main scan command ────────────────────────────────────────────────────
+async function scan(options) {
+    const startTime = Date.now();
+    const targetPath = (0, path_1.resolve)(options.path || process.cwd());
+    const isDryRun = options.dryRun ?? false;
+    const shouldCompile = options.compile ?? false;
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('  ekkOS Scan'));
+    console.log(chalk_1.default.gray('  ─'.repeat(25)));
+    console.log('');
+    // Check if in a git repo
+    const gitRoot = findGitRoot(targetPath);
+    const repoRoot = gitRoot || targetPath;
+    if (gitRoot) {
+        console.log(chalk_1.default.gray(`  Git root: ${gitRoot}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow(`  No git repo found — scanning ${targetPath}`));
+    }
+    console.log('');
+    // Phase 1: Scan repo structure
+    const scanSpinner = (0, ora_1.default)('Scanning repo structure...').start();
+    let systems;
+    try {
+        const rawSystems = scanDirectory(repoRoot, repoRoot, 0, 4, null);
+        systems = assignParentSystems(rawSystems);
+        scanSpinner.succeed(`Found ${chalk_1.default.bold(systems.length.toString())} systems`);
+    }
+    catch (err) {
+        scanSpinner.fail('Scan failed');
+        console.error(chalk_1.default.red(`  ${err instanceof Error ? err.message : err}`));
+        process.exit(1);
+    }
+    // Show discovered systems
+    if (systems.length > 0) {
+        console.log('');
+        // Group by domain
+        const byDomain = new Map();
+        for (const s of systems) {
+            const group = byDomain.get(s.domain) || [];
+            group.push(s);
+            byDomain.set(s.domain, group);
+        }
+        for (const [domain, entries] of byDomain) {
+            console.log(chalk_1.default.cyan(`  ${domain}`));
+            for (const s of entries) {
+                const indent = s.parent_system_id ? '    ' : '  ';
+                const arrow = s.parent_system_id ? '└─' : '──';
+                console.log(chalk_1.default.gray(`${indent}${arrow} `) + chalk_1.default.white(s.system_id) + chalk_1.default.gray(` → ${s.directory_path}`));
+            }
+        }
+        console.log('');
+    }
+    // Dry run — stop here
+    if (isDryRun) {
+        console.log(chalk_1.default.yellow('  Dry run — no changes made'));
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(chalk_1.default.gray(`  Done in ${duration}s`));
+        console.log('');
+        return;
+    }
+    // Phase 2: Load API key
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.log(chalk_1.default.red('  No API key found.'));
+        console.log(chalk_1.default.gray('  Run `ekkos init` first, or set EKKOS_API_KEY env var.'));
+        console.log('');
+        process.exit(1);
+    }
+    // Phase 3: Seed registry via API
+    const seedSpinner = (0, ora_1.default)('Seeding registry...').start();
+    try {
+        const apiUrl = process.env.EKKOS_API_URL || platform_js_1.MCP_API_URL;
+        const response = await fetch(`${apiUrl}/api/v1/living-docs/seed`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                systems,
+                compile: shouldCompile,
+            }),
+        });
+        if (!response.ok) {
+            const errBody = await response.text();
+            seedSpinner.fail('Seed failed');
+            console.error(chalk_1.default.red(`  API returned ${response.status}: ${errBody}`));
+            process.exit(1);
+        }
+        const result = await response.json();
+        if (!result.ok) {
+            seedSpinner.fail('Seed failed');
+            console.error(chalk_1.default.red(`  ${result.error || 'Unknown error'}`));
+            process.exit(1);
+        }
+        seedSpinner.succeed(`Seeded ${chalk_1.default.bold(result.total.toString())} systems` +
+            (result.inserted > 0 ? chalk_1.default.green(` (${result.inserted} new)`) : '') +
+            (result.updated > 0 ? chalk_1.default.gray(` (${result.updated} updated)`) : ''));
+        // Show any errors
+        if (result.errors && result.errors.length > 0) {
+            console.log(chalk_1.default.yellow(`  ${result.errors.length} errors:`));
+            for (const e of result.errors.slice(0, 5)) {
+                console.log(chalk_1.default.gray(`    - ${e}`));
+            }
+            if (result.errors.length > 5) {
+                console.log(chalk_1.default.gray(`    ... and ${result.errors.length - 5} more`));
+            }
+        }
+        // Compile pass result
+        if (result.compile) {
+            if (result.compile.triggered) {
+                console.log(chalk_1.default.green('  Compile pass triggered'));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`  Compile skipped: ${result.compile.reason || result.compile.error || 'unknown'}`));
+            }
+        }
+    }
+    catch (err) {
+        seedSpinner.fail('Seed failed');
+        if (err instanceof TypeError && err.cause?.code === 'ECONNREFUSED') {
+            console.error(chalk_1.default.red('  Could not connect to ekkOS API. Is it running?'));
+        }
+        else {
+            console.error(chalk_1.default.red(`  ${err instanceof Error ? err.message : err}`));
+        }
+        process.exit(1);
+    }
+    // Summary
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log('');
+    console.log(chalk_1.default.green(`  Done in ${duration}s`));
+    console.log('');
+}

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);
+}