@ekkos/cli 0.3.3 → 1.0.1

package/dist/commands/swarm.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Swarm CLI Commands
+ *
+ * Q-Learning model routing + multi-agent parallel task execution.
+ *
+ * Commands:
+ *   ekkos swarm status  — Show Q-table stats
+ *   ekkos swarm reset   — Clear Q-table from Redis
+ *   ekkos swarm export  — Dump Q-table to .swarm/q-learning-model.json
+ *   ekkos swarm import  — Load .swarm/q-learning-model.json into Redis
+ *   ekkos swarm launch  — Launch parallel workers on a decomposed task
+ */
+export declare function swarmStatus(): Promise<void>;
+export declare function swarmReset(): Promise<void>;
+export declare function swarmExport(): Promise<void>;
+export declare function swarmImport(): Promise<void>;
+export interface SwarmLaunchOptions {
+    workers: number;
+    task: string;
+    bypass?: boolean;
+    noDecompose?: boolean;
+    noQueen?: boolean;
+    verbose?: boolean;
+    queenStrategy?: string;
+    modelTiers?: ('opus' | 'sonnet' | 'haiku')[];
+    interactive?: boolean;
+}
+/**
+ * Launch N parallel workers in a tmux session, each working on a subtask.
+ *
+ * Architecture:
+ * - Uses tmux WINDOWS (not panes) — compatible with Python Queen discovery
+ * - Window 0: Swarm Dashboard (blessed TUI showing all workers)
+ * - Windows 1-N: Workers running `ekkos run -b` (proxy + infinite context)
+ * - Each worker gets full ekkOS stack: proxy, hooks, ccDNA, context eviction
+ *
+ * Flow:
+ * 1. Decompose task via Gemini Flash (free, fast)
+ * 2. Create tmux session: dashboard window + N worker windows
+ * 3. Each worker window runs `ekkos run -b` (ekkOS CLI, not vanilla Claude)
+ * 4. Wait for Claude Code to initialize (PTY + proxy + hooks)
+ * 5. Send subtask to each worker via tmux send-keys
+ * 6. Start swarm dashboard in window 0
+ * 7. Attach to tmux session (dashboard is default view)
+ */
+export declare function swarmLaunch(options: SwarmLaunchOptions): Promise<string | void>;

package/dist/commands/swarm.js

