helix-assistant-cli 0.2.14 → 0.6.1

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

package/dist/config/mcp-defaults.js

@@ -3,10 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCP_DEFAULTS = void 0;
 /** Catalog only: entries are never enabled or installed automatically. */
 exports.MCP_DEFAULTS = [
-    { id: 'filesystem', label: 'Archivos locales', purpose: 'Carpeta elegida por el usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo rutas autorizadas' },
+    { id: 'filesystem', label: 'Archivos locales', purpose: 'Carpetas y archivos del equipo del usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo rutas autorizadas' },
     { id: 'obsidian', label: 'Obsidian / Helix Vault', purpose: 'Leer y gestionar una bóveda concreta', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo la bóveda seleccionada' },
     { id: 'vscode', label: 'VS Code', purpose: 'Trabajar con el workspace seleccionado', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo el workspace seleccionado' },
-    { id: 'github', label: 'GitHub', purpose: 'Repositorios, issues y pull requests', transport: 'stdio', activation: 'oauth-opt-in', privacy: 'Requiere token u OAuth del usuario' },
-    { id: 'gmail', label: 'Gmail', purpose: 'Correo y búsqueda de mensajes', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere OAuth explícito del usuario' },
-    { id: 'notion', label: 'Notion', purpose: 'Páginas y bases de datos', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere integración autorizada' },
+    { id: 'cursor', label: 'Cursor', purpose: 'Proyectos y editor de código del usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo el workspace autorizado' },
+    { id: 'github', label: 'GitHub', purpose: 'Repositorios, issues, pull requests y código', transport: 'stdio', activation: 'oauth-opt-in', privacy: 'Requiere token u OAuth del usuario' },
+    { id: 'linear', label: 'Linear', purpose: 'Issues, roadmap y trabajo del equipo', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere acceso autorizado del workspace' },
+    { id: 'gmail', label: 'Gmail', purpose: 'Correo, búsquedas y mensajes relevantes', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere OAuth explícito del usuario' },
+    { id: 'google-drive', label: 'Google Drive', purpose: 'Documentos y archivos compartidos', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere acceso autorizado a la cuenta' },
+    { id: 'notion', label: 'Notion', purpose: 'Páginas, bases de datos y conocimiento', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere integración autorizada' },
+    { id: 'chatgpt', label: 'ChatGPT', purpose: 'Acceso a tareas y contexto de chat del usuario', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere conexión autorizada del usuario' },
+    { id: 'claude-desktop', label: 'Claude Desktop', purpose: 'Contexto y trabajo en la app desktop de Claude', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo los recursos autorizados por el usuario' },
+    { id: 'word', label: 'Microsoft Word', purpose: 'Documentos y edición de texto', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+    { id: 'excel', label: 'Microsoft Excel', purpose: 'Hojas de cálculo, análisis y tabulación', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+    { id: 'powerpoint', label: 'Microsoft PowerPoint', purpose: 'Presentaciones y material visual', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+    { id: 'antigravity', label: 'Antigravity', purpose: 'Workspace y flujos de automatización del usuario', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere conexión explícita del usuario' },
 ];

package/dist/index.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 // ═══════════════════════════════════════════════════════════════
 // Cross-Platform Terminal & Stream Encoding Setup
@@ -31,6 +34,7 @@ const agent_client_1 = require("./client/agent-client");
 const apikey_1 = require("./commands/apikey");
 const colors_1 = require("./ui/colors");
 const banner_1 = require("./ui/banner");
+const package_json_1 = __importDefault(require("../package.json"));
 async function readStdin() {
     if (process.stdin.isTTY) {
         return '';
@@ -70,7 +74,7 @@ const program = new commander_1.Command();
 program
     .name('helix')
     .description('HELIX - Interactive Terminal CLI for Windows AI Desktop Agent')
-    .version('0.2.14')
+    .version(package_json_1.default.version)
     .option('-u, --ws-url <url>', 'URL del servidor WebSocket del agente', (0, env_1.getWsUrl)())
     .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', (0, env_1.getWsToken)())
     .option('--plain', 'Desactivar formato enriquecido de Markdown y mostrar texto plano sin asteriscos')