dtic-DIIAA/docs/ambito/dtic-ADN/A01.P009_Evolucion-Dron-ADN.md

A01.P009 - Evolución del Ecosistema ADN al Concepto de Dron

Estado: ⏳ En Planificación
Pertenece a: A01 - Ecosistema ADN
Fecha: 2026-04-07
Responsable: Lic. Ricardo MONLA
Versión: 2.0 — Filosofía AtomicDrones

---

📋 Resumen Ejecutivo

Este plan define la evolución del ecosistema ADN hacia una arquitectura de Inteligencia de Colmena basada en AtomicDrones — drones atómicos especializados que, compuestos, forman una maquinaria autónoma integral.

Filosofía de Diseño:

Principio	Descripción
🧬 AtomicDrones	Cada dron hace UNA cosa y la hace bien. Sin monolitos.
🤖 Inteligencia de Colmena	La solución emerge de la composición de drones simples.
⚙️ Engranajes Especializados	Drones ejecutores, vigilantes, sanadores, planificadores.
🚫 No FrankenDrones	Rechazar drones que intentan hacer todo mal.

Concepto de Dron ADN:

• Atómico: Una responsabilidad única (Single Responsibility)
• Componible: Se ensambla con otros drones para soluciones complejas
• Auto-bitácora: Registra inicio/fin automáticamente
• Observable: Estado visible vía dron flota y dashboard web
• Efímero: Nace, ejecuta, muere (sin estado persistente innecesario)

---

🎯 Objetivo

Evolucionar el ecosistema ADN hacia una colonia de AtomicDrones especializados que, compuestos, resuelven problemas complejos mediante inteligencia de colmena.

Meta: Reducir la fricción operativa mediante drones atómicos que se especializan en una tarea única y se componen para flujos complejos.

---

🐝 Tipos de AtomicDrones (Especialización)

Cada tipo de dron tiene una única responsabilidad. La composición de múltiples drones resuelve problemas complejos.

Tipo	Símbolo	Responsabilidad	Ejemplo
Ejecutor	🛠️	Ejecuta un comando y reporta resultado	dron_ejecutor
Vigilante	👁️	Monitorea estado de otros drones	dron_vigilante
Sanador	🩹	Repara drones zombies/fallidos	dron_sanador
Planificador	📅	Lanza drones según cron	dron_planificador
Mensajero	📨	Notifica resultados (Slack, email)	dron_mensajero
Orquestador	🎼	Compone múltiples drones en flujo	dron_orquestador

Ejemplo de Composición (Inteligencia de Colmena)

Problema: Backup nocturno de SQL + sync a nube + notificación

Solución FrankenDron (❌ rechazar):

# Un solo dron que hace todo (monolito frágil)
dron_backup_nocturno.rb # 500 líneas, 7 responsabilidades

Solución AtomicDrones (✅ adoptar):

# Orquestador compone 4 drones especializados
dron_orquestador \
  --step "dron_ejecutor --cmd 'vzdump 103'" \
  --step "dron_ejecutor --cmd 'rclone sync /bkps oneDrive:'" \
  --step "dron_vigilante --check exit_code" \
  --step "dron_mensajero --notify slack 'Backup OK'"

---

📡 Medio de Comunicación: Bitácora Web como Registro Central

La Bitácora Web es el medio de comunicación donde los drones dejan registro de su actividad. El sistema sigue el principio DB-First con capas de visibilidad.

Arquitectura de Registros

┌─────────────────────────────────────────────────────────────────┐
│  DRONES (Ejecutores, Vigilantes, Sanadores, etc.)               │
│  Cada dron deja registro al ejecutar                            │
└────────────┬────────────────────────────────────────────────────┘
             │ registra
             ▼
┌─────────────────────────────────────────────────────────────────┐
│  CAPA 1: Tablas Internas (NO visibles directamente)             │
│  - bitacoras.dron_logs: Logs detallados de cada dron           │
│  - bitacoras.dron_avances: Progreso paso-a-paso                │
│  - bitacoras.dron_metricas: Métricas de rendimiento            │
│  - bitacoras.dron_errores: Errores y reintentos                │
└────────────┬────────────────────────────────────────────────────┘
             │
             │ dron_vigilante consolida
             ▼
┌─────────────────────────────────────────────────────────────────┐
│  CAPA 2: Bitácora Web (Resumen visible)                         │
│  - events: Eventos consolidados por flujo/orquestación         │
│  - Descripción: Resumen legible del progreso                   │
│  - Estado: ⏳ En ejecución | ✅ Completado | ❌ Fallido         │
│  - URL: http://localhost:5174/bitacoras/                       │
└─────────────────────────────────────────────────────────────────┘

