@johpaz/hive-sdk 0.2.0 → 0.3.1

package/packages/core/src/storage/onboarding.ts

@@ -12,7 +12,7 @@ import { SkillLoader } from "../skills/index.ts";
 import type {
   UserDoc, ProviderDoc, ModelDoc, AgentDoc, ChannelDoc, McpServerDoc,
   UserIdentityDoc, OnboardingProgressDoc, EthicsDoc, SkillDoc, ToolDoc,
-} from "./collections.ts";
+} from "./collections";
 import { normalizeUserEmail } from "./user-email.ts";
 
 export interface OnboardingSection {
@@ -27,101 +27,117 @@ const log = logger.child("onboarding");
 const HIVE_SYSTEM_PROMPT = `
 # HIVE — Agente Coordinador
 
-Sos Bee, coordinador de Hive. Sos el único agente que conversa con el usuario, y no trabajás solo: dirigís una colmena de workers especializados que corren en paralelo.
+Eres el coordinador de Hive. Eres el único agente que conversa con el usuario, y no trabajas solo: diriges una colmena de workers especializados que corren en paralelo.
 
-**Tu oficio es repartir trabajo, no hacerlo todo vos.** Ante cada pedido buscás primero quién puede resolverlo; solo lo hacés con tus propias manos cuando no hay nadie que lo cubra.
+**Tu oficio es repartir trabajo, no hacerlo todo tú.** Ante cada pedido buscas primero quién puede resolverlo; solo lo haces con tus propias manos cuando no hay nadie que lo cubra.
 
 ## 1. ANTES DE ACTUAR
 
-Leé el pedido completo y mirá lo que ya sabés: la sección SCRATCHPAD trae tus notas de esta conversación y \`memory_read\` / \`memory_search\` lo guardado en conversaciones anteriores. No rehagas trabajo ya hecho ni vuelvas a preguntar algo que ya te dijeron.
+Lee el pedido completo y mira lo que ya sabes: la sección SCRATCHPAD trae tus notas de esta conversación y \`memory_read\` / \`memory_search\` lo guardado en conversaciones anteriores. No rehagas trabajo ya hecho ni vuelvas a preguntar algo que ya te dijeron.
 
-**Si es un saludo, una charla o una pregunta que respondés de memoria: respondé y terminá.** Eso no se delega nunca ni necesita herramientas.
+**Si es un saludo, una charla o una pregunta que respondes de memoria: responde y termina.** Eso no se delega nunca ni necesita herramientas.
 
-## 2. DESCOMPONER
+## 2. MAPA RÁPIDO DE ESPECIALISTAS
 
-Separá el pedido en partes y clasificá cada una:
+Para cualquier pedido operativo, compáralo primero con este mapa y delega al especialista más cercano:
 
-| Tipo de parte | Qué hacés |
+- \`web_researcher\`: investiga información actual en la web y entrega fuentes.
+- \`browser_operator\`: navega sitios, completa formularios y verifica el resultado.
+- \`workspace_file_operator\`: crea, lee, edita y organiza archivos del workspace.
+- \`software_engineer\`: implementa, depura y prueba software en un repositorio.
+- \`office_document_agent\`: lee y genera PDF, Word, Excel y PowerPoint.
+- \`a2ui_builder\`: construye formularios, dashboards y flujos interactivos A2UI.
+- \`schedule_automation_agent\`: crea y administra jobs, recordatorios y automatizaciones de Hive.
+- \`api_operator\`: ejecuta y verifica operaciones contra APIs REST autorizadas.
+- Especialistas MCP del usuario: workers con integraciones específicas; encuéntralos con \`agent_find\` antes de usar una tool MCP.
+
+**Regla de prioridad:** primero elige un agente de este mapa y usa \`task_delegate\`, pero verifica antes que aparezca activo en la COLMENA; el mapa describe roles y no garantiza disponibilidad. Si no está activo o ninguno encaja, busca otro worker con \`agent_find\`; solo después descubre herramientas y resuelve directamente. No delegues a un ID asumido ni elijas herramientas directas antes de hacer esta comprobación, salvo saludos, charla o preguntas que respondes de memoria.
+
+## 3. DESCOMPONER
+
+Separa el pedido en partes y clasifica cada una:
+
+| Tipo de parte | Qué haces |
 |---|---|
 | Independientes entre sí | Van juntas, en paralelo, en este mismo turno |
 | Una necesita el resultado de otra | Va en una fase posterior |
-| Trivial o conversacional | La resolvés vos, sin herramientas |
+| Trivial o conversacional | La resuelves tú, sin herramientas |
 
-## 3. POR CADA PARTE: ¿HAY UN AGENTE QUE LA HAGA?
+## 4. POR CADA PARTE: ¿HAY UN AGENTE QUE LA HAGA?
 
 **Esta es la pregunta central de tu rol, y contestarla es gratis:** el roster está en la sección COLMENA DE AGENTES de este mismo prompt, no hace falta ninguna llamada para consultarlo.
 
 1. **¿Encaja un agente de la colmena?** → \`task_delegate\`. Este es el camino por defecto.
 2. **¿Ninguno encaja?** → \`agent_find\` por si existe un worker propio para esa especialidad.
-3. **¿Tampoco hay?** → recién ahí \`search_knowledge\` para encontrar las herramientas. Preferí siempre herramientas nativas sobre MCP.
-4. **Si encontraste una tool nativa** → resolvelo vos directamente.
+3. **¿Tampoco hay?** → recién ahí \`search_knowledge\` para encontrar las herramientas. Prefiere siempre herramientas nativas sobre MCP.
+4. **Si encontraste una tool nativa** → resuélvelo tú directamente.
 5. **Si al menos una parte requiere MCP**:
-   - Agrupá las tools por \`server_id\` y usá \`agent_find\` para buscar un especialista del usuario que ya tenga ese servidor.
-   - Si existe y está habilitado, delegale la parte correspondiente. No preguntes ni crees otro.
-   - Si no existe, **antes de ejecutar cualquier tool de ese servidor**, preguntale al usuario si quiere crear un agente persistente para esa integración.
-   - Si acepta: usá \`get_available_models\`, descubrí \`agent_create\`, creá un worker con \`mcp_server_id\` y delegale la tarea actual. El agente recibe todas las tools actuales y futuras de ese servidor.
-   - Si rechaza: ejecutá vos directamente las tools MCP necesarias solo para esta solicitud.
-   - Si intervienen varios servidores sin especialista, tratá cada servidor por separado: un agente por servidor, nunca uno combinado.
+   - Agrupa las tools por \`server_id\` y usa \`agent_find\` para buscar un especialista del usuario que ya tenga ese servidor.
+   - Si existe y está habilitado, delégale la parte correspondiente. No preguntes ni crees otro.
+   - Si no existe, **antes de ejecutar cualquier tool de ese servidor**, pregúntale al usuario si quiere crear un agente persistente para esa integración.
+   - Si acepta: usa \`get_available_models\`, descubre \`agent_create\`, crea un worker con \`mcp_server_id\` y delégale la tarea actual. El agente recibe todas las tools actuales y futuras de ese servidor.
+   - Si rechaza: ejecuta tú directamente las tools MCP necesarias solo para esta solicitud.
+   - Si intervienen varios servidores sin especialista, trata cada servidor por separado: un agente por servidor, nunca uno combinado.
 
 ### CALENDARIO NO ES CRON
 
 - \`schedule_automation_agent\` administra jobs que Hive ejecutará después: tareas recurrentes, reportes automáticos, monitoreos y recordatorios de una sola ejecución.
 - Crear, consultar o modificar eventos, citas o reuniones; invitar asistentes; o revisar disponibilidad pertenece al servidor de calendario y a su especialista MCP.
-- Una frase como “agenda una reunión” significa calendario, no \`cron.create\`. Solo usá cron cuando el usuario quiere que Hive ejecute una instrucción en el futuro.
+- Una frase como “agenda una reunión” significa calendario, no \`cron.create\`. Solo usa cron cuando el usuario quiere que Hive ejecute una instrucción en el futuro.
 
-Si \`search_knowledge\` no devuelve nada y el pedido es corto o ambiguo, **preguntale al usuario** en vez de adivinar y encadenar más búsquedas. Una pregunta cuesta un turno; adivinar mal cuesta varios.
+Si \`search_knowledge\` no devuelve nada y el pedido es corto o ambiguo, **pregúntale al usuario** en vez de adivinar y encadenar más búsquedas. Una pregunta cuesta un turno; adivinar mal cuesta varios.
 
-## 4. DELEGAR EN PARALELO
+## 5. DELEGAR EN PARALELO
 
 Las partes independientes se lanzan **todas en el mismo turno**: una \`task_delegate\` por parte, con \`mode="async"\`. Hive las agrupa por turno y los workers corren simultáneamente.
 
 Si el usuario pide tres cosas que no dependen entre sí, son tres \`task_delegate\` en la misma respuesta — no una, esperar, y después la siguiente. **Paralelizar es el caso normal, no la excepción.**
 
-Cada delegación lleva: \`worker_id\`, una subtarea acotada, contexto mínimo y \`acceptance\` verificable. Antes de delegar, si el worker va a necesitar herramientas puntuales, buscalas con \`search_knowledge\` e incluilas en la instrucción. Reservá \`mode="sync"\` solo para un lookup cuyo resultado esperás en segundos.
+Cada delegación lleva: \`worker_id\`, una subtarea acotada, contexto mínimo y \`acceptance\` verificable. Antes de delegar, si el worker va a necesitar herramientas puntuales, búscalas con \`search_knowledge\` e inclúyelas en la instrucción. Reserva \`mode="sync"\` solo para un lookup cuyo resultado esperas en segundos.
 
-Si más adelante una entrega no cumple sus criterios, \`task_revise\` reencola al mismo worker sobre el mismo hilo (ver sección 6) — no crees una delegación nueva para corregir algo ya delegado.
+Si más adelante una entrega no cumple sus criterios, \`task_revise\` reencola al mismo worker sobre el mismo hilo (ver sección 7) — no crees una delegación nueva para corregir algo ya delegado.
 
-## 5. ESPERAR: NO ESPERÁS
+## 6. ESPERAR: NO ESPERAS
 
-Después de delegar, contale al usuario en una línea qué pusiste a correr y **terminá tu turno**.
+Después de delegar, cuéntale al usuario en una línea qué pusiste a correr y **termina tu turno**.
 
 Cuando todas las tareas del turno alcanzan estado terminal, Hive te reinvoca automáticamente con un mensaje \`[Sistema]\` que trae el resultado de cada una.
 
-- **No hagas polling** con \`task_status\` en loop. Usalo solo si el usuario pide el estado antes de tiempo.
-- No anuncies resultados que todavía no tenés ni declares éxito antes del \`[Sistema]\`.
+- **No hagas polling** con \`task_status\` en loop. Úsalo solo si el usuario pide el estado antes de tiempo.
+- No anuncies resultados que todavía no tienes ni declares éxito antes del \`[Sistema]\`.
 - No re-delegues una tarea porque "no contestó": ya está encolada.
 
-## 6. CERRAR
+## 7. CERRAR
 
 Al recibir el \`[Sistema]\`, cada entrega trae sus \`acceptance\` (criterios) y sus \`checks\` (resultado determinístico, sin LLM, ya calculado):
 
-- \`checks.status="passed"\` → un check automático ya lo confirmó. Aceptalo.
+- \`checks.status="passed"\` → un check automático ya lo confirmó. Acéptalo.
 - \`checks.status="failed"\` (implica \`ok=false\`) → no cumplió. Nunca lo reportes como éxito.
-- \`checks.status="unchecked"\` o ausente → no hay check automático para ese criterio: **vos sos quien juzga**, con el contenido y la evidencia que trae la entrega.
+- \`checks.status="unchecked"\` o ausente → no hay check automático para ese criterio: **tú eres quien juzga**, con el contenido y la evidencia que trae la entrega.
 
-Si una entrega no cumple sus criterios: usá \`task_revise\` con el \`task_id\` y un feedback concreto y accionable — el worker retoma con su contexto, no hace falta repetirle todo el pedido. Si el problema es trivial y tenés las tools, corregilo vos directamente en vez de re-delegar. No inventes trabajo ni evidencia.
+Si una entrega no cumple sus criterios: usa \`task_revise\` con el \`task_id\` y un feedback concreto y accionable — el worker retoma con su contexto, no hace falta repetirle todo el pedido. Si el problema es trivial y tienes las tools, corrígelo tú directamente en vez de re-delegar. No inventes trabajo ni evidencia.
 
-Cuando todo lo delegado en esta ronda cumple, escribí **una sola** respuesta final integrando todo. Las entradas con \`ok=false\` se reportan con su motivo real, nunca como éxito.
+Cuando todo lo delegado en esta ronda cumple, escribe **una sola** respuesta final integrando todo. Las entradas con \`ok=false\` se reportan con su motivo real, nunca como éxito.
 
-Guardá lo que vaya a servir después: \`save_note\` para esta conversación, \`memory_write\` para lo que deba sobrevivir a ella. Confirmá con el usuario antes de persistir datos suyos.
+Guarda lo que vaya a servir después: \`save_note\` para esta conversación, \`memory_write\` para lo que deba sobrevivir a ella. Confirma con el usuario antes de persistir datos suyos.
 
 ## REGLAS PERMANENTES
 
-1. **Ética primero** — Operás bajo un Código de Ética obligatorio que no podés ignorar.
-2. **Verdad de ejecución** — \`TaskDoc\`/\`JobDoc\` son la fuente de verdad. \`agent_find\` solo descubre workers; nunca prueba si algo está corriendo: para eso están \`task_list\` y \`task_status\`. Si \`task_delegate\` devuelve \`ok=true\` con \`task_id\`, \`job_id\` y \`run_id\`, la tarea se persistió de verdad y no es una simulación. Si una herramienta falla, reportá su resultado exacto: no inventes IDs, estados ni ejecuciones.
-3. **Vos aceptás las entregas** — cada entrega vuelve con sus criterios, su evidencia y el resultado de los checks determinísticos (ver sección 6). Si cumple, la integrás; si no, \`task_revise\` con feedback concreto, o la corregís vos si es trivial. Si un worker devuelve \`needs_input\`, vos formulás la pregunta al usuario con contexto.
-4. **Buscá antes de crear** — nunca crees un worker si el catálogo ya cubre la tarea.
+1. **Ética primero** — Operas bajo un Código de Ética obligatorio que no puedes ignorar.
+2. **Verdad de ejecución** — \`TaskDoc\`/\`JobDoc\` son la fuente de verdad. \`agent_find\` solo descubre workers; nunca prueba si algo está corriendo: para eso están \`task_list\` y \`task_status\`. Si \`task_delegate\` devuelve \`ok=true\` con \`task_id\`, \`job_id\` y \`run_id\`, la tarea se persistió de verdad y no es una simulación. Si una herramienta falla, reporta su resultado exacto: no inventes IDs, estados ni ejecuciones.
+3. **Tú aceptas las entregas** — cada entrega vuelve con sus criterios, su evidencia y el resultado de los checks determinísticos (ver sección 7). Si cumple, la integras; si no, \`task_revise\` con feedback concreto, o la corriges tú si es trivial. Si un worker devuelve \`needs_input\`, tú formulas la pregunta al usuario con contexto.
+4. **Busca antes de crear** — nunca crees un worker si el catálogo ya cubre la tarea.
 5. **Mínimo privilegio** — solo las herramientas necesarias a cada worker. La única excepción explícita es un especialista MCP aprobado por el usuario: recibe el servidor completo que figura en \`mcp_server_ids_json\`, nunca otros servidores.
-6. **Nunca \`cli_exec\` para cron** — usá \`cron.create\`, y preguntá al usuario cada cuánto ejecutar.
+6. **Nunca \`cli_exec\` para cron** — usa \`cron.create\`, y pregunta al usuario cada cuánto ejecutar.
 7. **Calendario ≠ cron** — los eventos y reuniones van al especialista MCP de calendario; cron solo programa futuras ejecuciones de Hive.
 
 ## QUÉ HAY EN TU CONTEXTO
 
-- **COLMENA DE AGENTES** — los workers disponibles ahora mismo. Consultalo antes de decidir nada.
-- **HERRAMIENTAS SIEMPRE DISPONIBLES** — con las que arrancás cada turno. El resto se descubre con \`search_knowledge\` y queda usable de inmediato.
+- **COLMENA DE AGENTES** — los workers disponibles ahora mismo. Consúltalo antes de decidir nada.
+- **HERRAMIENTAS SIEMPRE DISPONIBLES** — con las que arrancas cada turno. El resto se descubre con \`search_knowledge\` y queda usable de inmediato.
 - **SCRATCHPAD** — tus notas de esta conversación; sobreviven a la compresión del historial.
-- **PLAYBOOK APRENDIDO** — reglas aprendidas de turnos anteriores, ya filtradas por relevancia. Aplicalas.
-- **SKILLS DESCUBIERTAS** — nombres de skills que el sistema considera relevantes para este pedido. Son una pista, no instrucciones: su contenido llega cuando descubrís sus herramientas con \`search_knowledge\`.
+- **PLAYBOOK APRENDIDO** — reglas aprendidas de turnos anteriores, ya filtradas por relevancia. Aplícalas.
+- **SKILLS DESCUBIERTAS** — nombres de skills que el sistema considera relevantes para este pedido. Son una pista, no instrucciones: su contenido llega cuando descubres sus herramientas con \`search_knowledge\`.
 
 ## CANALES
 
@@ -423,7 +439,7 @@ export async function propagateCoordinatorModel(
   providerId: string,
   modelId: string,
 ): Promise<number> {
-  const { applyCoordinatorModel } = await import("../agent/agent-catalog.ts");
+  const { applyCoordinatorModel } = await import("../agent/agent-catalog");
   const updated = await applyCoordinatorModel({ userId, providerId, modelId, overwrite: true });
   if (updated > 0) {
     log.info(`✅ ${updated} agente(s) sincronizados con el modelo del coordinador`, { providerId, modelId });

package/packages/core/src/storage/reconcile.ts

@@ -100,7 +100,12 @@ export async function reconcileOnBoot(bootId: string): Promise<ReconcileResult>
         result.runsInterrupted++;
         try {
           if (run.channel && run.user_id) {
-            await sendToUserChannel(run.channel, run.user_id, "Se interrumpió un turno en progreso por un reinicio del proceso.");
+            await sendToUserChannel(
+              run.channel,
+              run.user_id,
+              "Se interrumpió un turno en progreso por un reinicio del proceso.",
+              { threadId: run.thread_id }
+            );
           }
         } catch {
           // non-critical

package/packages/core/src/storage/seed.ts

@@ -57,6 +57,8 @@ export const SEED_DATA: SeedData = {
     { id: "computer_use_task", name: "computer_use_task", category: "web", description: "Operar el navegador de Hive mirando la pantalla: clic por coordenadas, escribir y navegar cuando no hay selector estable. Sinónimos: usar el navegador, hacer clic, operar una página, rellenar formulario, computer use" },
     { id: "artifact_inspect", name: "artifact_inspect", category: "web", description: "Inspeccionar integridad y metadatos de un artefacto administrado sin modificarlo. Sinónimos: inspeccionar artefacto, verificar archivo generado, metadatos artefacto, comprobar entrega" },
     { id: "artifact_read", name: "artifact_read", category: "web", description: "Leer por partes el contenido de texto de un artefacto administrado, o buscar dentro de él. Sinónimos: leer artefacto, ver contenido del artefacto, abrir resultado grande, buscar dentro del artefacto, leer artifact_ref" },
+    { id: "image_metadata", name: "image_metadata", category: "images", description: "Leer dimensiones y formato de una imagen guardada sin cargarla al contexto. Sinónimos: medir imagen, dimensiones de la imagen, tamaño de la foto, formato de imagen" },
+    { id: "image_transform", name: "image_transform", category: "images", description: "Redimensionar, rotar o convertir de formato una imagen guardada, devolviendo un artefacto nuevo. Sinónimos: redimensionar imagen, cambiar tamaño, convertir a webp, comprimir imagen, rotar foto, achicar imagen" },
     { id: "browser_click", name: "browser_click", category: "web", description: "Hacer clic en un elemento de la página web. Sinónimos: botón, enlace, interactuar, presionar, seleccionar" },
     { id: "browser_type", name: "browser_type", category: "web", description: "Escribir texto en un campo de formulario. Sinónimos: escribir formulario, tipear, campo de texto, input, llenar campo" },
     { id: "browser_extract", name: "browser_extract", category: "web", description: "Extraer texto, enlaces o datos estructurados usando selectores CSS o XPath. Sinónimos: obtener datos, scraping, selectores, extraer información" },
@@ -64,7 +66,7 @@ export const SEED_DATA: SeedData = {
     { id: "browser_wait", name: "browser_wait", category: "web", description: "Esperar a que aparezca un elemento o se cumpla una condición. Sinónimos: esperar, condición, elemento, selector, pausa" },
 
     // ─────────────────────────────────────────
-    // 3. CRON — Tareas programadas (Croner-based)
+    // 3. CRON — Tareas programadas
     // ─────────────────────────────────────────
     { id: "cron.create", name: "cron.create", category: "cron", description: "Crear una automatización de Hive programada: recurrente (expresión cron) o ejecución futura única (fire_at). Requiere 'task'. Sinónimos: programar tarea, crear automatización, ejecutar después, tarea recurrente, una vez" },
     { id: "cron.list", name: "cron.list", category: "cron", description: "Listar todas las tareas programadas con próximos horarios de ejecución. Sinónimos: ver tareas programadas, listar cronograma, próximas ejecuciones" },
@@ -423,7 +425,9 @@ import { SkillLoader } from "../skills/index.ts"
 import type {
   ToolDoc, SkillDoc, EthicsDoc, ProviderDoc, ModelDoc, McpServerDoc, ChannelDoc, PlaybookDoc, AgentDoc,
 } from "./collections.ts"
-import { createSeedCatalogAgents, ensureAgentsConfigured } from "../agent/agent-catalog.ts"
+import { createSeedCatalogAgents, ensureAgentsConfigured, requiredCapabilitiesFor } from "../agent/agent-catalog.ts"
+import { MINIMAL_TOOLS } from "../agent/minimal-loadout.ts"
+import { expandToolAllowlist } from "../agent/delegation-runtime.ts"
 
 const log = logger.child("seed");
 
@@ -557,13 +561,19 @@ const LEGACY_CRON_PERSONA = {
 function migrateLegacyCatalogPersona(existing: AgentDoc, current: AgentDoc): AgentDoc {
   if (existing.id !== LEGACY_CRON_PERSONA.id || existing.source !== "catalog") return existing;
 
-  let systemPrompt = existing.system_prompt;
+  // `system_prompt` es nullable en AgentDoc y esto corre en cada arranque: una
+  // fila sin prompt hacía estallar el seed entero con un TypeError, no un error
+  // de datos. Sin prompt no hay nada que migrar, así que se devuelve tal cual.
+  if (existing.system_prompt === null) return existing;
+
+  let systemPrompt: string = existing.system_prompt;
+  const currentPrompt = current.system_prompt ?? "";
   const hasLegacyStockPrompt = systemPrompt.includes(LEGACY_CRON_PERSONA.role)
     && systemPrompt.includes(LEGACY_CRON_PERSONA.receives);
   if (hasLegacyStockPrompt) {
     systemPrompt = systemPrompt
-      .replace(LEGACY_CRON_PERSONA.role, current.system_prompt.match(/# ROL\n([^\n]+)/)?.[1] ?? LEGACY_CRON_PERSONA.role)
-      .replace(LEGACY_CRON_PERSONA.receives, current.system_prompt.match(/# QUÉ RECIBES\n([^\n]+)/)?.[1] ?? LEGACY_CRON_PERSONA.receives);
+      .replace(LEGACY_CRON_PERSONA.role, currentPrompt.match(/# ROL\n([^\n]+)/)?.[1] ?? LEGACY_CRON_PERSONA.role)
+      .replace(LEGACY_CRON_PERSONA.receives, currentPrompt.match(/# QUÉ RECIBES\n([^\n]+)/)?.[1] ?? LEGACY_CRON_PERSONA.receives);
     if (!systemPrompt.includes(LEGACY_CRON_PERSONA.calendarProhibition)) {
       systemPrompt = systemPrompt.replace(
         "- No hablás con el usuario",
@@ -621,7 +631,32 @@ async function pruneRetired(): Promise<void> {
   if (removed > 0) log.info(`[seed] 🗑️  Removed ${removed} retired capability row(s)`);
 }
 
-async function reseedToolsAndSkills(): Promise<void> {
+/**
+ * Qué tools y skills deben nacer activas, según los especialistas elegidos.
+ *
+ * `null` = todas, que es el modo `"all"`. En cualquier otro modo la elección
+ * gobierna también las capacidades: un arranque `"none"` con las 62 tools
+ * activas sería contradecir el punto entero —ningún especialista instalado y
+ * todas las herramientas encendidas—, y el usuario terminaría apagándolas a
+ * mano una por una.
+ *
+ * Sólo afecta a las filas **nuevas**: `active` de una fila existente es la
+ * elección del usuario y sobrevive a todos los arranques.
+ */
+function capacidadesIniciales(
+  especialistas: SpecialistSeedMode,
+): { tools: Set<string>; skills: Set<string> } | null {
+  if (especialistas === "all") return null
+  const elegidos = especialistas === "none" ? [] : especialistas
+  const { toolPatterns, skills } = requiredCapabilitiesFor(elegidos)
+  return {
+    tools: new Set([...MINIMAL_TOOLS, ...expandToolAllowlist(toolPatterns)]),
+    skills: new Set(skills),
+  }
+}
+
+async function reseedToolsAndSkills(especialistas: SpecialistSeedMode = "all"): Promise<void> {
+  const iniciales = capacidadesIniciales(especialistas);
   // Seeding only writes the rows; the search index is rebuilt from them at
   // startup by the sync pass in gateway/initializer.ts.
 
@@ -630,9 +665,17 @@ async function reseedToolsAndSkills(): Promise<void> {
   const now = Date.now();
   let toolCount = 0;
   for (const tool of SEED_DATA.tools) {
+    // La descripción y la categoría vienen del código y se sobrescriben —son la
+    // fuente de verdad—, pero `active` NO: es la elección del usuario sobre qué
+    // capacidades quiere en su colmena (services/setup.ts). Pisarla en cada
+    // arranque haría que el seed selectivo durara hasta el próximo reinicio.
+    const existing = await toolsCol.get(tool.id);
     await toolsCol.put(tool.id, {
       id: tool.id, name: tool.name, description: tool.description, category: tool.category,
-      enabled: true, active: true, created_at: now, updated_at: now,
+      enabled: existing?.doc.enabled ?? true,
+      active: existing?.doc.active ?? (iniciales ? iniciales.tools.has(tool.name) : true),
+      created_at: existing?.doc.created_at ?? now,
+      updated_at: now,
     });
     toolCount++;
   }
@@ -646,6 +689,9 @@ async function reseedToolsAndSkills(): Promise<void> {
 
   let skillCount = 0;
   for (const s of realSkills) {
+    // Igual que con las tools: el contenido viene del archivo, pero `active` es
+    // del usuario y sobrevive al reseed.
+    const existingSkill = await skillsCol.get(s.name);
     await skillsCol.put(s.name, {
       id: s.name,
       name: s.name,
@@ -661,8 +707,8 @@ async function reseedToolsAndSkills(): Promise<void> {
       preferred_agents: JSON.stringify(s.preferred_agents || []),
       body: s.content || "",
       version_num: parseInt(String(s.version || "0.0.1").split(".")[0]) || 1,
-      active: true,
-      created_at: now,
+      active: existingSkill?.doc.active ?? (iniciales ? iniciales.skills.has(s.name) : true),
+      created_at: existingSkill?.doc.created_at ?? now,
       updated_at: now,
     });
     skillCount++;
@@ -672,10 +718,30 @@ async function reseedToolsAndSkills(): Promise<void> {
   await pruneRetired();
 }
 
-export async function seedAllData(): Promise<void> {
+/**
+ * Qué especialistas del catálogo crear en el arranque.
+ *
+ * - `"all"` — los 8. Comportamiento histórico y default.
+ * - `"none"` — ninguno. La colmena arranca con el coordinador y nada más; los
+ *   especialistas se crean cuando el usuario arma el enjambre que los pide.
+ *   Es el modo para un producto donde cada quien elige su equipo.
+ * - lista — sólo esos.
+ *
+ * **Nunca borra.** Los que ya existen en la base se siguen reconciliando en
+ * cada arranque, elija lo que elija: una instalación que ya tiene sus ocho
+ * agentes no los pierde por cambiar esta opción.
+ */
+export type SpecialistSeedMode = "all" | "none" | string[]
+
+export interface SeedOptions {
+  specialists?: SpecialistSeedMode
+}
+
+export async function seedAllData(opts?: SeedOptions): Promise<void> {
   log.info("[seed] 🌱 Iniciando seed de datos predeterminados...")
+  const especialistas = opts?.specialists ?? "all"
 
-  await reseedToolsAndSkills();
+  await reseedToolsAndSkills(especialistas);
 
   try {
     const now = Date.now();
@@ -830,9 +896,22 @@ export async function seedAllData(): Promise<void> {
     // factory values from older releases are migrated in place.
     let catalogAgentCount = 0;
     let repairedCatalogSkills = 0;
+    const quiereEspecialista = (id: string) =>
+      especialistas === "all" ? true
+      : especialistas === "none" ? false
+      : especialistas.includes(id);
+
     for (const catalogAgent of createSeedCatalogAgents()) {
-      await putIfAbsent(agentsCol, catalogAgent.id, catalogAgent);
-      const existing = await agentsCol.get(catalogAgent.id);
+      // Sembrar sólo los elegidos, pero seguir reconciliando los que ya
+      // existan: la elección gobierna qué se CREA, nunca qué se conserva. Una
+      // base que ya trae los ocho no los pierde por arrancar con "none", y
+      // tampoco se queda sin las migraciones de abajo.
+      let existing = await agentsCol.get(catalogAgent.id);
+      if (!existing) {
+        if (!quiereEspecialista(catalogAgent.id)) continue;
+        await putIfAbsent(agentsCol, catalogAgent.id, catalogAgent);
+        existing = await agentsCol.get(catalogAgent.id);
+      }
       if (!existing || existing.doc.source !== "catalog") {
         catalogAgentCount++;
         continue;
@@ -925,12 +1004,17 @@ export async function seedAllData(): Promise<void> {
       const existing = byRule.get(rule.rule);
       if (existing) {
         await playbookCol.put(existing.id, {
-          ...existing.doc, category: rule.category, applicable_to: rule.applicable_to, active: true, updated_at: now,
+          // `user_id: ""` va explícito y no heredado de `existing.doc`: en una
+          // base anterior a este campo las filas sembradas no lo tienen, y son
+          // justamente las que deben ser globales.
+          ...existing.doc, category: rule.category, applicable_to: rule.applicable_to, user_id: "", active: true, updated_at: now,
         }, { expectedVersion: existing.version });
       } else {
         const id = await nextId("playbook");
         await playbookCol.put(id, {
           id, rule: rule.rule, category: rule.category, applicable_to: rule.applicable_to,
+          // Conocimiento del producto, no aprendido de nadie: aplica a todos.
+          user_id: "",
           helpful_count: 1, harmful_count: 0, active: true,
           source_reflection_id: toIndexable(null), created_at: now, updated_at: now,
         });

package/packages/core/src/swarm/types.ts

@@ -1,12 +1,12 @@
 /**
  * Hive Scheduler - Type Definitions
  * 
- * Type interfaces for the Croner-based scheduling system.
+ * Type interfaces for the scheduling system.
  * All names use "CronJob" terminology (formerly ScheduledTask).
  */
 
 import type { Database } from "bun:sqlite";
-import type { Cron } from "croner";
+import type { Cron } from "../scheduler/cron/index.ts";
 
 /**
  * Task type: recurring uses cron expression, one_shot uses fire_at
@@ -141,24 +141,9 @@ export interface CronJobExecutionResult {
 }
 
 /**
- * Internal job wrapper holding Croner instance and metadata
+ * Internal job wrapper holding the scheduled job and its metadata
  */
 export interface CronJobEntry {
   job: CronJob;
   cron: Cron;
 }
-
-/**
- * Options for Croner job creation
- */
-export interface CronerOptions {
-  timezone: string;
-  protect: boolean;
-  catch: boolean | ((error: Error) => void);
-  name: string;
-  maxRuns?: number;
-  interval?: number;
-  startAt?: string;
-  stopAt?: string;
-  domAndDow?: boolean;
-}

package/packages/core/src/tool-runtime/embedded-worker.generated.ts

@@ -0,0 +1,21 @@
+// Auto-generado — NO EDITAR.
+//
+// En este paquete el valor es SIEMPRE null, y así debe quedarse: el SDK se
+// publica como fuente, no como ejecutable standalone, así que el worker se
+// resuelve desde disco (tool-worker.ts al lado de este archivo, o
+// dist/tool-worker.js junto al bundle).
+//
+// El archivo existe porque el gateway de hive sí compila un binario, y ahí su
+// `scripts/build-gateway.ts` reescribe este stub antes de compilar con:
+//
+//   import workerFile from "./tool-worker.generated.js" with { type: "file" }
+//   export const embeddedToolWorkerPath: string | null = workerFile
+//
+// Ese `with { type: "file" }` es lo que mete el bundle del worker dentro del
+// ejecutable, porque `new Worker(new URL("./tool-worker.ts", import.meta.url))`
+// NO se embebe solo: el path se resuelve en runtime y el bundler no lo ve.
+// Sin eso la app de escritorio se instalaba sin worker y cualquier turno con
+// más de una tool call moría con "Tool worker entry not found" (v1.0.3 y
+// anteriores). Mantener el símbolo acá deja que `tool-runtime/index.ts` sea el
+// mismo archivo en los dos repos.
+export const embeddedToolWorkerPath: string | null = null