AI Cross-App Strategy — Cadences Ecosystem

FichaYa + FishMap + FarmaMap + FuelMap + TravelMap + GarageMap

Principio rector: La IA es invisible. El usuario ve resultados inteligentes.
Nunca ve "IA", "inteligencia artificial" ni "modelo". Solo datos que parecen mágicos.

1. Mapa de IA por Producto

┌────────────────────────────────────────────────────────────────────────────┐
│                        CADENCES AI LAYER                                   │
│                                                                            │
│  ┌──── FichaYa ────┐  ┌──── *Map Apps ─────────────────────────────┐      │
│  │ Anomaly Detect.  │  │ FishMap: score, conditions, species AI     │      │
│  │ Smart Scheduling │  │ FarmaMap: guardia predictor, wait estim.   │      │
│  │ Absence Predict. │  │ FuelMap: price prediction, route optimizer │      │
│  │ Overtime Alerts  │  │ TravelMap: trip planner, difficulty scorer │      │
│  │ Compliance Check │  │ GarageMap: maintenance predictor, pricing  │      │
│  │ Report Narratives│  │                                            │      │
│  └──────────────────┘  └────────────────────────────────────────────┘      │
│                                                                            │
│  ┌──── Shared Infrastructure ──────────────────────────────────────┐      │
│  │ DeepSeek Reasoner (seeding) + Workers AI (inference) + D1 cache │      │
│  │ Cron triggers · KV scoring cache · Durable Objects for state    │      │
│  └─────────────────────────────────────────────────────────────────┘      │
└────────────────────────────────────────────────────────────────────────────┘

2. FichaYa — IA Invisible para RRHH

2.1 Detección de Anomalías (Priorities: P0)

Qué detecta (sin que el usuario sepa que hay ML):

Implementación (Worker Cron, cada 30min):

// workers/fichaya-anomaly-cron.js
export default {
  async scheduled(event, env) {
    const DB = env.DB;
    
    // 1. Fichajes sin cerrar > 12h
    const unclosed = await DB.prepare(`
      SELECT u.id, u.name, u.org_id, c.clock_time, c.type
      FROM fichaya_clockings c
      JOIN fichaya_users u ON c.user_id = u.id
      WHERE c.type = 'in' AND c.clock_date = date('now', '-1 day')
      AND NOT EXISTS (
        SELECT 1 FROM fichaya_clockings c2
        WHERE c2.user_id = c.user_id AND c2.clock_date = c.clock_date
        AND c2.type = 'out' AND c2.clock_time > c.clock_time
      )
    `).all();
    
    // 2. Horas excesivas hoy
    const overtime = await DB.prepare(`
      SELECT user_id, SUM(
        CASE WHEN type = 'in' THEN 
          julianday(COALESCE(next_time, datetime('now'))) - julianday(clock_time)
        ELSE 0 END
      ) * 24 as hours
      FROM (
        SELECT *, LEAD(clock_time) OVER (PARTITION BY user_id ORDER BY clock_time) as next_time
        FROM fichaya_clockings WHERE clock_date = date('now')
      )
      GROUP BY user_id HAVING hours > 10
    `).all();
    
    // 3. Store anomalies in fichaya_anomalies table
    for (const a of [...unclosed.results, ...overtime.results]) {
      await DB.prepare(`
        INSERT OR IGNORE INTO fichaya_anomalies (id, org_id, user_id, type, severity, detected_at, data)
        VALUES (?, ?, ?, ?, ?, datetime('now'), ?)
      `).bind(nanoid(), a.org_id, a.id || a.user_id, 'unclosed_shift', 'warning', JSON.stringify(a)).run();
    }
  }
};

2.2 Smart Scheduling (P1)

Qué hace: Aprende patrones de cada empleado y sugiere horarios.

Motor (no DeepSeek — cálculo local en Worker):

