helix-assistant-cli 0.2.13 → 0.6.0

package/README.md

@@ -0,0 +1,25 @@
+# HELIX CLI
+
+Interactive terminal client for the local HELIX agent.
+
+```powershell
+npx helix-assistant-cli
+```
+
+The CLI requires a reachable HELIX agent and a configured model provider for
+AI-backed requests.
+
+## Subagents
+
+- `/subagents` displays the ASCII profile/status panel.
+- `/subagents chat <profile_id> <message>` sends a direct message to a profile.
+
+## Browser snapshots
+
+- `/browser open <url>` asks the agent to open a page.
+- `/browser live on` enables the ASCII snapshot viewer; `/browser live off`
+  disables it.
+
+Frames are JPEG snapshots emitted after successful browser actions, not a
+continuous video stream. Browser-frame routing is limited to the requesting
+conversation.

package/dist/client/agent-launcher.d.ts

@@ -16,10 +16,6 @@ export declare function probePort(port: number, host?: string, timeoutMs?: numbe
  *   'closed': Connection refused / port closed
  */
 export declare function probeWebSocketAuth(port?: number, token?: string, host?: string, timeoutMs?: number): Promise<'ready' | 'unauthorized' | 'closed'>;
-/**
- * Terminates any rogue or orphaned process occupying the specified port.
- */
-export declare function killProcessOnPort(port?: number): void;
 /**
  * Waits until the agent service has completed startup and successfully accepts WebSocket authentication.
  */

package/dist/client/agent-launcher.js

@@ -11,7 +11,6 @@ exports.findPythonAgentScript = findPythonAgentScript;
 exports.findPythonExecutable = findPythonExecutable;
 exports.probePort = probePort;
 exports.probeWebSocketAuth = probeWebSocketAuth;
-exports.killProcessOnPort = killProcessOnPort;
 exports.waitForAgentReady = waitForAgentReady;
 exports.spawnAgentDaemon = spawnAgentDaemon;
 const child_process_1 = require("child_process");
@@ -231,24 +230,6 @@ function probeWebSocketAuth(port = 8765, token, host = '127.0.0.1', timeoutMs =
         });
     });
 }
