@johpaz/hive-agents 0.0.35 → 0.0.37

package/packages/skills/src/bundled/agents/code_delegator/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: code_delegator
+description: "Delegate coding tasks to CLI subagents (Qwen, Claude, Gemini, OpenCode) via Code Bridge and monitor execution"
+version: 1.0.0
+author: Hive Team
+icon: "💻"
+category: agents
+permissions:
+  - codebridge_manage
+dependencies: []
+tools: [task_delegate_code, task_status, codebridge_launch, codebridge_status]
+
+# Structured skill fields
+triggers:
+  - "delegá el código"
+  - "delegate code"
+  - "que lo haga un subagente"
+  - "let subagent do it"
+  - "programá esto"
+  - "code this"
+  - "implementá con CLI"
+  - "implement with CLI"
+  - "usá Qwen"
+  - "use Qwen"
+  - "usá Claude Code"
+  - "use Claude Code"
+  - "subagente de código"
+  - "coding subagent"
+
+preferred_agents: []
+
+steps:
+  - step: 1
+    action: analyze_task
+    instruction: "Analyze coding task complexity and determine best subagent (Qwen, Claude, Gemini, OpenCode)"
+    output: task_analysis
+
+  - step: 2
+    action: codebridge_launch
+    instruction: "Launch appropriate CLI subagent with task prompt"
+    params:
+      agent: "qwen|claude|gemini|opencode"
+      prompt: "Clear coding task description with requirements"
+    output: process_id
+
+  - step: 3
+    action: codebridge_status
+    instruction: "Monitor subagent execution progress"
+    params:
+      process_id: "ID from step 2"
+    output: execution_status
+
+  - step: 4
+    action: task_status
+    instruction: "Get final result and verify completion"
+    params:
+      task_id: "delegated task ID"
+    output: final_result
+
+rules:
+  - "Use task_delegate_code for simple coding tasks that don't require full CLI subagent"
+  - "Use codebridge_launch for complex coding requiring external CLI (Qwen, Claude Code, etc.)"
+  - "Specify clear requirements and acceptance criteria in prompt"
+  - "Monitor execution with codebridge_status every 30-60 seconds for long tasks"
+  - "Verify output matches requirements before marking complete"
+  - "Handle errors gracefully — retry with clarified prompt if subagent fails"
+
+output_format:
+  structure: markdown
+  sections:
+    - "task_description"
+    - "subagent_used"
+    - "execution_status"
+    - "result_summary"
+    - "files_modified"
+  max_length: "Comprehensive delegation summary"
+
+examples:
+  - user_input: "delegá la implementación del endpoint REST a Qwen"
+    expected_behavior: "codebridge_launch({ agent: 'qwen', prompt: 'Implement REST endpoint with GET/POST' }) → monitor → return result"
+
+  - user_input: "que Claude Code haga los tests unitarios"
+    expected_behavior: "codebridge_launch({ agent: 'claude', prompt: 'Write unit tests for module X' }) → codebridge_status → return test files"
+
+  - user_input: "implementá esto con un subagente"
+    expected_behavior: "Analyze task → select best subagent → codebridge_launch → monitor → deliver result"
+---
+
+# Code Delegator Skill
+
+## Cuándo se Activa
+
+Esta skill se activa cuando el usuario necesita delegar tareas de programación a subagentes CLI especializados (Qwen CLI, Claude Code, Gemini CLI, OpenCode).
+
+## Herramientas Disponibles
+
+| Tool | Qué hace | Cuándo usarla |
+|------|----------|---------------|
+| `task_delegate_code` | Delega tarea de código simple | Tasks pequeños/medianos |
+| `codebridge_launch` | Lanza subagente CLI externo | Tasks complejos que requieren CLI completo |
+| `codebridge_status` | Verifica estado de ejecución | Monitoreo de progreso |
+| `task_status` | Obtiene estado de tarea delegada | Verificación final |
+
+## Workflow
+
+### Delegación Simple
+```javascript
+task_delegate_code({
+  description: "Implementar función de autenticación",
+  acceptance_criteria: "Funciona con JWT, maneja errores"
+})
+```
+
+### Delegación Completa (CLI Subagent)
+```javascript
+// 1. Lanzar subagente
+const { process_id } = codebridge_launch({
+  agent: "qwen",  // o "claude", "gemini", "opencode"
+  prompt: `
+    Implementar endpoint REST para usuarios:
+    - GET /users - listar usuarios
+    - POST /users - crear usuario
+    - Validación con Zod
+    - Tests con Jest
+  `
+})
+
+// 2. Monitorear
+const status = codebridge_status({ process_id })
+
+// 3. Verificar resultado
+const result = task_status({ task_id })
+```
+
+## Subagentes Disponibles
+
+| Agente | Comando | Especialidad |
+|--------|---------|--------------|
+| Qwen CLI | `qwen` | Código general, rápido |
+| Claude Code | `claude` | Código complejo, refactor |
+| Gemini CLI | `gemini` | Código + documentación |
+| OpenCode | `opencode` | Open source, multi-lenguaje |
+
+## Mejores Prácticas
+
+- Prompts claros con requisitos específicos
+- Criterios de aceptación explícitos
+- Monitoreo periódico (30-60s para tasks largos)
+- Verificación de output antes de cerrar
+
+## Errores a Evitar
+
+- ❌ Prompts vagos sin criterios claros
+- ❌ No monitorear ejecución larga
+- ❌ Ignorar errores del subagente
+- ❌ No verificar que el código cumple requisitos