function analyzeSchedulePattern(clockings) {
  // Agrupar por día de semana
  const patterns = { 1: [], 2: [], 3: [], 4: [], 5: [] }; // L-V
  clockings.forEach(c => {
    if (c.type === 'in') {
      const d = new Date(c.clock_time);
      const dow = d.getDay();
      if (dow >= 1 && dow <= 5) {
        patterns[dow].push({
          arrivalMin: d.getHours() * 60 + d.getMinutes(),
        });
      }
    }
  });
  
  // Media y desviación por día
  return Object.entries(patterns).map(([dow, entries]) => {
    const arrivals = entries.map(e => e.arrivalMin);
    const avg = arrivals.reduce((a, b) => a + b, 0) / arrivals.length;
    const std = Math.sqrt(arrivals.map(x => (x - avg) ** 2).reduce((a, b) => a + b, 0) / arrivals.length);
    return {
      day: ['', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes'][dow],
      avgArrival: `${Math.floor(avg / 60)}:${String(Math.round(avg % 60)).padStart(2, '0')}`,
      stdMinutes: Math.round(std),
      consistency: std < 15 ? 'alta' : std < 30 ? 'media' : 'baja',
    };
  });
}

2.3 Predicción de Ausencias (P2)

Señales que el modelo observa (estadístico, no ML pesado):

• Lunes/viernes con más ausencias → "efecto puente"
• Empleados con patrón de ausencias pre-vacaciones
• Correlación con festivos locales

Output visible al admin: En el BI, sección "Predicción esta semana":

• "Jueves es víspera de festivo: probabilidad alta de ausencias"
• "3 empleados tienen patrón de viernes flexibles"

2.4 Compliance Checker Automático (P1)

Verificación continua sin intervención:

2.5 Narrativas Inteligentes para Reports (P2)

DeepSeek genera los textos de los PDFs de Inspección de Trabajo:

Prompt: "Resume el registro de jornada de {org_name} para el periodo {from} - {to}.
Hay {n} empleados. Total horas: {total}. Media por empleado: {avg}.
{anomalies_count} incidencias detectadas.
Genera un párrafo formal (estilo jurídico español) para el preámbulo del PDF."

Output: "Durante el periodo del 1 al 31 de marzo de 2026, la empresa Bar El 
Rinconcito, con CIF B12345678, ha registrado la jornada laboral de sus 4 
trabajadores conforme al artículo 34.9 del Estatuto de los Trabajadores..."

3. *Map Apps — Review IA Actual + Mejoras

3.1 FishMap — Pesca 🐟

IA actual (implementada):

• ✅ Seeding con DeepSeek: 294 spots + 1.581 asociaciones (98% éxito)
• ✅ Fishing Score por spot (multifactorial: especie × técnica × temporada)
• ✅ Cron cada 6h: AEMET + SAIH → condiciones actualizadas

Mejoras propuestas:

3.2 FarmaMap — Farmacias 💊

IA actual (implementada):

• ✅ Enriquecimiento de 22K+ farmacias con specialties, demographics
• ✅ Predicción de guardia (pattern matching por municipio)

Mejoras propuestas:

3.3 FuelMap — Gasolineras ⛽

IA actual (implementada):

• ✅ Datos MINETUR en tiempo real
• ✅ Scoring por relación calidad/precio
• ✅ Rutas optimizadas con paradas baratas

Mejoras propuestas:

3.4 TravelMap — Viajes 🗺️

IA actual: Seeding de destinos y rutas planificado.

Mejoras propuestas:

3.5 GarageMap — Talleres 🔧

IA propuesta:

4. Arquitectura IA Unificada

4.1 Capas del sistema

┌─────────────────────────────────────────────────────┐
│ CAPA 1: SEEDING (offline, batch)                     │
│ DeepSeek Reasoner via API                            │
│ Scripts .cjs → Validación → D1                       │
│ Coste: <$5 para todas las apps                       │
├─────────────────────────────────────────────────────┤
│ CAPA 2: SCORING (near-realtime, cron)                │
│ Workers Cron cada 30min/6h                           │
│ Datos externos (AEMET, SAIH, MINETUR) → Score        │
│ Cache en KV (TTL 30min)                              │
│ Sin coste IA — puro cálculo estadístico              │
├─────────────────────────────────────────────────────┤
│ CAPA 3: INFERENCE (realtime, per-request)            │
│ Workers AI (Llama 3 / Gemma) para:                   │
│ - Clasificación de texto (anomalies FichaYa)         │
│ - Resúmenes cortos (report narratives)               │
│ Coste: incluido en Workers plan                      │
├─────────────────────────────────────────────────────┤
│ CAPA 4: PERSONALIZATION (per-user)                   │
│ Algoritmos locales (JS en Worker):                   │
│ - Pattern matching (horarios, hábitos)               │
│ - Collaborative filtering (spots similares)          │
│ - Stats simples (media, σ, percentiles)              │
│ Sin coste IA — lógica pura                           │
└─────────────────────────────────────────────────────┘

4.2 Stack técnico compartido

4.3 Workers AI Models para inference

// Modelos disponibles en Workers AI (incluidos en plan)
const MODELS = {
  classification: '@cf/huggingface/distilbert-sst-2-int8',  // Anomaly classification
  summarize: '@cf/facebook/bart-large-cnn',                   // Report narratives  
  embeddings: '@cf/baai/bge-base-en-v1.5',                   // Similarity search
};

// Ejemplo: clasificar si un fichaje es anómalo
async function classifyAnomaly(env, clockingData) {
  const result = await env.AI.run(MODELS.classification, {
    text: `Employee clocked in at ${clockingData.time} from ${clockingData.location}. 
           Usual pattern: ${clockingData.usualTime} from ${clockingData.usualLocation}.`
  });
  return result[0].label === 'NEGATIVE' ? 'anomaly' : 'normal';
}

5. Roadmap de Implementación IA

Fase 1 — Q2 2026 (ahora)

• Seeding FishMap con DeepSeek (294 spots)
• Cron conditions FishMap (AEMET + SAIH)
• FichaYa: BI Analytics básico (implementado)
• FichaYa: Anomaly detection cron (unclosed shifts, overtime)
• FichaYa: Compliance checker automático
• FarmaMap: Enriquecimiento 22K farmacias

Fase 2 — Q3 2026

• FichaYa: Smart scheduling (pattern analysis)
• FichaYa: Report narrative AI (Workers AI summarize)
• FishMap: Recomendador personalizado de spots
• FuelMap: Predicción de precios (ARIMA en Worker)
• FuelMap: Alerta de precio personalizada

Fase 3 — Q4 2026

• FichaYa: Absence prediction
• TravelMap: Trip planner con DeepSeek
• GarageMap: Estimador de precios
• Content AI pipeline para SEO blogs (todas las *Map)
• Cross-app: Dashboard unificado de IA para admin Cadences

Fase 4 — 2027

• FichaYa: Integration con nóminas (Sage, A3, SILTRA)
• Modelo propio fine-tuned para datos españoles
• Real-time ML pipeline con Durable Objects
• Multi-idioma: catalán, euskera, gallego

6. Costes Totales Estimados

7. Principios Inquebrantables

1. El usuario NUNCA ve la palabra "IA" — Los resultados son "datos", "análisis", "informes"
2. Fallback graceful — Si la IA falla, mostramos datos básicos sin error
3. Privacy first — Los datos de FichaYa (RRHH) nunca salen de Cloudflare EU
4. Coste cero percibido — Todo incluido en el plan Workers ($5/mo)
5. Seeding > Training — No entrenamos modelos, enriquecemos datos con IA y luego servimos
6. Estadística > ML cuando basta — Medias, desviaciones y percentiles resuelven el 80%
7. DeepSeek para batch, Workers AI para realtime — Cada motor donde brilla
8. Invisible ≠ inexistente — El admin de Cadences ve métricas de IA en su panel interno

Documento generado: Abril 2026
Aplica a: FichaYa, FishMap, FarmaMap, FuelMap, TravelMap, GarageMap
Referencia: storefronts/STRATEGY_AI_MASTER_PLAN.md (detalle seeding)