-/**
- * Terminates any rogue or orphaned process occupying the specified port.
- */
-function killProcessOnPort(port = 8765) {
-    try {
-        if (process.platform === 'win32') {
-            (0, child_process_1.execSync)(`powershell -NoProfile -Command "$conn = Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue; if ($conn) { Stop-Process -Id $conn.OwningProcess -Force -ErrorAction SilentlyContinue }"`, { stdio: 'ignore', windowsHide: true });
-        }
-        else {
-            (0, child_process_1.execSync)(`fuser -k ${port}/tcp || lsof -ti tcp:${port} | xargs kill -9`, {
-                stdio: 'ignore',
-            });
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-}
 /**
  * Waits until the agent service has completed startup and successfully accepts WebSocket authentication.
  */
@@ -289,10 +270,11 @@ async function spawnAgentDaemon(port = 8765) {
     if (currentStatus === 'ready') {
         return { success: true };
     }
-    // 2. If port is occupied by an unauthorized process, clean it up
     if (currentStatus === 'unauthorized') {
-        killProcessOnPort(port);
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        return {
+            success: false,
+            error: `El puerto ${port} ya lo usa un agente HELIX que requiere otro token. Cierra esa instancia o inicia el CLI con --token.`,
+        };
     }
     if (isAgentProcessRunning() || isAgentStarting()) {
         return { success: true };
@@ -310,7 +292,7 @@ async function spawnAgentDaemon(port = 8765) {
     try {
         const child = (0, child_process_1.spawn)(pythonExec, ['main.py', '--ws-port', String(port), '--no-camera'], {
             cwd: agentDir,
-            detached: true,
+            detached: process.platform !== 'win32',
             stdio: 'ignore', // run completely in background
             windowsHide: true,
             env: {

package/dist/commands/browser.js

@@ -12,7 +12,7 @@ async function handleBrowserCommand(client, args) {
     const targetUrl = parts[1];
     if (subCommand === 'open' && targetUrl) {
         console.log((0, colors_1.CYAN)(`\n  Solicitando al agente abrir en navegador: ${targetUrl}...`));
-        client.sendUserText(`Por favor abre la siguiente URL en el navegador: ${targetUrl}`, `browser_${Date.now()}`);
+        client.sendUserText(`Por favor abre la siguiente URL en el navegador: ${targetUrl}`, `cli_browser_${Date.now()}`);
         console.log((0, colors_1.GREEN)(`  ✔ Comando enviado al agente.\n`));
         return;
     }
@@ -27,7 +27,8 @@ async function handleBrowserCommand(client, args) {
         console.log(`  Dominios:    ${settings.block_untrusted_domains ? (0, colors_1.YELLOW)('Filtrado Estricto') : (0, colors_1.GRAY)('Abierto')}`);
         console.log(`\n  ${(0, colors_1.DIM)('Comandos disponibles:')}`);
         console.log(`    ${(0, colors_1.CYAN)('/browser')}              ${(0, colors_1.DIM)('- Ver estado de navegación')}`);
-        console.log(`    ${(0, colors_1.CYAN)('/browser open <url>')}   ${(0, colors_1.DIM)('- Abrir URL con el agente')}\n`);
+        console.log(`    ${(0, colors_1.CYAN)('/browser open <url>')}   ${(0, colors_1.DIM)('- Abrir URL con el agente')}`);
+        console.log(`    ${(0, colors_1.CYAN)('/browser live [on|off]')} ${(0, colors_1.DIM)('- Alternar la vista ASCII de capturas')}\n`);
     }
     catch (err) {
         console.log((0, colors_1.RED)(`  Error al consultar estado del navegador: ${err.message}\n`));

package/dist/commands/memory.d.ts

@@ -0,0 +1,6 @@
+import type { AgentClient } from '../client/agent-client';
+export declare function handleMemoryStats(client: AgentClient): Promise<void>;
+export declare function handleMemoryRules(client: AgentClient): Promise<void>;
+export declare function handleMemoryReset(client: AgentClient): Promise<void>;
+/** Top-level dispatcher for /memory <args> */
+export declare function handleMemoryCommand(client: AgentClient, args: string): Promise<void>;

package/dist/commands/memory.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMemoryStats = handleMemoryStats;
+exports.handleMemoryRules = handleMemoryRules;
+exports.handleMemoryReset = handleMemoryReset;
+exports.handleMemoryCommand = handleMemoryCommand;
+/**
+ * /memory — CLI command for inspecting the Adaptive Learning Harness.
+ *
+ * Subcommands:
+ *   /memory           — show quick stats summary
+ *   /memory stats     — detailed episode + rule counts
+ *   /memory rules     — list top learned rules
+ *   /memory reset     — run maintenance / pruning cycle
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+async function fetchLearningStats(client) {
+    try {
+        return await client.request('GET_LEARNING_STATS', {});
+    }
+    catch {
+        return null;
+    }
+}
+// ── Renderers ─────────────────────────────────────────────────────────────────
+function renderStats(stats) {
+    console.log('');
+    console.log(`  ${chalk_1.default.hex('#FF8C00').bold('⬡ Sistema de Aprendizaje Adaptativo')}`);
+    console.log(`  ${chalk_1.default.gray('─'.repeat(48))}`);
+    const ep = stats.episode_count;
+    const ru = stats.rule_count;
+    const co = stats.correction_count;
+    const sk = stats.skill_count;
+    console.log(`  ${chalk_1.default.gray('Episodios registrados')}   ${chalk_1.default.white.bold(ep.toString())}`);
+    console.log(`  ${chalk_1.default.gray('Correcciones del usuario')} ${co > 0 ? chalk_1.default.yellow.bold(co.toString()) : chalk_1.default.white(co.toString())}`);
+    console.log(`  ${chalk_1.default.gray('Reglas aprendidas')}       ${chalk_1.default.cyan.bold(ru.toString())}`);
+    console.log(`  ${chalk_1.default.gray('Skills auto-generadas')}   ${chalk_1.default.magenta.bold(sk.toString())}`);
+    if (stats.last_episode_at) {
+        const d = new Date(stats.last_episode_at);
+        console.log(`  ${chalk_1.default.gray('Último episodio')}         ${(0, colors_1.DIM)(d.toLocaleString())}`);
+    }
+    const userMdStatus = stats.user_md_exists
+        ? chalk_1.default.green('✔ USER.md activo')
+        : chalk_1.default.gray('○ Sin perfil generado aún');
+    console.log(`  ${chalk_1.default.gray('Perfil feedforward')}      ${userMdStatus}`);
+    console.log('');
+}
+function renderRules(stats) {
+    if (!stats.top_rules || stats.top_rules.length === 0) {
+        console.log((0, colors_1.GRAY)('  No hay reglas aprendidas todavía. Interactúa con HELIX para que aprenda tus preferencias.\n'));
+        return;
+    }
+    console.log('');
+    console.log(`  ${chalk_1.default.hex('#FF8C00').bold(`✦ Top ${stats.top_rules.length} Reglas Aprendidas`)}`);
+    console.log(`  ${chalk_1.default.gray('─'.repeat(56))}`);
+    for (const rule of stats.top_rules) {
+        const conf = Math.round(rule.confidence * 100);
+        const bar = '█'.repeat(Math.min(10, Math.floor(conf / 10)));
+        const confColor = conf >= 80 ? chalk_1.default.green : conf >= 50 ? chalk_1.default.yellow : chalk_1.default.gray;
+        console.log(`  ${chalk_1.default.cyan(`[${rule.category}]`).padEnd(24)} ${chalk_1.default.white(rule.rule)}`);
+        console.log(`    ${(0, colors_1.DIM)('Confianza:')} ${confColor(`${conf}%`)} ${chalk_1.default.gray(bar)}  ${(0, colors_1.DIM)(`(${rule.uses} usos)`)}`);
+        console.log('');
+    }
+}
+// ── Command handlers ──────────────────────────────────────────────────────────
+async function handleMemoryStats(client) {
+    const stats = await fetchLearningStats(client);
+    if (!stats) {
+        console.log((0, colors_1.YELLOW)('  ⚠ El harness de aprendizaje no está disponible (agente desconectado o versión antigua).\n'));
+        return;
+    }
+    renderStats(stats);
+    if (stats.top_rules?.length) {
+        console.log((0, colors_1.DIM)('  Usa /memory rules para ver las reglas detalladas.'));
+        console.log('');
+    }
+}
+async function handleMemoryRules(client) {
+    const stats = await fetchLearningStats(client);
+    if (!stats) {
+        console.log((0, colors_1.YELLOW)('  ⚠ El harness de aprendizaje no está disponible.\n'));
+        return;
+    }
+    renderStats(stats);
+    renderRules(stats);
+}
+async function handleMemoryReset(client) {
+    try {
+        const result = await client.request('RUN_LEARNING_MAINTENANCE', {});
+        console.log('');
+        console.log((0, colors_1.GREEN)('  ✔ Mantenimiento del harness completado.'));
+        console.log(`  ${chalk_1.default.gray('Reglas podadas:')}  ${chalk_1.default.white.bold(String(result.pruned_rules_count ?? 0))}`);
+        const pruned = result.pruned_skills ?? [];
+        if (pruned.length) {
+            console.log(`  ${chalk_1.default.gray('Skills podadas:')} ${chalk_1.default.white(pruned.join(', '))}`);
+        }
+        else {
+            console.log(`  ${chalk_1.default.gray('Skills podadas:')} ${(0, colors_1.DIM)('ninguna')}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  ✖ Error durante mantenimiento: ${err.message}\n`));
+    }
+}
+/** Top-level dispatcher for /memory <args> */
+async function handleMemoryCommand(client, args) {
+    const sub = args.trim().split(/\s+/)[0]?.toLowerCase() || '';
+    switch (sub) {
+        case '':
+        case 'stats':
+            await handleMemoryStats(client);
+            break;
+        case 'rules':
+            await handleMemoryRules(client);
+            break;
+        case 'reset':
+        case 'maintenance':
+        case 'prune':
+            await handleMemoryReset(client);
+            break;
+        default:
+            console.log((0, colors_1.YELLOW)(`  Subcomando desconocido: "${sub}". Opciones: stats, rules, reset\n`));
+    }
+}

package/dist/commands/model.d.ts

@@ -0,0 +1,24 @@
+import type { AgentClient } from '../client/agent-client';
+export interface ModelEntry {
+    id: string;
+    label: string;
+    tier: 'free' | 'local' | 'cloud';
+    provider: string;
+    badge?: string;
+}
+export declare const FREE_MODELS: ModelEntry[];
+export declare const LOCAL_MODELS: ModelEntry[];
+export declare const CLOUD_MODELS: ModelEntry[];
+export declare const ALL_MODELS: ModelEntry[];
+/** /model — show current model */
+export declare function handleModelStatus(client: AgentClient): Promise<void>;
+/** /model list — print the full model catalog */
+export declare function handleModelList(): void;
+/** /model set <id> — switch the active model */
+export declare function handleModelSet(client: AgentClient, modelId: string): Promise<void>;
+/** /model effort <low|medium|high> — set effort/quality level */
+export declare function handleModelEffort(client: AgentClient, level: string): Promise<void>;
+/** /model free-list — list free models fetched from bridge (live) */
+export declare function handleFreeModelList(client: AgentClient): Promise<void>;
+/** Top-level dispatcher for /model <args> */
+export declare function handleModelCommand(client: AgentClient, args: string): Promise<void>;

package/dist/commands/model.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_MODELS = exports.CLOUD_MODELS = exports.LOCAL_MODELS = exports.FREE_MODELS = void 0;
+exports.handleModelStatus = handleModelStatus;
+exports.handleModelList = handleModelList;
+exports.handleModelSet = handleModelSet;
+exports.handleModelEffort = handleModelEffort;
+exports.handleFreeModelList = handleFreeModelList;
+exports.handleModelCommand = handleModelCommand;
+/**
+ * /model — CLI command for viewing and switching the active AI model.
+ *
+ * Subcommands:
+ *   /model            — show current model + provider
+ *   /model list       — list all model tiers (Free, Local Ollama, Cloud)
+ *   /model set <id>   — switch to a model by id
+ *   /model effort <low|medium|high> — set effort/quality level
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+exports.FREE_MODELS = [
+    {
+        id: 'meta-llama/llama-3.2-3b-instruct:free',
+        label: 'Llama 3.2 3B Instruct',
+        tier: 'free',
+        provider: 'free',
+        badge: '0-cost',
+    },
+    {
+        id: 'qwen/qwen-2.5-coder-32b-instruct:free',
+        label: 'Qwen 2.5 Coder 32B',
+        tier: 'free',
+        provider: 'free',
+        badge: '0-cost',
+    },
+    {
+        id: 'deepseek/deepseek-r1:free',
+        label: 'DeepSeek R1',
+        tier: 'free',
+        provider: 'free',
+        badge: '0-cost · razonamiento',
+    },
+    {
+        id: 'google/gemini-flash-1.5:free',
+        label: 'Gemini Flash 1.5',
+        tier: 'free',
+        provider: 'free',
+        badge: '0-cost · rápido',
+    },
+];
+exports.LOCAL_MODELS = [
+    { id: 'ollama/llama3', label: 'Llama 3 (local)', tier: 'local', provider: 'ollama' },
+    { id: 'ollama/mistral', label: 'Mistral 7B (local)', tier: 'local', provider: 'ollama' },
+    { id: 'ollama/deepseek-coder', label: 'DeepSeek Coder (local)', tier: 'local', provider: 'ollama' },
+    { id: 'ollama/phi3', label: 'Phi-3 Mini (local)', tier: 'local', provider: 'ollama' },
+    { id: 'ollama/qwen2.5-coder', label: 'Qwen 2.5 Coder (local)', tier: 'local', provider: 'ollama' },
+];
+exports.CLOUD_MODELS = [
+    { id: 'gpt-4o', label: 'GPT-4o', tier: 'cloud', provider: 'openai' },
+    { id: 'gpt-4o-mini', label: 'GPT-4o Mini', tier: 'cloud', provider: 'openai' },
+    { id: 'claude-3-5-sonnet-20241022', label: 'Claude 3.5 Sonnet', tier: 'cloud', provider: 'anthropic' },
+    { id: 'claude-3-haiku-20240307', label: 'Claude 3 Haiku', tier: 'cloud', provider: 'anthropic' },
+    { id: 'gemini-1.5-pro', label: 'Gemini 1.5 Pro', tier: 'cloud', provider: 'gemini' },
+    { id: 'gemini-1.5-flash', label: 'Gemini 1.5 Flash', tier: 'cloud', provider: 'gemini' },
+];
+exports.ALL_MODELS = [...exports.FREE_MODELS, ...exports.LOCAL_MODELS, ...exports.CLOUD_MODELS];
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function providerBadge(entry) {
+    if (entry.tier === 'free')
+        return chalk_1.default.green.bold('[0-COST]');
+    if (entry.tier === 'local')
+        return chalk_1.default.cyan.bold('[LOCAL]');
+    return chalk_1.default.yellow.bold('[CLOUD]');
+}
+function findModel(id) {
+    return exports.ALL_MODELS.find((m) => m.id === id || m.id.startsWith(id));
+}
+// ── Command handlers ──────────────────────────────────────────────────────────
+/** /model — show current model */
+async function handleModelStatus(client) {
+    try {
+        const settings = await client.getSettings();
+        const modelId = settings.default_model || '(none)';
+        const provider = settings.preferred_provider || '(none)';
+        const entry = findModel(modelId);
+        console.log('');
+        console.log(`  ${chalk_1.default.hex('#FF8C00').bold('⬡ Modelo Activo')}`);
+        console.log(`  ${chalk_1.default.gray('─'.repeat(44))}`);
+        console.log(`  ${chalk_1.default.gray('ID')}           ${chalk_1.default.white.bold(modelId)}`);
+        console.log(`  ${chalk_1.default.gray('Proveedor')}    ${chalk_1.default.white(provider)}`);
+        if (entry) {
+            console.log(`  ${chalk_1.default.gray('Nombre')}       ${entry.label}`);
+            console.log(`  ${chalk_1.default.gray('Nivel')}        ${providerBadge(entry)} ${entry.badge ? (0, colors_1.DIM)(`(${entry.badge})`) : ''}`);
+        }
+        const speed = settings.speed_preference || 'balanced';
+        const quality = settings.quality_preference || 'balanced';
+        console.log(`  ${chalk_1.default.gray('Velocidad')}    ${chalk_1.default.cyan(speed)}`);
+        console.log(`  ${chalk_1.default.gray('Calidad')}      ${chalk_1.default.cyan(quality)}`);
+        console.log('');
+        console.log((0, colors_1.DIM)('  Usa /model list para ver opciones, /model set <id> para cambiar.'));
+        console.log('');
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  Error al obtener modelo: ${err.message}\n`));
+    }
+}
+/** /model list — print the full model catalog */
+function handleModelList() {
+    const printSection = (title, models) => {
+        console.log(`\n  ${chalk_1.default.hex('#FF8C00').bold(title)}`);
+        console.log(`  ${chalk_1.default.gray('─'.repeat(60))}`);
+        for (const m of models) {
+            const badge = providerBadge(m);
+            const extra = m.badge ? (0, colors_1.DIM)(` · ${m.badge}`) : '';
+            console.log(`  ${badge}  ${chalk_1.default.white.bold(m.label.padEnd(32))} ${(0, colors_1.GRAY)(m.id)}${extra}`);
+        }
+    };
+    console.log('');
+    console.log(`  ${(0, colors_1.BOLD)('🧠 Catálogo de Modelos HELIX')}`);
+    printSection('✦ Nivel 1 — Sin costo (OpenRouter Free)', exports.FREE_MODELS);
+    printSection('✦ Nivel 2 — Local Ollama (sin internet)', exports.LOCAL_MODELS);
+    printSection('✦ Nivel 3 — Nube con API Key propia', exports.CLOUD_MODELS);
+    console.log('');
+    console.log((0, colors_1.DIM)('  Usa: /model set <model-id>   para activar un modelo'));
+    console.log((0, colors_1.DIM)('  Usa: /model effort <low|medium|high>   para ajustar esfuerzo'));
+    console.log('');
+}
+/** /model set <id> — switch the active model */
+async function handleModelSet(client, modelId) {
+    if (!modelId) {
+        console.log((0, colors_1.YELLOW)('  Uso: /model set <model-id>\n'));
+        return;
+    }
+    const entry = findModel(modelId);
+    const provider = entry?.provider || (modelId.startsWith('ollama/') ? 'ollama' : 'openai');
+    try {
+        await client.saveSettings({
+            default_model: entry?.id ?? modelId,
+            preferred_provider: provider,
+        });
+        const badge = entry ? providerBadge(entry) : '';
+        console.log('');
+        console.log((0, colors_1.GREEN)('  ✔ Modelo actualizado correctamente.'));
+        console.log(`  ${chalk_1.default.gray('Modelo:')}    ${chalk_1.default.white.bold(entry?.id ?? modelId)} ${badge}`);
+        console.log(`  ${chalk_1.default.gray('Proveedor:')} ${chalk_1.default.white(provider)}`);
+        console.log('');
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  ✖ Error al cambiar modelo: ${err.message}\n`));
+    }
+}
+/** /model effort <low|medium|high> — set effort/quality level */
+async function handleModelEffort(client, level) {
+    const valid = ['low', 'medium', 'high'];
+    const normalized = level?.toLowerCase();
+    if (!normalized || !valid.includes(normalized)) {
+        console.log((0, colors_1.YELLOW)('  Uso: /model effort <low|medium|high>\n'));
+        return;
+    }
+    const speedMap = { low: 'fast', medium: 'balanced', high: 'balanced' };
+    const qualityMap = { low: 'fast', medium: 'balanced', high: 'best' };
+    try {
+        await client.saveSettings({
+            speed_preference: speedMap[normalized],
+            quality_preference: qualityMap[normalized],
+        });
+        console.log('');
+        console.log((0, colors_1.GREEN)(`  ✔ Nivel de esfuerzo → ${chalk_1.default.white.bold(normalized.toUpperCase())}`));
+        console.log((0, colors_1.DIM)(`  Velocidad: ${speedMap[normalized]}  |  Calidad: ${qualityMap[normalized]}`));
+        console.log('');
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  ✖ Error al ajustar esfuerzo: ${err.message}\n`));
+    }
+}
+/** /model free-list — list free models fetched from bridge (live) */
+async function handleFreeModelList(client) {
+    try {
+        const result = await client
+            .request('LIST_FREE_MODELS', {});
+        if (!result?.models?.length) {
+            // Fallback to static catalog
+            handleModelList();
+            return;
+        }
+        console.log(`\n  ${(0, colors_1.BOLD)('✦ Modelos gratuitos disponibles (live):')} \n`);
+        for (const m of result.models) {
+            console.log(`  ${(0, colors_1.GREEN)('[0-COST]')}  ${chalk_1.default.white.bold(m.label)}  ${(0, colors_1.GRAY)(m.id)}`);
+        }
+        console.log('');
+    }
+    catch {
+        // Agent not connected or handler not present — fall back to static
+        handleModelList();
+    }
+}
+/** Top-level dispatcher for /model <args> */
+async function handleModelCommand(client, args) {
+    const parts = args.trim().split(/\s+/);
+    const sub = parts[0]?.toLowerCase() || '';
+    switch (sub) {
+        case '':
+            await handleModelStatus(client);
+            break;
+        case 'list':
+            handleModelList();
+            break;
+        case 'set':
+            await handleModelSet(client, parts.slice(1).join(' '));
+            break;
+        case 'effort':
+            await handleModelEffort(client, parts[1] || '');
+            break;
+        default:
+            console.log((0, colors_1.YELLOW)(`  Subcomando desconocido: "${sub}". Opciones: list, set, effort\n`));
+    }
+}

package/dist/commands/subagents.d.ts

@@ -0,0 +1,15 @@
+import type { AgentClient } from '../client/agent-client';
+interface SubagentProfile {
+    profile_id: string;
+    name: string;
+}
+interface SubagentStatus {
+    profile_id?: string;
+    name?: string;
+    status?: string;
+    progress?: number;
+    current_action?: string;
+}
+export declare function renderSubagentPanel(profiles: SubagentProfile[], statuses: SubagentStatus[]): string;
+export declare function handleSubagentsCommand(client: AgentClient, args?: string): Promise<void>;
+export {};

package/dist/commands/subagents.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSubagentPanel = renderSubagentPanel;
+exports.handleSubagentsCommand = handleSubagentsCommand;
+const colors_1 = require("../ui/colors");
+function boundedText(value, maxLength) {
+    if (typeof value !== 'string')
+        return '';
+    const clean = value.replace(/[\r\n|]/g, ' ').trim();
+    return clean.length > maxLength ? `${clean.slice(0, maxLength - 3)}...` : clean;
+}
+function statusLabel(status) {
+    const normalized = status?.toLowerCase() || 'idle';
+    if (['running', 'active', 'in_progress'].includes(normalized))
+        return 'RUNNING';
+    if (['failed', 'error'].includes(normalized))
+        return 'FAILED';
+    if (['completed', 'done'].includes(normalized))
+        return 'DONE';
+    if (['cancelled', 'canceled'].includes(normalized))
+        return 'STOPPED';
+    return 'IDLE';
+}
+function renderSubagentPanel(profiles, statuses) {
+    const statusByProfile = new Map();
+    for (const status of statuses) {
+        if (status.profile_id)
+            statusByProfile.set(status.profile_id, status);
+    }
+    const rows = profiles.map((profile) => {
+        const status = statusByProfile.get(profile.profile_id);
+        const profileId = boundedText(profile.profile_id, 22);
+        const name = boundedText(profile.name, 18);
+        const state = statusLabel(status?.status);
+        const progress = Number.isFinite(status?.progress) ? ` ${status?.progress}%` : '';
+        const action = boundedText(status?.current_action, 26);
+        return [
+            profileId.padEnd(22),
+            name.padEnd(18),
+            `${state}${progress}`,
+            action,
+        ];
+    });
+    const headings = ['PROFILE ID', 'NAME', 'STATE', 'CURRENT ACTION'];
+    const widths = [22, 18, 16, 26];
+    const border = `+${widths.map((width) => '-'.repeat(width + 2)).join('+')}+`;
+    const row = (values) => `| ${values.map((value, index) => value.padEnd(widths[index])).join(' | ')} |`;
+    const lines = [
+        border,
+        row(headings),
+        border,
+        ...(rows.length > 0
+            ? rows.map(row)
+            : [row(['No profiles', 'available', '', ''])]),
+        border,
+    ];
+    return lines.join('\n');
+}
+function asArray(value, label, isItem) {
+    if (!Array.isArray(value) || !value.every(isItem)) {
+        throw new Error(`Agent returned an invalid ${label} list.`);
+    }
+    return value;
+}
+function isSubagentProfile(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const profile = value;
+    return typeof profile.profile_id === 'string'
+        && typeof profile.name === 'string';
+}
+function isSubagentStatus(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const status = value;
+    return (status.profile_id === undefined || typeof status.profile_id === 'string')
+        && (status.status === undefined || typeof status.status === 'string')
+        && (status.progress === undefined || typeof status.progress === 'number')
+        && (status.current_action === undefined || typeof status.current_action === 'string');
+}
+async function handleSubagentsCommand(client, args = '') {
+    const trimmed = args.trim();
+    const chatMatch = trimmed.match(/^chat\s+(\S+)\s+([\s\S]+)$/i);
+    if (chatMatch) {
+        const [, profileId, message] = chatMatch;
+        try {
+            const result = await client.request('CHAT_SUBAGENT', { profile_id: profileId, message: message.trim() }, 120000);
+            console.log('\n' + (0, colors_1.CYAN_BOLD)(`  SUBAGENT ${profileId}`));
+            if (result !== null
+                && typeof result === 'object'
+                && 'response' in result
+                && typeof result.response === 'string') {
+                console.log(result.response);
+            }
+            else {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            console.log('');
+        }
+        catch (error) {
+            console.log((0, colors_1.RED)(`  No se pudo contactar al subagente: ${error.message}\n`));
+        }
+        return;
+    }
+    if (trimmed && !/^list$/i.test(trimmed)) {
+        console.log((0, colors_1.YELLOW)('  Uso: /subagents [list] | /subagents chat <id> <mensaje>\n'));
+        return;
+    }
+    try {
+        const [profilesValue, statusesValue] = await Promise.all([
+            client.request('GET_SUBAGENT_PROFILES'),
+            client.request('GET_SUBAGENT_STATUS'),
+        ]);
+        const profiles = asArray(profilesValue, 'subagent profile', isSubagentProfile);
+        const statuses = asArray(statusesValue, 'subagent status', isSubagentStatus);
+        console.log(`\n${(0, colors_1.CYAN_BOLD)('  HELIX SUBAGENTS')}`);
+        console.log(renderSubagentPanel(profiles, statuses));
+        console.log((0, colors_1.DIM)('  Chat: /subagents chat <profile_id> <mensaje>\n'));
+    }
+    catch (error) {
+        console.log((0, colors_1.RED)(`  No se pudo cargar el panel de subagentes: ${error.message}\n`));
+    }
+}