@johpaz/hive 1.1.0

package/CONTRIBUTING.md

@@ -0,0 +1,44 @@
+# Contribuir a Hive
+
+¡Gracias por tu interés en contribuir a Hive! Este documento te ayuda a saber dónde hacer tu cambio.
+
+## ¿Dónde hacer cambios?
+
+| Tipo de cambio | Carpeta |
+|---------------|---------|
+| Canal nuevo (Telegram, Discord, WhatsApp, etc.) | `packages/core/src/channels` |
+| Tool nueva (navegador, filesystem, etc.) | `packages/core/src/tools` |
+| Skill nuevo (web_search, shell, memory, etc.) | `packages/core/src/skills` |
+| MCP nuevo | `packages/core/src/mcp` |
+| Mejora al CLI | `packages/cli/src` |
+| Bug fix | Donde corresponda según el error |
+
+## Proceso de Pull Request
+
+1. **Fork** el repositorio
+2. Crea una rama: `git checkout -b feature/mi-nueva-feature`
+3. Haz tus cambios con pruebas si es posible
+4. Asegúrate de que pasa el lint: `bun run lint`
+5. Abre un PR describiendo tu cambio
+
+Todos los cambios se revisan en un solo lugar. Un PR. Una revisión. Un merge.
+
+## Ejecutar en desarrollo
+
+```bash
+bun install
+bun run dev
+```
+
+## Commands disponibles
+
+```bash
+bun run dev        # Modo desarrollo
+bun run start      # Iniciar gateway
+bun run test       # Ejecutar tests
+bun run lint       # Verificar tipos
+```
+
+---
+
+¿Dudas? Únete a nuestro [Discord](https://discord.gg/hive) o abre un issue.

package/README.md

@@ -0,0 +1,310 @@
+# Hive 🐝
+
+> Tu colmena de agentes IA. Local-first. Multi-canal. Open source. Construido desde Colombia para el mundo.
+
+[![npm version](https://img.shields.io/npm/v/@johpaz/hive)](https://www.npmjs.com/package/@johpaz/hive)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm downloads](https://img.shields.io/npm/dm/@johpaz/hive)](https://www.npmjs.com/package/@johpaz/hive)
+[![Hecho en Colombia 🇨🇴](https://img.shields.io/badge/Hecho%20en-Colombia-brightgreen)](https://github.com/johpaz/hive)
+
+---
+
+## ¿Qué es Hive?
+
+Hive es un Gateway de IA Orquestado — un Enjambre de Agentes Especializados que trabajan juntos bajo la coordinación de un gateway central. A diferencia de un asistente personal único, Hive implementa una arquitectura de enjambre donde múltiples agentes especializados trabajan en equipo.
+
+**El problema que resolvemos**: Necesitas un asistente de IA que funcione en múltiples canales (Telegram, Discord, WhatsApp), que pueda ejecutar tareas automáticamente, que respete tu privacidad con datos locales, y que sea extensible con herramientas propias.
+
+---
+
+## Instalación
+
+### Opción 1: npm (Recomendado para desarrolladores)
+
+```bash
+npm install -g @johpaz/hive
+```
+
+Luego ejecuta el asistente de configuración:
+
+```bash
+hive onboard
+```
+
+### Opción 2: Binario standalone (Cero dependencias)
+
+Descarga el binario para tu plataforma:
+
+| Plataforma | Descarga | Permisos |
+|------------|----------|----------|
+| Windows x64 | [hive-v1.1.0-windows-x64.exe](https://github.com/johpaz/hive/releases/latest) | `chmod +x hive-v1.1.0-windows-x64.exe` |
+| macOS Intel | [hive-v1.1.0-macos-x64](https://github.com/johpaz/hive/releases/latest) | `chmod +x hive-v1.1.0-macos-x64` |
+| macOS Apple Silicon | [hive-v1.1.0-macos-arm64](https://github.com/johpaz/hive/releases/latest) | `chmod +x hive-v1.1.0-macos-arm64` |
+| Linux x64 | [hive-v1.1.0-linux-x64](https://github.com/johpaz/hive/releases/latest) | `chmod +x hive-v1.1.0-linux-x64` |
+| Linux ARM64 | [hive-v1.1.0-linux-arm64](https://github.com/johpaz/hive/releases/latest) | `chmod +x hive-v1.1.0-linux-arm64` |
+
+```bash
+# Ejemplo para Linux:
+curl -L -o hive https://github.com/johpaz/hive/releases/latest/download/hive-v1.1.0-linux-x64
+chmod +x hive
+./hive onboard
+```
+
+### Caso de uso USB (Portable)
+
+Lleva tu agente contigo en una USB:
+
+1. Descarga el binario de tu plataforma
+2. Copia el binario a una USB
+3. En cualquier equipo compatible, ejecuta:
+   ```bash
+   ./hive onboard
+   ```
+
+Tu configuración y base de datos se guardan en `~/.hive`. Puedes copiar esa carpeta a tu USB y tener tu agente completo siempre contigo.
+
+---
+
+## Los Cuatro Pilares
+
+| Pilar | Descripción |
+|-------|-------------|
+| **Tools** | Herramientas nativas: navegador, sistema de archivos, cron, canvas. |
+| **Skills** | Habilidades incluidas: búsqueda web, shell, memoria, HTTP client, file manager. |
+| **MCP** | Compatible con Model Context Protocol para extender funcionalidades. |
+| **Ética** | Límites claros definidos en ETHICS.md — tu agente siempre sabe qué puede y qué no puede hacer. |
+
+---
+
+## Arquitectura técnica
+
+Hive usa un **Native Agent Loop** propio — sin dependencias de LangGraph ni LangChain. Todo corre sobre Bun + SQLite con cero abstracciones intermedias.
+
+### Loop principal
+
+```
+mensaje entrante
+  → Context Compiler (compileContext)
+      → callLLM()
+          → [executeTool() → callLLM()]*
+              → respuesta al usuario
+```
+
+---
+
+### FASE 3 — Context Compiler
+
+El Context Compiler es el componente central del motor. Se ejecuta antes de cada llamada al modelo y ensambla una "vista mínima" del contexto consultando SQLite directamente. Implementa cuatro estrategias de Context Engineering:
+
+**3.1 — Selección de historial (SELECCIONAR)**
+- Conversaciones cortas (< 20 mensajes): pasa todos los mensajes
+- Conversaciones largas: usa el resumen de la tabla `summaries` + los últimos N mensajes recientes
+- Nunca pasa la conversación cruda completa a modelos con ventana chica
+
+**3.2 — Scratchpad (ESCRIBIR)**
+- Carga las notas persistentes del thread actual desde la tabla `scratchpad`
+- Las inyecta en el system prompt como "Información conocida sobre esta conversación"
+- El agente puede escribir al scratchpad usando la tool `save_note(key, value)`
+
+**3.3 — Playbook del ACE (SELECCIONAR)**
+- Busca con FTS5 en la tabla `playbook` usando keywords del mensaje del usuario
+- Inyecta máximo 5 reglas relevantes (`active=1`, `helpful_count > harmful_count`)
+- Las reglas son aprendidas automáticamente por el Curator del ACE
+
+**3.4 — Selección de tools en tres niveles (SELECCIONAR)**
+
+| Nivel | Operación |
+|-------|-----------|
+| 1 — Catálogo | `collectNativeTools()` + tools de MCP activos |
+| 2 — Agente | `filterToolsByAgent()` — filtra por `tools_json` del agente. `NULL` = todas permitidas |
+| 3 — Turno | `selectToolLoadout()` — ALWAYS_INCLUDE + scoring por keywords del mensaje (máx. 20) |
+
+El límite de 20 tools por turno es crítico para modelos locales con recursos limitados. Las tools del `ALWAYS_INCLUDE` siempre están disponibles sin consumir slots opcionales: `cron_add/list/remove/edit`, `project_create/task_create/task_update`, `read/write/edit`, `save_note`, `notify`, `report_progress`, `create_agent`.
+
+**3.5 — Ética (capa constitucional)**
+- Carga todas las reglas de la tabla `ethics` — sin filtrar, sin comprimir
+- Siempre es el primer bloque del system prompt, en toda llamada al modelo
+
+**Orden de ensamblaje del contexto:**
+
+```
+[system prompt]
+  1. Reglas de ética (completas, siempre)
+  2. Identidad del agente (agents.system_prompt + description)
+  3. Hive Capabilities Manifest (hive_capabilities table)
+  4. Perfil del usuario (users table)
+  5. Reglas del playbook relevantes (FTS5, máx. 5)
+  6. Notas del scratchpad (filtradas por thread_id)
+  7. Entorno (agent_id, thread_id, fecha/hora local)
+
+[messages]
+  8. Resumen del historial (si la conversación es larga)
+  9. Mensajes recientes (últimos N)
+
+[tools]
+  10. Tools filtradas en tres niveles
+```
+
+---
+
+### FASE 4 — Proyectos, Tareas y Workers
+
+El Coordinador puede descomponer problemas complejos en proyectos con tareas paralelas ejecutadas por workers autónomos.
+
+**4.1 — Decisión simple vs proyecto**
+
+El modelo decide en su system prompt:
+- **Tarea simple** → el Coordinador la resuelve directamente o despacha a un worker existente
+- **Tarea compleja** → crea un proyecto con subtareas y dependencias
+
+**4.2 — Creación de proyecto y asignación de workers**
+
+1. `project_create` — registra el objetivo del proyecto
+2. `task_create` — crea cada subtarea con dependencias
+3. `find_agent` — busca por FTS5 sobre `name+description` del agente vs la tarea
+   - Si existe un worker compatible → `assign_task`
+   - Si no → `create_agent` con system prompt y tools necesarios, luego `assign_task`
+
+**4.3 — Ejecución respetando dependencias**
+
+- Tareas sin dependencias (o con dependencias ya `completed`) se ejecutan primero
+- Tareas independientes entre sí corren en paralelo (`Promise.all`)
+- Si una tarea falla: el Coordinador puede reintentar, reasignar a otro agente, o marcar el proyecto como `failed`
+
+**4.4 — Contexto aislado por worker (AISLAR)**
+
+Cada worker recibe **solo** lo necesario para su tarea:
+- Reglas de ética + su system prompt propio
+- Descripción de la tarea asignada
+- Resultados de las tareas de las que depende
+
+El worker **no** recibe la conversación completa del usuario. Esto mantiene el contexto mínimo y evita contaminación entre agentes.
+
+---
+
+### FASE 5 — ACE (Adaptive Context Engine)
+
+El ACE convierte a Hive en un sistema que aprende automáticamente de sus propias ejecuciones.
+
+**5.1 — Tracer (Generator)**
+
+Después de cada ejecución se guarda automáticamente en la tabla `traces`:
+- Qué agente, qué tool, qué recibió, qué produjo
+- Si fue exitoso, cuánto tardó, cuántos tokens consumió
+
+Pasivo — no agrega latencia al usuario.
+
+**5.2 — Reflector (análisis periódico)**
+
+Se ejecuta en segundo plano, nunca en el flujo del usuario:
+- Trigger: cada 20 trazas nuevas, o por cron periódico
+- Le pide al modelo que analice las trazas: patrones de éxito, fallos repetidos, oportunidades de mejora
+- Guarda los insights en la tabla `reflections` (incluyendo `ethics_violation` con prioridad máxima)
+
+**5.3 — Curator (playbook + poda de agentes)**
+
+Transforma insights en reglas operativas:
+- Si ya existe una regla similar → incrementa `helpful_count` o `harmful_count`
+- Si es nueva → la inserta con `confidence` proporcional a cuántas trazas la respaldan
+- Si `harmful_count > helpful_count` → marca la regla como `active=0`
+- Si hay reglas duplicadas o contradictorias → fusiona o poda
+
+Poda de agentes:
+- Workers sin actividad por más de 14 días → `status='archived'`
+- Workers con tasa de fallo alta → `archived` + regla en playbook explicando por qué fallaba
+- Workers duplicados (skills similares) → archiva el menos exitoso
+
+**Ciclo completo del ACE:**
+
+```
+Agentes ejecutan tareas
+  → trazas en SQLite
+      → Reflector analiza periódicamente
+          → Curator actualiza playbook + poda agentes
+              → Context Compiler inyecta reglas
+                  → Agentes ejecutan mejor la próxima vez
+```
+
+---
+
+### FASE 6 — Compaction (compresión de historial)
+
+Mantiene el contexto dentro del presupuesto de tokens del modelo.
+
+**Compresión de conversación (COMPRIMIR)**
+- Trigger: cuando el token count acumulado del thread supera el 60% de la ventana del modelo
+- Toma todos los mensajes excepto los últimos 5
+- El modelo los resume preservando: datos del usuario, decisiones tomadas, resultados de tools, contexto para continuar
+- El resumen se guarda en la tabla `summaries`; los mensajes originales permanecen como historial
+
+**Tool result clearing**
+- Resultados de tools con más de N turnos de antigüedad → reemplazados por un resumen corto
+- Reduce tokens sin perder el registro de que la tool se ejecutó
+
+---
+
+### Providers LLM soportados
+
+Hive llama directamente a los SDKs oficiales de cada provider:
+
+| Provider | SDK | Modelos ejemplo |
+|----------|-----|-----------------|
+| Google Gemini | `@google/genai` | gemini-2.5-flash, gemini-2.0-flash |
+| Anthropic | `@anthropic-ai/sdk` | claude-sonnet-4-6, claude-opus-4-6 |
+| OpenAI | `openai` | gpt-4o, gpt-4.1 |
+| Groq | `openai` (compat) | llama-3.3-70b, mixtral-8x7b |
+| Mistral | `openai` (compat) | mistral-large |
+| DeepSeek | `openai` (compat) | deepseek-chat |
+| Ollama | `openai` (compat) | llama3, qwen2.5, etc. |
+| OpenRouter | `openai` (compat) | cualquier modelo de la plataforma |
+
+### Onboarding → System Prompt
+
+Al completar el onboarding, el campo `agents.system_prompt` se genera automáticamente con el nombre, descripción y tono del agente. El tono puede ser: `friendly`, `professional`, `direct` o `casual`.
+
+---
+
+## Desarrollo
+
+```bash
+# Clonar el repo
+git clone https://github.com/johpaz/hive.git
+cd hive
+
+# Instalar dependencias
+bun install
+
+# Modo desarrollo
+bun run dev
+```
+
+---
+
+## Contribuir
+
+¿Quieres agregar una nueva funcionalidad? Consulta [CONTRIBUTING.md](CONTRIBUTING.md) para saber exactamente dónde hacer tu cambio.
+
+| Tipo de cambio | Ubicación |
+|---------------|-----------|
+| Canal nuevo | `packages/core/src/channels/` + registrar en `manager.ts` |
+| Tool nativa | `packages/core/src/tools/` + registrar en `native-tools.ts` |
+| Skill nueva | `packages/skills/src/` |
+| MCP nuevo | `packages/core/src/mcp/` |
+| Capability en el manifest | tabla `hive_capabilities` vía `seed.ts` |
+| Mejora al CLI | `packages/cli/src/commands/` |
+
+Todo en un PR. Una revisión. Un merge.
+
+---
+
+## Links
+
+- 🌐 [hiveagents.io](https://hiveagents.io)
+- 💬 [Discord](https://discord.gg/hive)
+- 📱 [Telegram](https://t.me/hive_agents)
+
+---
+
+## Licencia
+
+MIT © 2024-2026 Hive Team — Construido con ❤️ desde Colombia

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@johpaz/hive",
+  "version": "1.1.0",
+  "description": "Tu colmena de agentes IA. Local-first. Multi-canal. Open source. Construido desde Colombia para el mundo.",
+  "bin": {
+    "hive": "packages/cli/src/index.ts"
+  },
+  "main": "packages/core/src/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johpaz/hive.git"
+  },
+  "keywords": [
+    "hive",
+    "agents",
+    "ai",
+    "llm",
+    "context-engine",
+    "local-first",
+    "multi-channel",
+    "telegram",
+    "discord",
+    "whatsapp",
+    "bun",
+    "sqlite",
+    "mcp",
+    "open-source",
+    "latam",
+    "colombia"
+  ],
+  "license": "MIT",
+  "files": [
+    "packages/core/",
+    "packages/cli/",
+    "packages/mcp/",
+    "packages/skills/",
+    "packages/tools/",
+    "packages/code-bridge/",
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "CONTRIBUTING.md"
+  ],
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "dev": "HIVE_HOME=$HOME/.hive-dev HIVE_DEV=true bun run packages/cli/src/index.ts dev",
+    "dev:keep": "HIVE_HOME=$HOME/.hive-dev HIVE_DEV=true HIVE_DEV_CLEAN=false bun run packages/cli/src/index.ts dev",
+    "start": "bun run packages/cli/src/index.ts start",
+    "test": "bun test",
+    "test:ci": "bun test --coverage",
+    "lint": "bunx tsc --noEmit",
+    "build": "echo 'No build needed - TypeScript is interpreted by Bun'",
+    "build:binaries": "bun run scripts/build-binaries.ts",
+    "bench": "bun run scripts/bench.ts",
+    "prepublishOnly": "bun run build",
+    "publish": "npm publish --access public"
+  },
+  "dependencies": {
+    "@ag-ui/core": "^0.0.46",
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@clack/prompts": "^0.5.0",
+    "@google/genai": "^1.43.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@sapphire/snowflake": "latest",
+    "@slack/bolt": "latest",
+    "@vitejs/plugin-react": "^5.1.4",
+    "@whiskeysockets/baileys": "latest",
+    "async-mutex": "^0.5.0",
+    "cron-parser": "^5.5.0",
+    "discord.js": "latest",
+    "grammy": "latest",
+    "groq-sdk": "^0.37.0",
+    "isomorphic-git": "^1.37.2",
+    "js-yaml": "^4.1.1",
+    "ollama": "^0.6.3",
+    "openai": "^6.18.0",
+    "qrcode-terminal": "latest",
+    "react-markdown": "^10.1.0",
+    "toon-format-parser": "^1.1.0",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "@types/react": "^18.3.23",
+    "typescript": "latest"
+  },
+  "overrides": {
+    "vite": "^7.3.1"
+  },
+  "resolutions": {
+    "vite": "^7.3.1"
+  }
+}

package/packages/cli/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@johpaz/hive-cli",
+  "version": "1.1.0",
+  "private": true,
+  "description": "Hive CLI — Command line interface for the Hive AI Gateway",
+  "bin": {
+    "hive": "src/index.ts"
+  },
+  "main": "./src/index.ts",
+  "license": "MIT",
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@clack/prompts": "^",
+    "@johpaz/hive-core": "^1.1.0",
+    "@johpaz/hive-code-bridge": "^1.1.0",
+    "js-yaml": "latest",
+    "toon-format-parser": "^1.1.0"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "@types/bun": "latest"
+  }
+}

package/packages/cli/src/commands/agent-run.ts

@@ -0,0 +1,168 @@
+import * as p from "@clack/prompts";
+import { loadConfig } from "@johpaz/hive-core/config/loader";
+
+function getGatewayUrl(config: any): string {
+  const gateway = config?.gateway;
+  const host = gateway?.host ?? "localhost";
+  const port = gateway?.port ?? 3000;
+  return `http://${host}:${port}`;
+}
+
+export async function agent(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "run":
+      await agentRun(args);
+      break;
+    default:
+      console.log(`
+Usage: hive agent <command>
+
+Commands:
+  run --message <text>     Ejecutar agente con mensaje
+  run --thinking <level>   Nivel de razonamiento (low/medium/high)
+  run --wait               Esperar respuesta completa
+`);
+  }
+}
+
+async function agentRun(args: string[]): Promise<void> {
+  const messageIndex = args.indexOf("--message");
+  const thinkingIndex = args.indexOf("--thinking");
+  const toolsIndex = args.indexOf("--tools");
+  const agentIndex = args.indexOf("--agent");
+  const waitIndex = args.indexOf("--wait");
+
+  if (messageIndex === -1) {
+    const msg = await p.text({
+      message: "Mensaje para el agente:",
+      placeholder: "Analiza el archivo README.md",
+      validate: (v) => (!v ? "El mensaje es requerido" : undefined),
+    });
+
+    if (p.isCancel(msg)) {
+      p.cancel("Cancelado");
+      return;
+    }
+
+    args.push("--message", msg as string);
+    return agentRun(args);
+  }
+
+  const message = args[messageIndex + 1];
+  const thinking = thinkingIndex !== -1 ? args[thinkingIndex + 1] : "medium";
+  const tools = toolsIndex !== -1 ? args[toolsIndex + 1] : "all";
+  const agentId = agentIndex !== -1 ? args[agentIndex + 1] : "main";
+  const wait = waitIndex !== -1;
+
+  if (!message) {
+    console.log("❌ Mensaje requerido");
+    return;
+  }
+
+  const config = loadConfig();
+  const gatewayUrl = getGatewayUrl(config);
+
+  const spinner = p.spinner();
+  spinner.start("Conectando con el agente...");
+
+  try {
+    if (wait) {
+      await executeWithStream(gatewayUrl, { message, thinking, tools, agentId }, spinner);
+    } else {
+      await executeAsync(gatewayUrl, { message, thinking, tools, agentId }, spinner);
+    }
+  } catch (error) {
+    spinner.stop("Error");
+    console.log(`❌ ${(error as Error).message}`);
+    console.log("   ¿Está corriendo el Gateway? Ejecuta: hive start");
+  }
+}
+
+async function executeWithStream(
+  gatewayUrl: string,
+  payload: { message: string; thinking: string; tools: string; agentId: string },
+  spinner: ReturnType<typeof p.spinner>
+): Promise<void> {
+  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...payload, stream: true }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Error: ${response.statusText}`);
+  }
+
+  spinner.stop("Conectado");
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No se pudo obtener el stream");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let thinking = true;
+
+  process.stdout.write("\n");
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      if (!line.trim() || !line.startsWith("data: ")) continue;
+
+      try {
+        const data = JSON.parse(line.slice(6));
+
+        if (data.type === "thinking" && thinking) {
+          process.stdout.write(".");
+        } else if (data.type === "response") {
+          if (thinking) {
+            process.stdout.write("\n\n");
+            thinking = false;
+          }
+          process.stdout.write(data.content ?? "");
+        } else if (data.type === "tool_call") {
+          process.stdout.write(`\n[Tool: ${data.toolName}]`);
+        } else if (data.type === "complete") {
+          process.stdout.write("\n\n");
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+}
+
+async function executeAsync(
+  gatewayUrl: string,
+  payload: { message: string; thinking: string; tools: string; agentId: string },
+  spinner: ReturnType<typeof p.spinner>
+): Promise<void> {
+  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...payload, stream: false }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Error: ${response.statusText}`);
+  }
+
+  const result = await response.json() as { taskId?: string; success: boolean };
+
+  spinner.stop("Enviado");
+
+  if (result.taskId) {
+    console.log(`✓ Tarea enviada: ${result.taskId}`);
+    console.log("  Usa `hive tasks list` para ver el estado");
+  } else {
+    console.log("✓ Tarea enviada");
+  }
+}