@@ -0,0 +1,441 @@
+"use strict";
+/**
+ * Swarm CLI Commands
+ *
+ * Q-Learning model routing + multi-agent parallel task execution.
+ *
+ * Commands:
+ *   ekkos swarm status  — Show Q-table stats
+ *   ekkos swarm reset   — Clear Q-table from Redis
+ *   ekkos swarm export  — Dump Q-table to .swarm/q-learning-model.json
+ *   ekkos swarm import  — Load .swarm/q-learning-model.json into Redis
+ *   ekkos swarm launch  — Launch parallel workers on a decomposed task
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swarmStatus = swarmStatus;
+exports.swarmReset = swarmReset;
+exports.swarmExport = swarmExport;
+exports.swarmImport = swarmImport;
+exports.swarmLaunch = swarmLaunch;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const PROXY_API_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.dev';
+const CONFIG_FILE = (0, path_1.join)((0, os_1.homedir)(), '.ekkos', 'config.json');
+const SWARM_DIR = (0, path_1.join)(process.cwd(), '.swarm');
+const SWARM_FILE = (0, path_1.join)(SWARM_DIR, 'q-learning-model.json');
+function getUserId() {
+    try {
+        if ((0, fs_1.existsSync)(CONFIG_FILE)) {
+            const config = JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, 'utf-8'));
+            return config.userId || null;
+        }
+    }
+    catch { }
+    return null;
+}
+async function swarmStatus() {
+    const userId = getUserId();
+    if (!userId) {
+        console.log(chalk_1.default.red('Not authenticated. Run `ekkos init` first.'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)('Fetching Q-table stats...').start();
+    try {
+        const res = await fetch(`${PROXY_API_URL}/swarm/status/${userId}`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const stats = await res.json();
+        spinner.stop();
+        console.log('');
+        console.log(chalk_1.default.cyan.bold('🐝 Swarm Q-Learning Status'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log('');
+        console.log(`  ${chalk_1.default.gray('States explored:')}  ${chalk_1.default.bold(String(stats.totalStates))}/48`);
+        console.log(`  ${chalk_1.default.gray('Total visits:')}     ${chalk_1.default.bold(String(stats.totalVisits))}`);
+        console.log(`  ${chalk_1.default.gray('Total updates:')}    ${chalk_1.default.bold(String(stats.totalUpdates))}`);
+        console.log(`  ${chalk_1.default.gray('Epsilon (ε):')}      ${chalk_1.default.bold(stats.epsilon.toFixed(4))} ${chalk_1.default.gray(`(${stats.epsilon > 0.1 ? 'exploring' : 'exploiting'})`)}`);
+        console.log(`  ${chalk_1.default.gray('Last updated:')}     ${stats.lastUpdated ? new Date(stats.lastUpdated).toLocaleString() : 'never'}`);
+        if (stats.topStates && stats.topStates.length > 0) {
+            console.log('');
+            console.log(chalk_1.default.gray('  Top states by visits:'));
+            console.log('');
+            console.log(`  ${chalk_1.default.gray('State')}                    ${chalk_1.default.gray('Visits')}  ${chalk_1.default.gray('Best')}    ${chalk_1.default.gray('Q-Values (opus/sonnet/haiku)')}`);
+            for (const s of stats.topStates) {
+                const tierColor = s.bestAction === 'opus' ? chalk_1.default.magenta : s.bestAction === 'sonnet' ? chalk_1.default.blue : chalk_1.default.green;
+                const qStr = s.qValues.map((v) => v.toFixed(2)).join(' / ');
+                console.log(`  ${chalk_1.default.white(s.key.padEnd(24))} ${String(s.visits).padStart(6)}  ${tierColor(s.bestAction.padEnd(8))} ${chalk_1.default.gray(qStr)}`);
+            }
+        }
+        else {
+            console.log('');
+            console.log(chalk_1.default.gray('  No Q-table data yet. Start a session to begin learning.'));
+        }
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail(`Failed to fetch stats: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function swarmReset() {
+    const userId = getUserId();
+    if (!userId) {
+        console.log(chalk_1.default.red('Not authenticated. Run `ekkos init` first.'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)('Resetting Q-table...').start();
+    try {
+        const res = await fetch(`${PROXY_API_URL}/swarm/reset/${userId}`, { method: 'DELETE' });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        spinner.succeed(chalk_1.default.green('Q-table cleared. Routing will use static rules until new data is learned.'));
+    }
+    catch (err) {
+        spinner.fail(`Failed to reset: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function swarmExport() {
+    const userId = getUserId();
+    if (!userId) {
+        console.log(chalk_1.default.red('Not authenticated. Run `ekkos init` first.'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)('Exporting Q-table...').start();
+    try {
+        const res = await fetch(`${PROXY_API_URL}/swarm/export/${userId}`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        // Ensure .swarm directory exists
+        if (!(0, fs_1.existsSync)(SWARM_DIR)) {
+            (0, fs_1.mkdirSync)(SWARM_DIR, { recursive: true });
+        }
+        (0, fs_1.writeFileSync)(SWARM_FILE, JSON.stringify(data, null, 2));
+        spinner.succeed(chalk_1.default.green(`Q-table exported to ${SWARM_FILE}`));
+        const entries = Object.keys(data.entries || {}).length;
+        console.log(chalk_1.default.gray(`  ${entries} states, ${data.stats?.totalUpdates || 0} updates`));
+    }
+    catch (err) {
+        spinner.fail(`Failed to export: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function swarmImport() {
+    const userId = getUserId();
+    if (!userId) {
+        console.log(chalk_1.default.red('Not authenticated. Run `ekkos init` first.'));
+        process.exit(1);
+    }
+    if (!(0, fs_1.existsSync)(SWARM_FILE)) {
+        console.log(chalk_1.default.red(`No Q-table file found at ${SWARM_FILE}`));
+        console.log(chalk_1.default.gray('  Run `ekkos swarm export` first, or place a q-learning-model.json in .swarm/'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)('Importing Q-table...').start();
+    try {
+        const raw = (0, fs_1.readFileSync)(SWARM_FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        const res = await fetch(`${PROXY_API_URL}/swarm/import/${userId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const result = await res.json();
+        spinner.succeed(chalk_1.default.green(`Imported ${result.imported} states into Q-table`));
+    }
+    catch (err) {
+        spinner.fail(`Failed to import: ${err.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Locate the ekkos-swarm Python app directory.
+ * Checks: EKKOS_SWARM_DIR env → monorepo relative paths.
+ */
+function findSwarmDir() {
+    // Env override
+    const envDir = process.env.EKKOS_SWARM_DIR;
+    if (envDir && (0, fs_1.existsSync)(envDir))
+        return envDir;
+    // Monorepo relative paths (from cwd or from CLI package)
+    const candidates = [
+        (0, path_1.join)(process.cwd(), 'apps', 'ekkos-swarm'),
+        (0, path_1.join)(__dirname, '..', '..', '..', '..', 'apps', 'ekkos-swarm'),
+    ];
+    for (const dir of candidates) {
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'cli', 'main.py')))
+            return dir;
+    }
+    return null;
+}
+/**
+ * Find Python3 inside the swarm venv.
+ */
+function findPythonPath(swarmDir) {
+    const venvPython = (0, path_1.join)(swarmDir, '.venv', 'bin', 'python3');
+    if ((0, fs_1.existsSync)(venvPython))
+        return venvPython;
+    return null;
+}
+/**
+ * Launch N parallel workers in a tmux session, each working on a subtask.
+ *
+ * Architecture:
+ * - Uses tmux WINDOWS (not panes) — compatible with Python Queen discovery
+ * - Window 0: Swarm Dashboard (blessed TUI showing all workers)
+ * - Windows 1-N: Workers running `ekkos run -b` (proxy + infinite context)
+ * - Each worker gets full ekkOS stack: proxy, hooks, ccDNA, context eviction
+ *
+ * Flow:
+ * 1. Decompose task via Gemini Flash (free, fast)
+ * 2. Create tmux session: dashboard window + N worker windows
+ * 3. Each worker window runs `ekkos run -b` (ekkOS CLI, not vanilla Claude)
+ * 4. Wait for Claude Code to initialize (PTY + proxy + hooks)
+ * 5. Send subtask to each worker via tmux send-keys
+ * 6. Start swarm dashboard in window 0
+ * 7. Attach to tmux session (dashboard is default view)
+ */
+async function swarmLaunch(options) {
+    const { workers, task, bypass = true, noDecompose = false, noQueen = false, verbose = false, queenStrategy, modelTiers, interactive = false, } = options;
+    const log = interactive ? (..._args) => { } : console.log;
+    // Validate
+    if (workers < 2 || workers > 8) {
+        log(chalk_1.default.red('Worker count must be between 2 and 8.'));
+        if (!interactive)
+            process.exit(1);
+        throw new Error('Worker count must be between 2 and 8');
+    }
+    if (!task || task.trim().length === 0) {
+        log(chalk_1.default.red('Task is required. Use --task "describe what to do"'));
+        if (!interactive)
+            process.exit(1);
+        throw new Error('Task is required');
+    }
+    // Check tmux
+    try {
+        (0, child_process_1.execSync)('which tmux', { stdio: 'pipe' });
+    }
+    catch {
+        log(chalk_1.default.red('tmux is required for swarm launch.'));
+        log(chalk_1.default.gray('  Install: brew install tmux'));
+        if (!interactive)
+            process.exit(1);
+        throw new Error('tmux is required');
+    }
+    log('');
+    log(chalk_1.default.cyan.bold('🐝 Swarm Launch'));
+    log(chalk_1.default.gray('─'.repeat(50)));
+    log(`  ${chalk_1.default.gray('Task:')}    ${chalk_1.default.white(task)}`);
+    log(`  ${chalk_1.default.gray('Workers:')} ${chalk_1.default.bold(String(workers))}`);
+    log('');
+    const cwd = process.cwd();
+    const ekkosCmd = process.argv[1];
+    const launchTs = Date.now();
+    // ── Step 1: Decompose task into subtasks ──────────────────────────────
+    let subtasks;
+    if (noDecompose) {
+        subtasks = Array.from({ length: workers }, (_, i) => `You are worker ${i + 1} of ${workers} in a parallel swarm. ` +
+            `Focus on your portion and avoid overlapping with other workers. ` +
+            `Task: ${task}`);
+        log(chalk_1.default.gray('  Skipping decomposition (--no-decompose)'));
+    }
+    else {
+        const spinner = interactive ? { start: () => spinner, succeed: (_m) => { }, fail: (_m) => { } } : (0, ora_1.default)('Decomposing task into subtasks...').start();
+        try {
+            const res = await fetch(`${PROXY_API_URL}/swarm/decompose`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    task,
+                    workerCount: workers,
+                    context: `Working directory: ${cwd}`,
+                }),
+            });
+            if (!res.ok) {
+                const errData = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+                throw new Error(errData.error || `HTTP ${res.status}`);
+            }
+            const data = await res.json();
+            subtasks = data.subtasks;
+            if (!subtasks || subtasks.length === 0) {
+                throw new Error('No subtasks returned');
+            }
+            spinner.succeed(chalk_1.default.green(`Decomposed into ${subtasks.length} subtasks`));
+            for (let i = 0; i < subtasks.length; i++) {
+                const color = [chalk_1.default.magenta, chalk_1.default.blue, chalk_1.default.green, chalk_1.default.yellow, chalk_1.default.cyan, chalk_1.default.red, chalk_1.default.white, chalk_1.default.gray][i % 8];
+                log(`  ${color(`Worker ${i + 1}:`)} ${subtasks[i].slice(0, 80)}${subtasks[i].length > 80 ? '...' : ''}`);
+            }
+            log('');
+        }
+        catch (err) {
+            spinner.fail(`Decomposition failed: ${err.message}`);
+            log(chalk_1.default.yellow('  Falling back to sending same task to all workers.'));
+            subtasks = Array.from({ length: workers }, (_, i) => `You are worker ${i + 1} of ${workers} in a parallel swarm. Task: ${task}`);
+        }
+    }
+    // ── Step 2: Create tmux session with windows ──────────────────────────
+    // Uses WINDOWS (not panes) — Queen discovers agents via `tmux list-windows`
+    const tmuxSession = `ekkos-swarm-${Date.now().toString(36)}`;
+    const runArgs = ['run'];
+    if (bypass)
+        runArgs.push('-b');
+    const runCommand = `node "${ekkosCmd}" ${runArgs.join(' ')}`;
+    const noopSpinner = { start: () => noopSpinner, succeed: (_m) => { }, fail: (_m) => { } };
+    const launchSpinner = interactive ? noopSpinner : (0, ora_1.default)('Creating swarm tmux session...').start();
+    try {
+        // Ensure .swarm directory
+        if (!(0, fs_1.existsSync)(SWARM_DIR))
+            (0, fs_1.mkdirSync)(SWARM_DIR, { recursive: true });
+        // Window 0: Dashboard (default view when attaching)
+        (0, child_process_1.execSync)(`tmux new-session -d -s "${tmuxSession}" -c "${cwd}" -n "dashboard"`, { stdio: 'pipe' });
+        // Configure tmux options
+        const tmuxOpts = [
+            'set-option -g mouse on',
+            'set-option -g history-limit 50000',
+            'set-option -g set-clipboard on',
+            'set-option -g allow-passthrough on',
+            'set-option -g mode-keys vi',
+            'set-option -g escape-time 0',
+            'set-option -g focus-events on',
+            'set-option -g default-terminal "xterm-256color"',
+        ];
+        for (const opt of tmuxOpts) {
+            try {
+                (0, child_process_1.execSync)(`tmux ${opt} -t "${tmuxSession}"`, { stdio: 'pipe' });
+            }
+            catch { }
+        }
+        // Worker windows: 1 through N (named worker-1, worker-2, etc.)
+        for (let i = 0; i < workers; i++) {
+            (0, child_process_1.execSync)(`tmux new-window -t "${tmuxSession}" -c "${cwd}" -n "worker-${i + 1}"`, { stdio: 'pipe' });
+        }
+        launchSpinner.succeed(chalk_1.default.green(`Created ${workers + 1} windows (dashboard + ${workers} workers)`));
+        // ── Step 3: Start ekkos run in each worker window ───────────────
+        const startSpinner = interactive ? noopSpinner : (0, ora_1.default)('Starting ekkos run in workers...').start();
+        for (let i = 0; i < workers; i++) {
+            // Pass model tier as env var per worker (if specified)
+            const tierEnv = modelTiers && modelTiers[i] ? `EKKOS_MODEL_TIER=${modelTiers[i]} ` : '';
+            const workerCmd = `${tierEnv}${runCommand}`;
+            (0, child_process_1.spawnSync)('tmux', ['send-keys', '-t', `${tmuxSession}:worker-${i + 1}`, workerCmd, 'Enter'], { stdio: 'pipe' });
+        }
+        startSpinner.succeed(chalk_1.default.green(`Started ${workers} ekkos instances (proxy + infinite context)`));
+        // ── Step 4: Write swarm metadata ────────────────────────────────
+        const metaPath = (0, path_1.join)(SWARM_DIR, 'active-swarm.json');
+        // queenEnabled is set later, but metadata is written here before queen launch.
+        // We'll update metadata after queen launch in step 6b.
+        const swarmMeta = {
+            tmuxSession,
+            workers,
+            task,
+            subtasks,
+            startedAt: new Date().toISOString(),
+            launchTs,
+            cwd,
+            queenEnabled: false,
+            queenStrategy: queenStrategy || 'adaptive-default',
+            modelTiers: modelTiers || [],
+        };
+        (0, fs_1.writeFileSync)(metaPath, JSON.stringify(swarmMeta, null, 2));
+        // ── Step 5: Wait for Claude Code to initialize ──────────────────
+        const waitSpinner = interactive ? noopSpinner : (0, ora_1.default)('Waiting for Claude Code to initialize (15s)...').start();
+        await new Promise(resolve => setTimeout(resolve, 15000));
+        waitSpinner.succeed(chalk_1.default.green('Workers initialized'));
+        // ── Step 6: Send subtasks to each worker ────────────────────────
+        const sendSpinner = interactive ? noopSpinner : (0, ora_1.default)('Sending subtasks to workers...').start();
+        for (let i = 0; i < workers; i++) {
+            const subtask = subtasks[i] || subtasks[subtasks.length - 1];
+            // Send text first, then Enter separately after a delay.
+            // Claude Code treats combined text+Enter from send-keys as a paste,
+            // which puts the text in the prompt but doesn't submit it.
+            const result = (0, child_process_1.spawnSync)('tmux', [
+                'send-keys', '-t', `${tmuxSession}:worker-${i + 1}`,
+                subtask,
+            ], { stdio: 'pipe' });
+            if (result.status !== 0) {
+                const errMsg = result.stderr?.toString().trim() || 'unknown error';
+                log(chalk_1.default.yellow(`  Warning: failed to send to worker-${i + 1}: ${errMsg}`));
+            }
+            else if (verbose) {
+                log(chalk_1.default.gray(`  Sent to worker-${i + 1}: ${subtask.slice(0, 60)}...`));
+            }
+        }
+        // Wait briefly for Claude Code to process the pasted text, then send Enter
+        await new Promise(resolve => setTimeout(resolve, 500));
+        for (let i = 0; i < workers; i++) {
+            (0, child_process_1.spawnSync)('tmux', [
+                'send-keys', '-t', `${tmuxSession}:worker-${i + 1}`,
+                'Enter',
+            ], { stdio: 'pipe' });
+        }
+        sendSpinner.succeed(chalk_1.default.green(`Dispatched ${workers} subtasks`));
+        // ── Step 6b: Start Python Queen coordinator ──────────────────────
+        let queenEnabled = false;
+        if (!noQueen) {
+            const swarmDir = findSwarmDir();
+            const pythonPath = swarmDir ? findPythonPath(swarmDir) : null;
+            if (swarmDir && pythonPath) {
+                try {
+                    (0, child_process_1.execSync)(`tmux new-window -t "${tmuxSession}" -c "${swarmDir}" -n "queen"`, { stdio: 'pipe' });
+                    const strategyEnv = queenStrategy ? `EKKOS_QUEEN_STRATEGY=${queenStrategy} ` : '';
+                    const metaEnv = `EKKOS_SWARM_META=${metaPath} `;
+                    const queenCmd = `${metaEnv}${strategyEnv}${pythonPath} -m cli.main start ${tmuxSession}`;
+                    (0, child_process_1.spawnSync)('tmux', ['send-keys', '-t', `${tmuxSession}:queen`, queenCmd, 'Enter'], { stdio: 'pipe' });
+                    queenEnabled = true;
+                    log(chalk_1.default.green('  👑 Queen coordinator started'));
+                }
+                catch (err) {
+                    log(chalk_1.default.yellow(`  ⚠ Queen window failed: ${err.message}`));
+                }
+            }
+            else {
+                const reason = !swarmDir ? 'apps/ekkos-swarm/ not found' : '.venv/bin/python3 not found';
+                log(chalk_1.default.yellow(`  ⚠ Skipping Queen (${reason})`));
+            }
+        }
+        // Update metadata with queen status
+        if (queenEnabled) {
+            swarmMeta.queenEnabled = true;
+            (0, fs_1.writeFileSync)(metaPath, JSON.stringify(swarmMeta, null, 2));
+        }
+        // ── Step 7: Start swarm dashboard in window 0 ───────────────────
+        const dashCmd = `node "${ekkosCmd}" swarm dashboard --launch-ts ${launchTs}`;
+        (0, child_process_1.spawnSync)('tmux', ['send-keys', '-t', `${tmuxSession}:dashboard`, dashCmd, 'Enter'], { stdio: 'pipe' });
+        log('');
+        log(chalk_1.default.cyan('  Attaching to swarm session...'));
+        log(chalk_1.default.gray('  Ctrl+B 0        Dashboard (overview)'));
+        log(chalk_1.default.gray('  Ctrl+B 1-N      Worker windows'));
+        if (queenEnabled) {
+            log(chalk_1.default.gray(`  Ctrl+B ${workers + 1}        Queen coordinator`));
+        }
+        log(chalk_1.default.gray('  Ctrl+B N/P      Next/prev window'));
+        log(chalk_1.default.gray('  Ctrl+B D        Detach (workers keep running)'));
+        log('');
+        // ── Step 8: Attach to tmux session (dashboard is window 0) ──────
+        (0, child_process_1.execSync)(`tmux select-window -t "${tmuxSession}:dashboard"`, { stdio: 'pipe' });
+        // In interactive mode, return the session name so the wizard can attach
+        if (interactive) {
+            return tmuxSession;
+        }
+        (0, child_process_1.execSync)(`tmux attach -t "${tmuxSession}"`, { stdio: 'inherit' });
+    }
+    catch (err) {
+        if (interactive)
+            throw err;
+        launchSpinner.fail(`Swarm launch failed: ${err.message}`);
+        try {
+            (0, child_process_1.execSync)(`tmux kill-session -t "${tmuxSession}"`, { stdio: 'pipe' });
+        }
+        catch { }
+        process.exit(1);
+    }
+}

