# Schéma de début de session

Chaque session d'agent LLM devrait suivre cette séquence canonique de démarrage.
Sauter des étapes mène à un contexte perdu, des messages manqués et des tâches
oubliées.

## Le schéma

```
1. Recall all memories
2. Poll for unread chat messages
3. Check in-progress tasks
4. Build context from results
5. Process pending items before new work
```

## Implémentation

### Étape 1 : rappeler toutes les mémoires

> [!CRITICAL]
> C'est l'appel le plus important. Sans lui, vous n'avez aucune mémoire des sessions
> passées.

```bash
curl -H "Authorization: Bearer YOUR_MIND_KEY" \
     https://synapse.schaefer.zone/memory/recall
```

Renvoie un résumé en texte brut de toutes les mémoires, trié par priorité.

### Étape 2 : polliner les messages chat non lus

```bash
curl -H "Authorization: Bearer YOUR_MIND_KEY" \
     https://synapse.schaefer.zone/chat/poll
```

Renvoie les messages non lus de l'humain. **Les marque automatiquement comme lus.**

### Étape 3 : vérifier les tâches en cours

```bash
curl -H "Authorization: Bearer YOUR_MIND_KEY" \
     "https://synapse.schaefer.zone/mind/tasks?status=in_progress"
```

Renvoie les tâches sur lesquelles vous travailliez à la dernière session.

### Étape 4 : construire le contexte

Combinez les trois réponses dans votre prompt système :

```python
def build_context(memories, messages, tasks):
    context = f"""# SESSION CONTEXT

## Memories (from previous sessions)
{memories}

## Unread Messages from Human
{format_messages(messages)}

## Active Tasks
{format_tasks(tasks)}

## Instructions
- Address unread messages first
- Resume active tasks before starting new work
- Store new learnings as they happen (POST /memory)
- Poll for new messages every 30-60 seconds
"""
    return context
```

### Étape 5 : traiter les éléments en attente

```
For each unread message:
  - Acknowledge receipt (POST /chat/reply)
  - Address the message content
  - Store any new commitments as memories

For each in-progress task:
  - Recall why you were working on it
  - Continue from where you left off
  - Update task status as you progress
```

## Exemple complet

```python
import os
import requests

URL = "https://synapse.schaefer.zone"
KEY = os.environ["SYNAPSE_MIND_KEY"]

def session_start():
    """Canonical session start sequence."""
    headers = {"Authorization": f"Bearer {KEY}"}
    
    # 1. Rappeler les mémoires
    r = requests.get(f"{URL}/memory/recall", headers=headers)
    memories = r.text
    
    # 2. Polliner le chat
    r = requests.get(f"{URL}/chat/poll", headers=headers)
    messages = r.json().get("messages", [])
    
    # 3. Vérifier les tâches
    r = requests.get(f"{URL}/mind/tasks?status=in_progress", headers=headers)
    tasks = r.json().get("tasks", [])
    
    # 4. Construire le contexte
    context = f"""You are a Synapse-enabled AI assistant.

MEMORIES FROM PREVIOUS SESSIONS:
{memories}

UNREAD MESSAGES FROM HUMAN:
{chr(10).join(f'- {m["content"]}' for m in messages) or 'None'}

ACTIVE TASKS:
{chr(10).join(f'- [{t["id"]}] {t["title"]}: {t.get("description", "")}' for t in tasks) or 'None'}

INSTRUCTIONS:
1. Acknowledge each unread message
2. Resume active tasks
3. Store new learnings via POST /memory
4. Poll /chat/poll every 30-60 seconds
"""
    return context

# Au début de session
system_prompt = session_start()
# Passer au LLM...
```

## Erreurs courantes

> [!WARNING]
> - **Sauter le rappel** — vous commencez sans contexte, répétez les erreurs passées
> - **Oublier de polliner le chat** — les messages de l'humain restent sans réponse
> - **Ignorer les tâches actives** — le travail est oublié en cours d'exécution
> - **Ne rien stocker** — la session ne produit aucune valeur persistante

## Variations

### Schéma minimal (LLM à faible contexte)

Pour les LLM avec de petites fenêtres de contexte, sautez le rappel complet :

```bash
# Juste obtenir les stats, pas le contenu complet
curl -H "Authorization: Bearer $KEY" .../memory/stats
```

Puis recherchez des sujets spécifiques au besoin :

```bash
curl -H "Authorization: Bearer $KEY" ".../memory/search?q=current+project"
```

### Schéma agressif (agents longue durée)

Pour les agents qui tournent pendant des heures, ajoutez un re-rappel périodique :

```python
while working:
    if time.time() - last_recall > 3600:  # toutes les heures
        memories = recall()
        last_recall = time.time()
    # ... do work ...
```

## Prochaines étapes

- [Stratégie de tagging mémoire](/docs/llm-cookbook/memory-tagging-strategy)
- [Workflow piloté par les tâches](/docs/llm-cookbook/task-driven-workflow)
- [Schéma de polling de chat](/docs/llm-cookbook/chat-polling-pattern)