package/packages/skills/src/bundled/agents/memory_manager/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: memory_manager
+description: "Complete management of persistent memory including write, read, search, list, and delete operations"
+version: 1.0.0
+author: Hive Team
+icon: "🧠"
+category: agents
+permissions:
+  - memory_read
+  - memory_write
+dependencies: []
+tools: [memory_write, memory_read, memory_list, memory_search, memory_delete]
+
+# Structured skill fields
+triggers:
+  - "guardá en memoria"
+  - "save to memory"
+  - "recordá esto"
+  - "remember this"
+  - "leé la memoria"
+  - "read memory"
+  - "qué hay en memoria"
+  - "what's in memory"
+  - "buscá en memoria"
+  - "search memory"
+  - "lista las memorias"
+  - "list memories"
+  - "eliminá de memoria"
+  - "delete from memory"
+  - "preferencias"
+  - "preferences"
+  - "datos persistentes"
+  - "persistent data"
+
+preferred_agents: []
+
+steps:
+  - step: 1
+    action: determine_operation
+    instruction: "Determine if user wants to write, read, list, search, or delete"
+    output: operation_type
+
+  - step: 2
+    action: execute_memory_op
+    instruction: "Execute appropriate memory operation"
+    params:
+      write: "memory_write({ title, content })"
+      read: "memory_read({ title })"
+      list: "memory_list({})"
+      search: "memory_search({ query })"
+      delete: "memory_delete({ title })"
+    output: memory_result
+
+  - step: 3
+    action: format_result
+    instruction: "Format memory content for user consumption"
+    output: formatted_result
+
+rules:
+  - "Use descriptive, unique titles for memory_write — titles are used for direct lookup"
+  - "If title exists, memory_write overwrites — confirm before overwriting important data"
+  - "Use memory_search for fuzzy matching when exact title unknown"
+  - "Use memory_list to show all when user asks 'what did you save'"
+  - "Avoid storing sensitive data (passwords, API keys, tokens)"
+  - "Keep content concise — split large data into multiple entries"
+
+output_format:
+  structure: markdown
+  sections:
+    - "title"
+    - "content_summary"
+    - "created_at"
+  max_length: "1000 characters per entry"
+
+examples:
+  - user_input: "guardá en memoria que prefiero TypeScript"
+    expected_behavior: "memory_write({ title: 'Preferencias de Desarrollo', content: 'El usuario prefiere TypeScript' })"
+
+  - user_input: "qué guardaste sobre mis preferencias"
+    expected_behavior: "memory_search({ query: 'preferencias' }) → return matching memories"
+
+  - user_input: "lista todas las memorias"
+    expected_behavior: "memory_list({}) → return all memory titles"
+
+  - user_input: "buscá en memoria información sobre la DB"
+    expected_behavior: "memory_search({ query: 'DB database' }) → return relevant entries"
+---
+
+# Memory Manager Skill
+
+## Cuándo se Activa
+
+Para guardar, recuperar, buscar, listar o eliminar información persistente entre sesiones.
+
+## Herramientas Disponibles
+
+| Tool | Qué hace | Cuándo usarla |
+|------|----------|---------------|
+| `memory_write` | Almacena con título único | Guardar preferencias, datos |
+| `memory_read` | Recupera por título exacto | Cuando conocés el título |
+| `memory_list` | Lista todos los títulos | Explorar qué hay guardado |
+| `memory_search` | Busca por keywords | Cuando no recordás título exacto |
+| `memory_delete` | Elimina entrada | Limpiar datos obsoletos |
+
+## Workflow
+
+### Write
+```javascript
+memory_write({ 
+  title: "Preferencias de Desarrollo",
+  content: "TypeScript, VS Code, Prettier single quotes"
+})
+```
+
+### Read/Search
+```javascript
+memory_read({ title: "Preferencias" })  // Título exacto
+memory_search({ query: "preferencias" })  // Fuzzy match
+```
+
+### List
+```javascript
+memory_list({})  // Todos los títulos
+```
+
+### Delete
+```javascript
+memory_delete({ title: "Datos Temporales" })
+```
+
+## Mejores Prácticas
+
+- Títulos descriptivos y únicos
+- Agrupar datos relacionados en misma entrada
+- Confirmar antes de sobrescribir
+- No guardar datos sensibles
+
+## Errores a Evitar
+
+- ❌ Datos sensibles (passwords, API keys)
+- ❌ Títulos genéricos ("Config", "Datos")
+- ❌ Sobrescribir sin confirmar
+- ❌ Entradas gigantes (split por tema)