Tablas Internas (Esquema bitacoras)

-- Logs detallados de cada dron (NO visible en web directamente)
CREATE TABLE bitacoras.dron_logs (
    id              SERIAL PRIMARY KEY,
    dron_id         VARCHAR(50) NOT NULL,        -- ej: dron_083045_123
    flujo_id        VARCHAR(50),                  -- ID de orquestación (si aplica)
    tipo            VARCHAR(20) NOT NULL,         -- ejecutor|vigilante|sanador|planificador|mensajero
    estado          VARCHAR(20) NOT NULL,         -- pending|running|completed|failed|zombie
    cmd             TEXT,                         -- Comando ejecutado
    output          TEXT,                         -- Salida del comando
    exit_code       INTEGER,                      -- Código de retorno
    started_at      TIMESTAMP DEFAULT NOW(),
    completed_at    TIMESTAMP,
    heartbeat       TIMESTAMP DEFAULT NOW(),      -- Último heartbeat
    reintentos      INTEGER DEFAULT 0,
    metadata        JSONB DEFAULT '{}'::jsonb     -- Metadata adicional
);

-- Avances paso-a-paso (para flujos multi-paso)
CREATE TABLE bitacoras.dron_avances (
    id              SERIAL PRIMARY KEY,
    dron_id         VARCHAR(50) NOT NULL,
    paso            INTEGER NOT NULL,             -- Número de paso en flujo
    descripcion     TEXT NOT NULL,                -- Qué se está haciendo
    estado          VARCHAR(20) NOT NULL,         -- pending|running|completed|failed
    started_at      TIMESTAMP DEFAULT NOW(),
    completed_at    TIMESTAMP,
    metadata        JSONB DEFAULT '{}'::jsonb
);

-- Métricas de rendimiento (agregaciones)
CREATE TABLE bitacoras.dron_metricas (
    id              SERIAL PRIMARY KEY,
    fecha           DATE NOT NULL,
    dron_tipo       VARCHAR(20) NOT NULL,
    total_ejecuciones INTEGER DEFAULT 0,
    completados     INTEGER DEFAULT 0,
    fallidos        INTEGER DEFAULT 0,
    zombies         INTEGER DEFAULT 0,
    tiempo_promedio INTERVAL,
    reintentos_total INTEGER DEFAULT 0,
    UNIQUE(fecha, dron_tipo)
);

-- Índices para consultas eficientes
CREATE INDEX idx_dron_logs_estado ON bitacoras.dron_logs(estado);
CREATE INDEX idx_dron_logs_heartbeat ON bitacoras.dron_logs(heartbeat);
CREATE INDEX idx_dron_logs_flujo ON bitacoras.dron_logs(flujo_id);
CREATE INDEX idx_dron_avances_dron ON bitacoras.dron_avances(dron_id);

Dron Vigilante: El Monitor de Flotas

El dron_vigilante es responsable de:

1. Escanear flota: Lee bitacoras.dron_logs para detectar drones activos
2. Detectar zombies: heartbeat > 5min → marca como zombie
3. Registrar avances: Inserta en bitacoras.dron_avances el progreso
4. Consolidar resumen: Crea/actualiza evento en bitacoras.events (visible en web)
5. Alertar anomalías: Si detecta >5 fallos en 1h → notifica

# Ejemplo: dron_vigilante escanea y registra avances
class DronVigilante
  def escanear_flota
    drones_activos = DronDB.where("estado = 'running' AND heartbeat < ?", 5.minutes.ago)
    
    drones_activos.each do |dron|
      # Marcar como zombie
      dron.update(estado: 'zombie')
      
      # Registrar en avances
      DronAvance.create(
        dron_id: dron.id,
        paso: -1,
        descripcion: "Dron detectado como zombie (heartbeat > 5min)",
        estado: 'failed'
      )
      
      # Consolidar resumen en events (visible en Bitácora Web)
      consolidar_resumen(dron.flujo_id)
    end
  end
  
  def consolidar_resumen(flujo_id)
    # Obtener todos los logs del flujo
    logs = DronLog.where(flujo_id: flujo_id)
    
    # Calcular estado consolidado
    estado = if logs.all? { |l| l.estado == 'completed' }
               'completed'
             elsif logs.any? { |l| l.estado == 'failed' }
               'failed'
             else
               'running'
             end
    
    # Actualizar/crear evento resumen (visible en Bitácora Web)
    Evento.find_or_create_by(flujo_id: flujo_id).update(
      descripcion: "Flujo #{flujo_id}: #{logs.count} drones - #{estado}",
      estado: estado
    )
  end
