Context Intents [B, T] ──→ IntentEmbedding [E] ──┐
                                                   ├──→ Sum [B, T, E] ──→ GRU [B, H] ──→ Dropout
Context Actions [B, T] ──→ ActionEmbedding [E] ──┘                  │
                                                                      │
                                                   ┌──────────────────┘
                                                   │
Current Intent  [B]    ──→ IntentEmbedding [E] ───┴──→ Concat [B, H+E] ──→ Linear ──→ Action Logits [B, A]

DIALOGUE_POLICY_EMBED_DIM: int = 64     # Dimensione embedding
DIALOGUE_POLICY_HIDDEN_DIM: int = 128   # Dimensione hidden state GRU
DIALOGUE_POLICY_DROPOUT: float = 0.3    # Probabilità di dropout

1. context_emb = IntentEmbedding(context_intents) + ActionEmbedding(context_actions)
                 ─── somma element-wise degli embedding di intent e azione ad ogni passo temporale

2. _, hidden = GRU(context_emb)
               ─── hidden: [1, B, H] → squeeze → [B, H]

3. hidden = Dropout(hidden)

4. curr_emb = IntentEmbedding(current_intent)     ─── [B, E]

5. combined = Concat([hidden, curr_emb], dim=-1)   ─── [B, H+E]

6. logits = Linear(combined)                       ─── [B, A]

probs = softmax(logits, dim=-1)
action_idx = argmax(probs)           # 0-indexed
confidence = probs[0, action_idx]    # float in [0.0, 1.0]

[1] Carica conversations da .cognitor/conversations.yaml
         │
         ▼
[2] Costruisce dizionari intent→id e action→id (1-indexed, 0 = padding)
         │
         ▼
[3] Genera campioni di training dalle storie (history window = 5)
         │
         ▼
[4] Crea DialoguePolicyDataset e DataLoader (batch_size ≤ 4, shuffle=True)
         │
         ▼
[5] Inizializza il modello DialoguePolicy con gli iperparametri condivisi
         │
         ▼
[6] Training loop con early stopping (epochs=150, lr=0.001, patience=20)
         │
         ▼
[7] Salva il modello e i dizionari

conversations:
  flusso_prenotazione:
    description: "Flusso di prenotazione ristorante"
    steps:
      - user: greeting
        bot: greeting_response
      - user: prenota_ristorante
        bot: prenota_ristorante_response
      - user: conferma_prenotazione
        bot: conferma_prenotazione_response
      - user: farewell
        bot: farewell_response

(context_intent_ids, context_action_ids, current_intent_id, target_action_id)

optimizer  = AdamW(model.parameters(), lr=0.001, weight_decay=1e-4)
criterion  = CrossEntropyLoss()
scheduler  = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3)

for epoch in range(150):
    # Forward + backward + step
    # Calcola avg_loss sull'epoca
    # ReduceLROnPlateau aggiorna il lr se il loss non migliora per 3 epoche
    # Early stopping: se avg_loss non migliora per 20 epoche → stop
    # Ripristina il miglior stato del modello

# Intera pipeline (Step 0–5)
python -m pipeline

# Solo Dialogue Policy
python -m intellective.train_dialogue_policy

1. Utente invia messaggio
         │
         ▼
2. Agent.predict()       ─── Intent + Entities dal modello NLU (BiGRU + Attention + CRF)
         │
         ▼
3. SlotManager.update_session()   ─── Estrae slot dalle entità
         │
         ▼
4. DialogueStatePolicy.predict_next_action(current_intent, history)
   ├─── [Modalità ML]        → DialoguePolicy (GRU)
   └─── [Modalità Euristica] → Longest-suffix match sulle storie YAML
         │
         ▼
5. Se azione trovata → Risposta dalla Dialogue Policy
   Altrimenti        → RuleInterpreter.handle_intent()
         │
         ▼
6. Risposta finale all'utente

1. Estrai la sequenza degli intent utente precedenti dallo history (max 5)
2. Converti gli intent in ID tramite il dizionario
3. Costruisci i tensori di input (batch size = 1):
     context_intent_tensor: [1, T]  ─── sequenza di ID intent contesto
     context_action_tensor: [1, T]  ─── zeri (placeholder, TODO: tracciare azioni bot)
     current_tensor:        [1]     ─── ID intent corrente
4. Chiama model.predict(context_intent_tensor, context_action_tensor, current_tensor)
     ─── Restituisce (action_idx 0-indexed, confidence)
5. Converti action_idx in nome azione tramite dizionario inverso
     ─── action_dict_inv[action_idx + 1]  (riconversione a 1-indexed)
6. Restituisce {'action': action_name, 'confidence': confidence}

1. Estrai la sequenza degli intent utente recenti dallo history (contesto corrente)
2. Per ogni transizione nelle storie YAML con user_intent == current_intent:
     - Calcola lo score di corrispondenza del suffisso tra contesto corrente e contesto della storia:
         score = max_suffix_match_length / len(story_context)
         score = 0.5 se story_context è vuoto (primo passo della storia)
3. Seleziona la transizione con lo score più alto
4. Restituisce {'action': best_action, 'confidence': best_score}

[
    {
        'role': 'user',
        'content': 'Ciao, voglio prenotare un tavolo',
        'intent': 'prenota_ristorante',
        'entities': [...],
        'timestamp': '...'
    },
    {
        'role': 'bot',
        'content': 'Con piacere! Per quante persone?',
        ...
    },
    ...
]

[utente] "ciao"          → intent: greeting
[bot]    "Ciao! ..."
[utente] "prenota tavolo" → intent: prenota_ristorante   ← turno corrente

WARNING Dialogue Policy ML non disponibile: ...
[TED] Modalità: EURISTICA | intent='prenota_ristorante' | transizioni_disponibili=12