package/packages/skills/src/bundled/agents/research_and_remember/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: research_and_remember
+description: "Research information from web sources and save findings to persistent memory"
+version: 1.0.0
+author: Hive Team
+icon: "🔍🧠"
+category: agents
+permissions:
+  - internet_access
+  - memory_write
+dependencies: []
+tools: [web_search, web_fetch, memory_write]
+
+# Structured skill fields
+triggers:
+  - "investigá y guardá"
+  - "research and save"
+  - "buscá y recordá"
+  - "find and remember"
+  - "aprendé sobre"
+  - "learn about"
+  - "estudiá esto"
+  - "study this"
+  - "documentate y guardá"
+  - "research and store"
+
+preferred_agents: []
+
+steps:
+  - step: 1
+    action: web_search
+    instruction: "Search for topic using clear query. Get 5-8 relevant results"
+    params:
+      query: "topic keywords"
+      numResults: 8
+    output: search_results
+
+  - step: 2
+    action: web_fetch
+    instruction: "Fetch 2-3 most relevant URLs for detailed content"
+    params:
+      urls: "top 2-3 URLs"
+    output: detailed_content
+
+  - step: 3
+    action: synthesize
+    instruction: "Synthesize findings into structured knowledge with sources"
+    output: synthesized_knowledge
+
+  - step: 4
+    action: memory_write
+    instruction: "Store synthesized knowledge with clear title for future retrieval"
+    params:
+      title: "Topic: {topic_name}"
+      content: "synthesized knowledge + sources"
+    output: memory_stored
+
+rules:
+  - "Always do at least 2 searches for comprehensive coverage"
+  - "Cross-reference information across multiple sources"
+  - "Include source URLs in stored memory for verification"
+  - "Organize knowledge with clear structure (headings, bullet points)"
+  - "Use descriptive titles that include topic and date if relevant"
+  - "Flag uncertain or conflicting information explicitly"
+
+output_format:
+  structure: markdown
+  sections:
+    - "topic"
+    - "summary"
+    - "key_findings"
+    - "sources"
+    - "memory_title"
+  max_length: "Comprehensive but concise knowledge entry"
+
+examples:
+  - user_input: "investigá y guardá información sobre transformers en ML"
+    expected_behavior: "web_search → web_fetch top sources → synthesize → memory_write({ title: 'Transformers ML', content: '...' })"
+
+  - user_input: "aprendé sobre las mejores prácticas de React 2025"
+    expected_behavior: "Search 'React best practices 2025' → fetch docs → synthesize → memory_write"
+
+  - user_input: "buscá y recordá las tendencias de IA actuales"
+    expected_behavior: "Search 'AI trends 2025' → fetch multiple sources → compile trends → memory_write"
+---
+
+# Research and Remember Skill
+
+## Cuándo se Activa
+
+Para investigar temas en la web y guardar el conocimiento sintetizado en memoria persistente.
+
+## Herramientas Disponibles
+
+| Tool | Qué hace | Cuándo usarla |
+|------|----------|---------------|
+| `web_search` | Busca en internet | Encontrar fuentes |
+| `web_fetch` | Descarga contenido | Obtener detalles |
+| `memory_write` | Guarda conocimiento | Almacenar para futuro |
+
+## Workflow
+
+1. **Buscar** → `web_search({ query, numResults: 8 })`
+2. **Fetch** → `web_fetch({ urls: top 2-3 })`
+3. **Sintetizar** → Compilar hallazgos con estructura clara
+4. **Guardar** → `memory_write({ title, content })`
+
+## Estructura de Conocimiento
+
+```markdown
+# {Topic}
+
+## Summary
+2-3 oración resumen
+
+## Key Findings
+- Punto clave 1
+- Punto clave 2
+- ...
+
+## Sources
+- [Source 1](url)
+- [Source 2](url)
+```
+
+## Mejores Prácticas
+
+- Mínimo 2 searches para cobertura completa
+- Cruzar información entre fuentes múltiples
+- Incluir URLs para verificación
+- Estructura clara con headings
+- Flaggear información incierta
+
+## Errores a Evitar
+
+- ❌ Una sola búsqueda (insuficiente)
+- ❌ Sin fuentes (no verificable)
+- ❌ Títulos vagos para memoria
+- ❌ No flaggear información conflictiva