package/dist/commands/test-claude.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ekkos test-claude — Bare proxy test (no CLI wrapper)
+ *
+ * Launches vanilla Claude Code with ONLY the proxy URL set.
+ * No ccDNA, no PTY wrapper, no injection, no context management.
+ *
+ * Purpose: Isolate whether fast context growth is caused by:
+ *   A) The proxy (IPC, injections, tool compression)
+ *   B) The ekkos CLI wrapper (ccDNA, PTY, run.ts logic)
+ */
+export interface TestClaudeOptions {
+    noProxy?: boolean;
+    noHooks?: boolean;
+    verbose?: boolean;
+}
+export declare function testClaude(options: TestClaudeOptions): Promise<void>;

package/dist/commands/test-claude.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * ekkos test-claude — Bare proxy test (no CLI wrapper)
+ *
+ * Launches vanilla Claude Code with ONLY the proxy URL set.
+ * No ccDNA, no PTY wrapper, no injection, no context management.
+ *
+ * Purpose: Isolate whether fast context growth is caused by:
+ *   A) The proxy (IPC, injections, tool compression)
+ *   B) The ekkos CLI wrapper (ccDNA, PTY, run.ts logic)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testClaude = testClaude;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const state_1 = require("../utils/state");
+const EKKOS_PROXY_URL = 'https://proxy.ekkos.dev';
+async function testClaude(options) {
+    const verbose = options.verbose || false;
+    console.log(chalk_1.default.cyan('\n  ekkOS test-claude — Bare Proxy Test'));
+    console.log(chalk_1.default.gray('  ══════════════════════════════════'));
+    console.log(chalk_1.default.green('  Proxy:    ') + (options.noProxy ? chalk_1.default.yellow('NO') : chalk_1.default.green('YES')));
+    console.log(chalk_1.default.green('  CLI:      ') + chalk_1.default.yellow('NO  (no ccDNA, no PTY, no inject)'));
+    console.log(chalk_1.default.green('  Hooks:    ') + (options.noHooks ? chalk_1.default.yellow('NO  (disabled)') : chalk_1.default.gray('YES (same .claude/hooks/)')));
+    console.log('');
+    // Resolve Claude path
+    const claudePath = resolveClaudePath();
+    if (!claudePath) {
+        console.error(chalk_1.default.red('  Claude Code not found. Install with: npm install -g @anthropic-ai/claude-code'));
+        process.exit(1);
+    }
+    // Build env — only set ANTHROPIC_BASE_URL if proxy mode
+    /* eslint-disable no-restricted-syntax */
+    const env = { ...process.env };
+    /* eslint-enable no-restricted-syntax */
+    if (!options.noProxy) {
+        const ekkosConfig = (0, state_1.getConfig)();
+        const userId = ekkosConfig?.userId || 'anonymous';
+        const projectPath = process.cwd();
+        const projectPathEncoded = Buffer.from(projectPath).toString('base64url');
+        const proxyUrl = `${EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/_pending?project=${projectPathEncoded}`;
+        env.ANTHROPIC_BASE_URL = proxyUrl;
+        console.log(chalk_1.default.gray(`  Proxy URL: ${proxyUrl.replace(userId, userId.slice(0, 8) + '...')}`));
+    }
+    else {
+        console.log(chalk_1.default.gray('  Direct to Anthropic (no proxy)'));
+    }
+    console.log(chalk_1.default.gray(`  Claude:   ${claudePath}`));
+    console.log('');
+    // Disable hooks by temporarily renaming the hooks directory
+    const hooksDir = path.join(os.homedir(), '.claude', 'hooks');
+    const hooksBackup = path.join(os.homedir(), '.claude', 'hooks.bak-test');
+    let hooksDisabled = false;
+    if (options.noHooks && fs.existsSync(hooksDir) && !fs.existsSync(hooksBackup)) {
+        fs.renameSync(hooksDir, hooksBackup);
+        hooksDisabled = true;
+        console.log(chalk_1.default.gray('  Hooks temporarily disabled (renamed to hooks.bak-test)'));
+    }
+    // Also disable project-level hooks
+    const projectHooksDir = path.join(process.cwd(), '.claude', 'hooks');
+    const projectHooksBackup = path.join(process.cwd(), '.claude', 'hooks.bak-test');
+    let projectHooksDisabled = false;
+    if (options.noHooks && fs.existsSync(projectHooksDir) && !fs.existsSync(projectHooksBackup)) {
+        fs.renameSync(projectHooksDir, projectHooksBackup);
+        projectHooksDisabled = true;
+        console.log(chalk_1.default.gray('  Project hooks temporarily disabled'));
+    }
+    // Restore hooks on exit (always, even on crash)
+    const restoreHooks = () => {
+        if (hooksDisabled && fs.existsSync(hooksBackup)) {
+            try {
+                fs.renameSync(hooksBackup, hooksDir);
+            }
+            catch { /* ignore */ }
+        }
+        if (projectHooksDisabled && fs.existsSync(projectHooksBackup)) {
+            try {
+                fs.renameSync(projectHooksBackup, projectHooksDir);
+            }
+            catch { /* ignore */ }
+        }
+    };
+    process.on('SIGINT', restoreHooks);
+    process.on('SIGTERM', restoreHooks);
+    process.on('exit', restoreHooks);
+    console.log('');
+    // Spawn Claude directly — no PTY, no wrapper, just exec
+    const child = (0, child_process_1.spawn)(claudePath, [], {
+        env,
+        stdio: 'inherit',
+        cwd: process.cwd(),
+    });
+    child.on('exit', (code) => {
+        restoreHooks();
+        process.exit(code || 0);
+    });
+    child.on('error', (err) => {
+        restoreHooks();
+        console.error(chalk_1.default.red(`Failed to start Claude: ${err.message}`));
+        process.exit(1);
+    });
+}
+function resolveClaudePath() {
+    // 1. ekkOS managed installation
+    const ekkosClaudeBin = path.join(os.homedir(), '.ekkos', 'claude-code', 'node_modules', '.bin', 'claude');
+    if (fs.existsSync(ekkosClaudeBin))
+        return ekkosClaudeBin;
+    // 2. Homebrew
+    try {
+        const brewPath = (0, child_process_1.execSync)('which claude', { encoding: 'utf-8' }).trim();
+        if (brewPath && fs.existsSync(brewPath))
+            return brewPath;
+    }
+    catch { /* ignore */ }
+    // 3. npx fallback
+    return 'npx';
+}

package/dist/commands/usage/blocks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ekkos usage blocks [--json]
+ *
+ * Show 5-hour billing block analysis
+ */
+export declare function blocksCommand(options: {
+    json?: boolean;
+}): Promise<void>;