end

Bitácora Web: Lo que el Usuario Ve

La Bitácora Web (http://localhost:5174/bitacoras/) muestra:

Columna	Contenido
ID	ID del evento resumen
I	Hora de inicio del flujo
F	Hora de fin (si completado)
Descripción	Resumen consolidado (ej: "Backup nocturno: 4 drones completados")
J	Modo (P=Presencial, R=Remoto, A=Automático)
E	Estado (⏳, ✅, ❌)
Acc.	Acciones (ver detalle, reintentar)

Al hacer clic en "ver detalle":

• Muestra tabla con drones individuales y su estado
• Muestra avances paso-a-paso del flujo
• Muestra métricas de rendimiento (tiempo, reintentos)

---

📊 Estado Actual (Línea Base)

Herramientas Existentes

Herramienta	Ubicación	Tipo	Estado
dron.rb	adn/tools/cli/dron.rb	Orquestador básico	✅ Operativo
dron lanzar	Subcomando CLI	Ejecutor	✅ Funcional
dron flota	Dashboard	Vigilante	✅ Implementado
dron salud	Health check	Sanador	✅ Implementado
dron limpiar	Limpieza	Sanador	✅ Implementado

Capacidades Actuales

# Ejecutor (lanzar tarea con auto-bitácora)
./adn/tools/run dron lanzar --evento AUTO --nota "Backup" -- <cmd>

# Vigilante (ver flota)
./adn/tools/run dron flota

# Sanador (health check + limpiar)
./adn/tools/run dron salud
./adn/tools/run dron limpiar

Limitaciones Detectadas (Deuda de Atomicidad)

#	Limitación	Tipo	Impacto	Prioridad
1	dron.rb es monolítico	FrankenDron	Difícil de extender	Alta
2	Sin persistencia entre sesiones	Ejecutor	Drones se pierden al reiniciar	Alta
3	Sin reintentos automáticos	Sanador	Tareas fallidas no se recuperan	Media
4	Sin planificación (cron)	Planificador	Requiere lanzamiento manual	Alta
5	Sin composición de drones	Orquestador	No hay flujos multi-paso	Media
6	Sin métricas históricas	Vigilante	No se puede analizar rendimiento	Baja

---

🗺️ Fases de Implementación

Fase 0: Infraestructura de Datos (Dron 0.5) — PRIORITARIA

Objetivo: Crear tablas internas para registro detallado de drones.

ID	Tarea	Descripción	Estado
F0.T1	Migración 003_dron_logs.sql	Tabla bitacoras.dron_logs	⏳
F0.T2	Migración 004_dron_avances.sql	Tabla bitacoras.dron_avances	⏳
F0.T3	Migración 005_dron_metricas.sql	Tabla bitacoras.dron_metricas	⏳
F0.T4	adn/tools/db/core/dron_db.rb	Acceso a datos de drones	⏳
F0.T5	Hooks DB-First	Auto-registro en dron_logs al lanzar	⏳

Criterio de éxito: Drones pueden registrar actividad en tablas internas sin tocar events directamente.

---

Fase 1: Atomicidad — Separación de Responsabilidades (Dron 1.0)

Objetivo: Refactorizar el monolito dron.rb en módulos atómicos especializados.

ID	Tarea	Tipo de Dron	Estado
F1.T1	dron/ejecutor.rb	Ejecutor — lanza y monitorea comando	⏳
F1.T2	dron/vigilante.rb	Vigilante — escanea flota, detecta zombies	⏳
F1.T3	dron/sanador.rb	Sanador — re-intenta, limpia, notifica fallos	⏳
F1.T4	dron/bitacora.rb	Registrador — auto-bitácora (inicio/fin)	⏳
F1.T5	dron/dispatcher.rb	Orquestador — dispatch de subcomandos	⏳

Criterio de éxito: Cada módulo tiene una única responsabilidad. Sin código duplicado.

---

Fase 2: Composición — Orquestación de Flujos (Dron 1.5)

Objetivo: Permitir composición de drones para flujos multi-paso.

ID	Tarea	Descripción	Estado
F2.T1	dron/orquestador.rb	Ejecuta pasos secuenciales (--step)	⏳
F2.T2	Condicionales	--on-error continue|abort|retry	⏳
F2.T3	Paralelismo	--parallel para pasos independientes	⏳
F2.T4	Contexto compartido	Variables entre pasos ($DRON_OUTPUT_N)	⏳

Ejemplo:

./adn/tools/run dron orquestar \
  --step "dron_ejecutor --cmd 'vzdump 103'" \
  --step "dron_ejecutor --cmd 'rclone sync /bkps oneDrive:'" \
  --step "dron_mensajero --notify 'Backup OK'" \
  --on-error abort

Criterio de éxito: Flujos complejos se expresan como composición de drones simples.

---

Fase 3: Planificación — Drones Programados (Dron 2.0)

Objetivo: Ejecución automática según cron.

ID	Tarea	Tipo de Dron	Estado
F3.T1	dron/planificador.rb	Planificador — lee cron y lanza drones	⏳
F3.T2	Persistencia de schedules	~/.claude/scheduled_tasks.json	⏳
F3.T3	CLI schedules	schedule add|list|remove	⏳
F3.T4	Integración CronCreate	SDK de Claude Code	⏳

Criterio de éxito: Tareas recurrentes se lanzan automáticamente.

---

Fase 4: Inteligencia de Colmena — Comunicación entre Drones (Dron 3.0)

Objetivo: Drones se comunican y coordinan para resolver problemas.

ID	Tarea	Descripción	Estado
F4.T1	Cola de eventos	Redis o archivo compartido para eventos	⏳
F4.T2	Publicar/ Suscribirse	Drones publican eventos, otros reaccionan	⏳
F4.T3	Patrones de reacción	on failed → sanador, on completed → mensajero	⏳
F4.T4	Feromonas digitales	Señales químicas virtuales (/tmp/dron_pheromones/)	⏳

Ejemplo de flujo emergente:

1. Ejecutor falla → publica "failed" en cola
2. Sanador escucha → re-intenta (máx 3 veces)
3. Si falla → publica "critical"
4. Mensajero escucha → notifica por Slack

Criterio de éxito: Soluciones complejas emergen sin orquestador central.

---

Fase 5: Observabilidad — Dashboard y Métricas (Dron 4.0)

Objetivo: Visibilidad completa de la colonia.

ID	Tarea	Tipo de Dron	Estado
F5.T1	API /api/drones	Endpoint para listar drones	⏳
F5.T2	API /api/drones/:id/avances	Endpoint para avances de un dron	⏳
F5.T3	Dashboard web	http://localhost:5174/drones	⏳
F5.T4	Gráficas	Tareas por día, tasa de éxito, tiempos	⏳
F5.T5	Alertas proactivas	dron_vigilante detecta anomalías	⏳

Criterio de éxito: Visibilidad completa vía web dashboard y métricas históricas.

---

📈 Progreso

Fase 0:  ░░░░░░░░░░   0%  Infraestructura de Datos (tablas internas)
Fase 1:  ░░░░░░░░░░   0%  Atomicidad — Separación de Responsabilidades (Dron 1.0)
Fase 2:  ░░░░░░░░░░   0%  Composición — Orquestación de Flujos (Dron 1.5)
Fase 3:  ░░░░░░░░░░   0%  Planificación — Drones Programados (Dron 2.0)
Fase 4:  ░░░░░░░░░░   0%  Inteligencia de Colmena (Dron 3.0)
Fase 5:  ░░░░░░░░░░   0%  Observabilidad — Dashboard y Métricas (Dron 4.0)

---

🏗️ Arquitectura de Colmena

Diagrama de Flujo (Inteligencia de Colmena)

┌──────────────────────────────────────────────────────────────────┐
│  PLANIFICADOR (dron_planificador)                                │
│  - Lee ~/.claude/scheduled_tasks.json                           │
│  - Publica evento "scheduled" en cola                           │
└─────────────┬────────────────────────────────────────────────────┘
              │ publica
              ▼
┌──────────────────────────────────────────────────────────────────┐
│  COLA DE EVENTOS (/tmp/dron_queue/)                             │
│  - Archivos por evento: {tipo, payload, timestamp}              │
│  - Escuchado por suscriptores                                   │
└─────────────┬────────────────────────────────────────────────────┘
              │
    ┌─────────┼─────────┬─────────────────┐
    │         │         │                 │
    ▼         ▼         ▼                 ▼
┌────────┐ ┌────────┐ ┌────────┐  ┌──────────┐
│EJECUTOR│ │VIGILANTE│ │SANADOR│  │MENSAJERO │
│🛠️     │ │👁️     │ │🩹     │  │📨        │
│Escucha │ │Escanea│ │Escucha │  │Escucha   │
│"run"   │ │flota  │ │"failed"│  │"notify"  │
└───┬────┘ └───┬────┘ └───┬────┘  └────┬─────┘
    │          │         │            │
    │          │         │            │ publica "alert"
    │          │         │            ▼
    │          │         │      ┌─────────────┐
    │          │         │      │SLACK/EMAIL  │
    │          │         │      └─────────────┘
    │          │         │
    │          │         └─→ Re-intenta (máx 3)
    │          │              Backoff: 1m, 2m, 4m
    │          │
    │          └─→ Detecta zombies (heartbeat > 5min)
    │               Publica "zombie_detected"
    │
    └─→ Ejecuta cmd
         Registra en bitácora (AUTO)
         Publica "completed" o "failed"

Principios de Diseño

Principio	Aplicación
Single Responsibility	Cada dron hace UNA cosa
Composability	Drones se ensamblan en flujos
Event-Driven	Comunicación vía cola de eventos
Stateless	Drones no guardan estado (efímeros)
Observable	Todo evento se registra en DB

---

🔧 Componentes por Tipo de Dron

Ejecutor (adn/tools/cli/dron/ejecutor.rb)

Componente	Propósito
Ejecutor#lanzar	Ejecuta comando, captura output, exit_code
Ejecutor#heartbeat	Escribe heartbeat cada 30s
Ejecutor#resultado	Retorna {cmd, output, exit_code, duration}

Vigilante (adn/tools/cli/dron/vigilante.rb)

Componente	Propósito
Vigilante#escanear	Lee /tmp/dron_flota/, detecta zombies
Vigilante#reportar	Muestra dashboard (flota)
Vigilante#alertar	Detecta anomalías (ej: >5 fallos en 1h)

Sanador (adn/tools/cli/dron/sanador.rb)

Componente	Propósito
Sanador#reintentar	Re-lanza failed (máx 3, backoff)
Sanador#limpiar	Remueve completados >24h
Sanador#notificar_fallo	Alerta tras 3 fallos consecutivos

Planificador (adn/tools/cli/dron/planificador.rb)

Componente	Propósito
Planificador#leer_cron	Lee ~/.claude/scheduled_tasks.json
Planificador#encolar	Publica evento en cola
Planificador#listar	Muestra schedules activos

Orquestador (adn/tools/cli/dron/orquestador.rb)

Componente	Propósito
Orquestador#secuenciar	Ejecuta pasos en orden
Orquestador#paralelizar	Ejecuta pasos en paralelo
Orquestador#condicionar	on-error: continue|abort|retry

Registrador (adn/tools/cli/dron/bitacora.rb)

Componente	Propósito
Bitacora#iniciar	Crea evento ⏳ con nota
Bitacora#finalizar	Actualiza evento con --fin
Bitacora#fallar	Marca evento como ❌ con error

Persistencia

Archivo/Tabla	Tipo	Propósito	Visibilidad
bitacoras.dron_logs	Tabla DB	Logs detallados de cada dron	🔒 Interna
bitacoras.dron_avances	Tabla DB	Progreso paso-a-paso de flujos	🔒 Interna
bitacoras.dron_metricas	Tabla DB	Agregaciones y estadísticas	🔒 Interna
bitacoras.events	Tabla DB	Eventos consolidados (resumen)	✅ Bitácora Web
/tmp/dron_flota/*.json	Archivo	Estado de drones activos (runtime)	🔒 CLI
/tmp/dron_queue/*.json	Archivo	Cola de eventos (por tipo)	🔒 Drones
/tmp/dron_pheromones/	Directorio	Señales químicas virtuales	🔒 Drones
~/.claude/scheduled_tasks.json	Archivo	Schedules persistentes (cron)	🔒 Planificador

Modificar

Archivo	Cambio
adn/tools/cli/dron.rb	Refactorizar → dispatcher que importa módulos
adn/tools/run	Registrar subcomandos: dron lanzar, dron orquestar, etc.
adn/tools/db/core/bitacora_db.rb	Hook para eventos AUTO (dron_bitacora)

---

📝 Comandos por Tipo de Dron

Ejecutor

# Lanzar tarea simple (auto-bitácora)
./adn/tools/run dron lanzar --evento AUTO --nota "Backup SQL" -- vzdump 103

# Lanzar sin registro (efímero)
./adn/tools/run dron lanzar --no-bitacora --nota "Test rápido" -- echo hola

# Lanzar con timeout
./adn/tools/run dron lanzar --timeout 300 --nota "Sync larga" -- rclone sync ...

Orquestador (Composición)

# Flujo secuencial (backup → sync → notificar)
./adn/tools/run dron orquestar \
  --step "dron lanzar --nota 'Backup' -- vzdump 103" \
  --step "dron lanzar --nota 'Sync' -- rclone sync /bkps oneDrive:" \
  --step "dron notificar --msg 'Backup completado'" \
  --on-error abort

# Flujo paralelo (múltiples backups simultáneos)
./adn/tools/run dron orquestar \
  --parallel \
  --step "dron lanzar --nota 'Backup SQL' -- vzdump 103" \
  --step "dron lanzar --nota 'Backup DC' -- vzdump 100" \
  --step "dron lanzar --nota 'Backup PCV' -- vzdump 104"

Planificador (Cron)

# Agendar backup nocturno
./adn/tools/run dron schedule add \
  --cron "0 2 * * *" \
  --cmd "dron lanzar --evento AUTO --nota 'Backup nocturno' -- ./adn/tools/run bkps run C4 --batch"

# Listar schedules
./adn/tools/run dron schedule list

# Eliminar schedule
./adn/tools/run dron schedule remove <id>

Vigilante (Monitoreo)

# Dashboard de flota
./adn/tools/run dron flota

# Estado detallado de un dron
./adn/tools/run dron estado <tarea_id>

# Métricas históricas
./adn/tools/run dron metricas [--desde 2026-04-01] [--hasta 2026-04-07]

Sanador (Reparación)

# Health check (detecta zombies)
./adn/tools/run dron salud

# Reintentar fallidos
./adn/tools/run dron sanear --reintentar

# Limpiar completados
./adn/tools/run dron limpiar --mayor-a 24h

Mensajero (Notificaciones)

# Notificar por Slack
./adn/tools/run dron notificar --slack "#backups" "Backup completado ✅"

# Notificar por email
./adn/tools/run dron notificar --email "admin@frlr.utn.edu.ar" "Alerta de fallo"

---

🎯 Criterios de Éxito

Atomicidad (Fase 1)

• ✅ Cada dron tiene una única responsabilidad (Single Responsibility)
• ✅ Sin código duplicado entre módulos
• ✅ Tests independientes por tipo de dron

Composición (Fase 2)

• ✅ Flujos multi-paso se expresan como composición de drones
• ✅ Orquestador permite secuencial/paralelo/condicional

Inteligencia de Colmena (Fase 4)

• ✅ Drones se comunican vía cola de eventos
• ✅ Patrones de reacción emergen (failed → sanador → notificar)
• ✅ Sin orquestador central para reacciones automáticas

Observabilidad (Fase 5)

• ✅ Dashboard web muestra estado en tiempo real
• ✅ Histórico consultable vía CLI y web
• ✅ Alertas proactivas ante anomalías

---

📚 Referencias

Internas (ADN)

• Herramienta actual: adn/tools/cli/dron.rb
• A01.P006: Sensor de Mejora Continua — Dron como evolución del sensor
• A01 (dtic-ADN): Manifiesto de Ámbito — Marco de trabajo
• adn/06_gobernanza.md: Principios Rectores — Menos es Más

Externas (Inspiración)

• Swarm Intelligence: Comportamiento emergente en colonias de insectos
• Unix Philosophy: "Do one thing and do it well"
• Microservices: Servicios pequeños, composables, independientes
• Event-Driven Architecture: Comunicación asíncrona vía eventos
• CronCreate: SDK de Claude Code para schedules persistentes

DB-First

• Todas las métricas se almacenan en PostgreSQL (bitacoras.dron_logs)
• Dashboard web consume API → DB

---

🔄 Armonía Integral

Última actualización: 2026-04-07 (plan creado, filosofía AtomicDrones aplicada)

Documento	Estado	Notas
A01_dtic-ADN.md	📍 Pendiente	Agregar A01.P009 a tabla de planes
adn/07_proyectos.md	📍 Pendiente	Referenciar nuevo plan
docs/contexto/IA.md	📍 Pendiente	Actualizar sección de drones
adn/06_gobernanza.md	✅ Alineado	Principio "Menos es Más" — AtomicDrones