package/packages/skills/src/bundled/agents/task_orchestrator/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: task_orchestrator
+description: "Orchestrate tasks across multiple workers with delegation, status tracking, and bus communication"
+version: 1.1.0
+author: Hive Team
+icon: "🎻"
+category: agents
+permissions:
+  - agent_manage
+  - agent_bus
+dependencies: []
+tools: [get_available_models, task_delegate, task_status, agent_find, agent_create, bus_publish, bus_read]
+
+# Structured skill fields
+triggers:
+  - "delegá esta tarea"
+  - "delegate task"
+  - "orquestá los workers"
+  - "orchestrate workers"
+  - "coordiná el equipo"
+  - "coordinate team"
+  - "estado de las tareas"
+  - "task status"
+  - "comunicá los workers"
+  - "communicate workers"
+  - "mensaje al bus"
+  - "bus message"
+  - "tarea en paralelo"
+  - "parallel tasks"
+
+preferred_agents: []
+
+steps:
+  - step: 1
+    action: get_available_models
+    instruction: "Query available providers and models to select optimal model for new workers if needed"
+    params:
+      capabilities: "required specialty (coding, analysis, research)"
+    output: available_models
+
+  - step: 2
+    action: agent_find
+    instruction: "Find suitable workers for each task"
+    params:
+      search: "required specialty"
+    output: available_workers
+
+  - step: 3
+    action: agent_create (if needed)
+    instruction: "Create new worker if no suitable one exists, using optimal model from get_available_models"
+    params:
+      name: "specialty_worker"
+      providerId: "from get_available_models"
+      modelId: "from get_available_models"
+    output: new_worker
+
+  - step: 4
+    action: task_delegate
+    instruction: "Delegate tasks to workers with clear instructions. Workers execute immediately (blocking)"
+    params:
+      worker_id: "selected worker ID"
+      task_description: "Clear detailed instructions"
+      task_id: "optional task DB ID for auto status update"
+      project_id: "optional project ID for progress tracking"
+    output: task_result
+
+  - step: 5
+    action: task_status
+    instruction: "Monitor progress of delegated tasks"
+    params:
+      task_ids: "array of task IDs"
+    output: task_statuses
+
+  - step: 6
+    action: bus_publish
+    instruction: "Publish coordination messages for worker-to-worker communication"
+    params:
+      event_type: "coordination"
+      to_worker_id: "target worker"
+      content: "coordination message"
+    output: published
+
+  - step: 7
+    action: bus_read
+    instruction: "Check for messages from workers requiring coordinator attention"
+    output: bus_messages
+
+rules:
+  - "task_delegate is BLOCKING — worker executes immediately, result returned synchronously"
+  - "ALWAYS use get_available_models BEFORE agent_create — providerId y modelId son OBLIGATORIOS"
+  - "Assign tasks based on worker specialty and current load"
+  - "Use bus_publish / bus_read for worker-to-worker coordination"
+  - "Monitor task status continuously for multi-task orchestration"
+  - "Publish to bus when workers need to share context"
+  - "Check bus messages for worker requests or completion notifications"
+
+output_format:
+  structure: markdown
+  sections:
+    - "tasks_delegated"
+    - "workers_assigned"
+    - "current_status"
+    - "bus_messages"
+  max_length: "Orchestration summary"
+
+examples:
+  - user_input: "delegá la investigación y generación de contenido a workers"
+    expected_behavior: "find_agent('researcher') → delegate_task → find_agent('writer') → delegate_task → monitor both"
+
+  - user_input: "cuál es el estado de las tareas"
+    expected_behavior: "get_task_status({ task_ids: [...] }) → return status for each task"
+
+  - user_input: "avisale al writer que el researcher terminó"
+    expected_behavior: "publish_to_bus({ to_worker_id: 'writer', content: 'Research complete, ready for content generation' })"
+---
+
+# Task Orchestrator Skill
+
+## Cuándo se Activa
+
+Para coordinar múltiples workers, delegar tareas, monitorear progreso, y facilitar comunicación worker-to-worker.
+
+## Herramientas Disponibles
+
+| Tool | Qué hace | Cuándo usarla |
+|------|----------|---------------|
+| `get_available_models` | Consulta providers y modelos activos | Al crear workers — seleccionar modelo óptimo |
+| `agent_find` | Busca workers disponibles | Antes de delegar |
+| `agent_create` | Crea nuevo worker | Si no hay uno adecuado |
+| `task_delegate` | Asigna y EJECUTA tarea | Delegar con ejecución inmediata |
+| `task_status` | Verifica estado de tareas | Monitorear progreso |
+| `bus_publish` | Publica mensaje | Coordinación worker-to-worker |
+| `bus_read` | Lee mensajes del bus | Ver solicitudes de workers |
+
+## Workflow
+
+### Delegación
+1. **Consultar modelos** → `get_available_models({ capabilities })` — si necesita crear workers
+2. **Buscar worker** → `agent_find({ search })`
+3. **Si no existe** → `agent_create({...})` — con providerId y modelId OBLIGATORIOS
+4. **Delegar** → `task_delegate({ worker_id, task_description, task_id?, project_id? })` — **BLOQUEANTE**
+5. **Resultado retornado** → Worker ejecuta inmediatamente y devuelve resultado
+
+### Create Agent Config (providerId y modelId son OBLIGATORIOS)
+```javascript
+// 1. Consultar modelos disponibles
+get_available_models({ capabilities: "analysis" })
+// → [{ providerId: "anthropic", modelId: "claude-sonnet-4-6", contextWindow: 200000 }, ...]
+
+// 2. Crear worker con modelo óptimo
+agent_create({
+  name: "data_analyst",
+  description: "Especialista en análisis de datos y visualización",
+  system_prompt: "Sos analista de datos experto...",
+  tools_json: ["web_search", "web_fetch", "save_note"],
+  providerId: "anthropic",  // OBLIGATORIO
+  modelId: "claude-sonnet-4-6",  // OBLIGATORIO
+  tone: "analytical"
+})
+```
+
+### Monitoreo
+1. **Check estado** → `task_status({ task_ids })`
+2. **Publicar coordinación** → `bus_publish()` si needed
+3. **Leer bus** → `bus_read()` para respuestas
+
+## Agent Bus Communication
+
+```javascript
+// Worker notifica completado:
+bus_publish({
+  event_type: "task_complete",
+  to_worker_id: "next_worker",
+  content: "Research done. Found 7 trends. Ready for content generation."
+})
+
+// Worker solicita contexto:
+bus_read() → [{ from: "writer", content: "Need research results" }]
+```
+
+## Mejores Prácticas
+
+- `task_delegate` es bloqueante — el resultado llega en el retorno de la tool
+- Consultar modelos disponibles antes de crear workers (`get_available_models`)
+- Asignar workers por especialidad (`agent_find`)
+- Usar `bus_publish` / `bus_read` para coordinación entre workers
+- Pasar `task_id` y `project_id` a `task_delegate` para auto-tracking de progreso
+- Seleccionar modelo según capacidad: coding → modelos grandes, chat → modelos rápidos
+
+## Errores a Evitar
+
+- ❌ Usar `delegate_task` (no existe) — usar `task_delegate`
+- ❌ Usar `find_agent` (no existe) — usar `agent_find`
+- ❌ Usar `publish_to_bus` / `get_bus_messages` (no existen) — usar `bus_publish` / `bus_read`
+- ❌ Usar `get_task_status` (no existe) — usar `task_status`
+- ❌ No consultar modelos disponibles antes de crear workers
+- ❌ No monitorear estado de tasks
+- ❌ No coordinar workers cuando hay dependencias