# PLIP — Téléphone conversationnel France Télécom — Plan d'implémentation

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Faire du PLIP un téléphone France Télécom interactif : décroché → tonalité → numérotation (cadran/DTMF) → annuaire → PNJ vocal conversationnel (Zacus & services d'époque).

**Architecture:** Le firmware PLIP possède la machine à états téléphonique ; la gateway expose `POST /v1/voice/turn` (stateless/tour) qui enchaîne whisper(STT) → ailiance(chat) → ailiance(TTS) → resample 16k. Le PLIP ne fait ni TLS, ni prompt, ni resample.

**Tech Stack:** ESP-IDF (esp32, plip_voice : net.c httpd, audio.c I2S/ES8388, phone.c hook), SLIC classe AG1171 (SHK = hook+impulsions). Gateway FastAPI/httpx (`tools/zacus-gateway/main.py`), pytest. TTS+LLM via `gateway.ailiance.fr` (OpenAI-compatible).

**Spec:** `docs/superpowers/specs/2026-06-14-plip-telephone-conversation-design.md`

**Référence (numéros de ligne au moment de la rédaction) :** patterns dans `ESP32_ZACUS/plip_voice/main/{net.c,audio.c,phone.c,cmd_exec.c,hook_client.c,Kconfig.projbuild,board_config.h,CMakeLists.txt}` et `tools/zacus-gateway/main.py` (`_synthesise_wav` ~l.701, `_wav_to_16k_mono` ~l.734, route `/v1/voice/say` ~l.1358).

**Convention build/flash firmware :** `. ~/esp/esp-idf/export.sh ; cd ESP32_ZACUS/plip_voice ; idf.py build ; idf.py -p /dev/cu.usbserial-0001 flash`. Série : `/dev/cu.usbserial-0001` (un lecteur à la fois). PLIP IP 192.168.0.138.

**Convention commits firmware (submodule) :** `git -C ESP32_ZACUS -c user.name=electron-rare -c user.email=c.saillant@gmail.com commit -m "..."`. JAMAIS `--no-verify`. Commits gateway : depuis la racine repo.

---

## STAGE 1 — Tonalités + dialer + machine à états (firmware, zéro IA)

Livrable : décroché → tonalité 440 Hz ; composer un numéro (debug HTTP + impulsions SHK) → ringback si numéro connu / occupé sinon ; raccroché = mute. Aucune conversation encore.

### Task 1.1 : Module `tones` (tonalités France Télécom)

**Files:**
- Create: `ESP32_ZACUS/plip_voice/main/tones.h`
- Create: `ESP32_ZACUS/plip_voice/main/tones.c`
- Modify: `ESP32_ZACUS/plip_voice/main/CMakeLists.txt` (ajouter `tones.c` aux SRCS)

- [ ] **Step 1 : Écrire `tones.h`**

```c
#pragma once
#include "esp_err.h"
// Tonalités France Télécom — générées via le DAC/I2S, non bloquant (tâche dédiée).
// Toutes forcent le PA on (audio_pa_set(true)) le temps de jouer.
void tones_dialtone_start(void);   // 440 Hz continu (invitation à numéroter)
void tones_busy_start(void);       // 440 Hz 0,5 s on / 0,5 s off (occupé / non attribué)
void tones_ringback_start(void);   // 440 Hz 1,5 s on / 3,5 s off (retour d'appel)
void tones_stop(void);             // arrête toute tonalité en cours
```

- [ ] **Step 2 : Écrire `tones.c`**

Génère un sinus 440 Hz en PCM 16 kHz mono et l'écrit en boucle sur l'I2S TX (`audio_spk_handle()`), avec un masque on/off selon la tonalité. Une seule tâche FreeRTOS `s_tone_task`, un `volatile tone_mode_t s_mode` (NONE/DIAL/BUSY/RINGBACK). `tones_stop` met NONE + `audio_pa_set` géré par l'appelant (la machine à états). Modèle : la génération de tone dans `audio.c::audio_play_tone` (sinus + `i2s_channel_write` sur `audio_spk_handle()`).

```c
#include "tones.h"
#include "audio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/i2s_std.h"
#include <math.h>
#include <string.h>

typedef enum { TONE_NONE, TONE_DIAL, TONE_BUSY, TONE_RINGBACK } tone_mode_t;
static volatile tone_mode_t s_mode = TONE_NONE;
static TaskHandle_t s_task;
#define SR 16000
#define FRAME 320                       // 20 ms

static void fill_440(int16_t *buf, int n, int *phase) {
    for (int i = 0; i < n; i++) {
        buf[i] = (int16_t)(8000.0f * sinf(2.0f * (float)M_PI * 440.0f * (*phase) / SR));
        (*phase)++;
    }
}

static void tone_task(void *arg) {
    int16_t buf[FRAME];
    int phase = 0;
    int64_t t = 0;                      // ms écoulées dans le cycle on/off
    for (;;) {
        tone_mode_t m = s_mode;
        if (m == TONE_NONE) { vTaskDelay(pdMS_TO_TICKS(20)); t = 0; continue; }
        bool on = true;
        if (m == TONE_BUSY)      on = (t % 1000) < 500;
        else if (m == TONE_RINGBACK) on = (t % 5000) < 1500;
        if (on) fill_440(buf, FRAME, &phase);
        else    memset(buf, 0, sizeof(buf));
        size_t w;
        i2s_channel_write(audio_spk_handle(), buf, sizeof(buf), &w, portMAX_DELAY);
        t += 20;
    }
}

static void ensure_task(void) {
    if (!s_task) xTaskCreate(tone_task, "tones", 3072, NULL, 5, &s_task);
}
void tones_dialtone_start(void){ audio_pa_set(true); ensure_task(); s_mode = TONE_DIAL; }
void tones_busy_start(void){ audio_pa_set(true); ensure_task(); s_mode = TONE_BUSY; }
void tones_ringback_start(void){ audio_pa_set(true); ensure_task(); s_mode = TONE_RINGBACK; }
void tones_stop(void){ s_mode = TONE_NONE; }
```

- [ ] **Step 3 : Ajouter `tones.c` au CMakeLists**

Dans `ESP32_ZACUS/plip_voice/main/CMakeLists.txt`, ajouter `"tones.c"` dans `SRCS` (à côté de `"audio.c"`).

- [ ] **Step 4 : Build**

Run: `. ~/esp/esp-idf/export.sh ; cd ESP32_ZACUS/plip_voice ; idf.py build`
Expected: build vert, `tones.c` compilé.

- [ ] **Step 5 : Commit**

```bash
git -C ESP32_ZACUS -c user.name=electron-rare -c user.email=c.saillant@gmail.com commit -am "feat(plip): tones module — France Télécom dial/busy/ringback"
```

### Task 1.2 : Module `dialer` (numéro composé : debug + impulsions SHK)

**Files:**
- Create: `ESP32_ZACUS/plip_voice/main/dialer.h`
- Create: `ESP32_ZACUS/plip_voice/main/dialer.c`
- Modify: `ESP32_ZACUS/plip_voice/main/CMakeLists.txt`
- Modify: `ESP32_ZACUS/plip_voice/main/net.c` (handler `/debug/dial`)

- [ ] **Step 1 : Écrire `dialer.h`**

```c
#pragma once
#include "esp_err.h"
#include <stdbool.h>
// Le dialer accumule des chiffres (source : impulsions SHK, DTMF, ou /debug/dial)
// et expose le numéro courant. La machine à états (conversation.c) lit
// dialer_current()/dialer_complete() et appelle dialer_reset() à la fin d'un appel.
void dialer_init(void);
void dialer_push_digit(int d);       // 0..9 ; appelé par les sources (debug, pulse, dtmf)
void dialer_reset(void);             // vide le numéro (raccroché / fin d'appel)
const char *dialer_current(void);    // ex. "17" (string null-terminée, max 8)
bool dialer_idle(void);              // true si aucun chiffre depuis le reset
int  dialer_ms_since_last(void);     // ms depuis le dernier chiffre (pour timeout inter-chiffre)
```

- [ ] **Step 2 : Écrire `dialer.c`** (accumulateur + horodatage)

```c
#include "dialer.h"
#include "freertos/FreeRTOS.h"
#include "esp_timer.h"
#include <string.h>

static char s_num[9];
static int  s_len;
static int64_t s_last_us;

void dialer_init(void){ dialer_reset(); }
void dialer_reset(void){ s_num[0]=0; s_len=0; s_last_us=0; }
void dialer_push_digit(int d){
    if (d<0||d>9||s_len>=8) return;
    s_num[s_len++] = (char)('0'+d); s_num[s_len]=0;
    s_last_us = esp_timer_get_time();
}
const char *dialer_current(void){ return s_num; }
bool dialer_idle(void){ return s_len==0; }
int dialer_ms_since_last(void){
    if (!s_last_us) return 0;
    return (int)((esp_timer_get_time()-s_last_us)/1000);
}
```

- [ ] **Step 3 : Handler `/debug/dial?number=NNNN` dans `net.c`**

Calque le pattern `handle_status`/`handle_cmd_post` (net.c:127, 407). Parse le query `number`, appelle `dialer_push_digit` pour chaque chiffre. Enregistre `uri_debug_dial` (HTTP_GET) et **incrémente `cfg.max_uri_handlers`** (actuellement 12 → 14, on ajoutera aussi `/debug/onhook` et plus tard rien d'autre côté net). Include `dialer.h`.

```c
static esp_err_t handle_debug_dial(httpd_req_t *req) {
    char q[64], val[16];
    if (httpd_req_get_url_query_str(req, q, sizeof(q)) == ESP_OK &&
        httpd_query_key_value(q, "number", val, sizeof(val)) == ESP_OK) {
        for (const char *p = val; *p; p++) if (*p>='0'&&*p<='9') dialer_push_digit(*p-'0');
        return send_json(req, "200 OK", "{\"ok\":true}");
    }
    return send_json(req, "400 Bad Request", "{\"error\":\"number?\"}");
}
static const httpd_uri_t uri_debug_dial = {
    .uri="/debug/dial", .method=HTTP_GET, .handler=handle_debug_dial, .user_ctx=NULL };
// dans la fonction d'enregistrement : httpd_register_uri_handler(s_httpd, &uri_debug_dial);
```

- [ ] **Step 4 : Ajouter `dialer.c` au CMakeLists + build**

Run: `cd ESP32_ZACUS/plip_voice ; idf.py build`
Expected: vert.

- [ ] **Step 5 : Flash + test debug dial**

```bash
idf.py -p /dev/cu.usbserial-0001 flash
curl -s "http://192.168.0.138/debug/dial?number=17"   # -> {"ok":true}
```
Expected: `{"ok":true}`, série logue les chiffres (ajouter un `ESP_LOGI` dans push_digit pour vérifier).

- [ ] **Step 6 : Commit**

```bash
git -C ESP32_ZACUS ... commit -am "feat(plip): dialer module + /debug/dial (digit accumulator)"
```

### Task 1.3 : Impulsions cadran sur SHK (comptage)

**Files:**
- Modify: `ESP32_ZACUS/plip_voice/main/phone.c` (compter les impulsions sur le GPIO hook = SHK)
- Modify: `ESP32_ZACUS/plip_voice/main/Kconfig.projbuild` (option pulse)

- [ ] **Step 1 : Kconfig pulse**

Dans `Kconfig.projbuild`, ajouter sous le menu PLIP :
```
config PLIP_DIAL_PULSE
    bool "Enable rotary pulse dialing on the hook/SHK GPIO"
    default y
config PLIP_DIAL_PULSE_MAX_GAP_MS
    int "Inter-pulse max gap (ms) — above this = digit complete"
    depends on PLIP_DIAL_PULSE
    default 200
```

- [ ] **Step 2 : Compter les impulsions dans `phone.c`**

Le cadran génère des ouvertures/fermetures rapides de la boucle pendant la composition (le SHK pulse), distinctes du décroché/raccroché (état stable). Dans la task hook (phone.c:86-111) : si `PLIP_DIAL_PULSE` et qu'on est **off-hook**, compter les transitions rapides ; quand le gap depuis la dernière impulsion dépasse `CONFIG_PLIP_DIAL_PULSE_MAX_GAP_MS`, le nombre d'impulsions = le chiffre (10 impulsions = 0) → `dialer_push_digit`. Garder la détection on/off-hook stable (raccroché = boucle ouverte >~500 ms). Include `dialer.h`.

```c
// pseudo-intégration dans la task hook, après lecture du niveau débouncé :
#if CONFIG_PLIP_DIAL_PULSE
static int s_pulse_count = 0;
static int64_t s_last_pulse_us = 0;
// sur front descendant bref (impulsion) pendant off-hook : s_pulse_count++; s_last_pulse_us=now;
// périodiquement : si s_pulse_count>0 && (now - s_last_pulse_us) > gap_ms :
//     int digit = (s_pulse_count==10)?0:s_pulse_count; dialer_push_digit(digit); s_pulse_count=0;
#endif
```

(Note implémenteur : le débounce hook actuel 30 ms peut masquer les impulsions cadran ~ 60-100 ms ; ajuster la logique pour distinguer impulsion brève vs raccroché stable. Tester au banc avec un vrai cadran ; sans cadran, `/debug/dial` couvre la suite.)

- [ ] **Step 3 : Build + flash**

Run: `cd ESP32_ZACUS/plip_voice ; idf.py build ; idf.py -p /dev/cu.usbserial-0001 flash`
Expected: vert ; au banc avec cadran (si dispo) composer "1" → série logue digit=1. Sans cadran : skip, `/debug/dial` reste la voie de test.

- [ ] **Step 4 : Commit**

```bash
git -C ESP32_ZACUS ... commit -am "feat(plip): rotary pulse dialing on SHK GPIO"
```

### Task 1.4 : Machine à états `conversation` jusqu'à RINGBACK/BUSY

**Files:**
- Create: `ESP32_ZACUS/plip_voice/main/conversation.h`
- Create: `ESP32_ZACUS/plip_voice/main/conversation.c`
- Modify: `ESP32_ZACUS/plip_voice/main/phone.c` (notifier conversation des transitions hook)
- Modify: `ESP32_ZACUS/plip_voice/main/main.c` (init conversation)
- Modify: `ESP32_ZACUS/plip_voice/main/CMakeLists.txt`

- [ ] **Step 1 : Écrire `conversation.h`**

```c
#pragma once
#include <stdbool.h>
void conversation_init(void);
void conversation_on_hook_change(bool offhook);   // appelé par phone.c
// Stage 1 : IDLE → DIAL_TONE → DIALING → ROUTING → RINGBACK|BUSY → (Stage 2: CONNECT…)
```

- [ ] **Step 2 : Écrire `conversation.c`** (tâche d'état, Stage 1)

Tâche FreeRTOS qui poll l'état. Au décroché : `tones_dialtone_start()`. Dès qu'un chiffre apparaît (`!dialer_idle()`) : `tones_stop()`, passe en DIALING. Quand `dialer_ms_since_last() > 3000` (timeout inter-chiffre) OU le numéro matche une entrée connue : ROUTING. Routing Stage 1 = table locale des numéros valides (`"12","3615","15","17","18"` + Zacus) ; connu → `tones_ringback_start()` (2 s puis stop, Stage 2 enchaînera CONNECT) ; inconnu → `tones_busy_start()` (5 s) → IDLE. Au raccroché : `tones_stop()`, `audio_stop()`, `audio_pa_set(false)`, `dialer_reset()`, IDLE.

```c
#include "conversation.h"
#include "tones.h"
#include "dialer.h"
#include "audio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include <string.h>

static const char *TAG = "conv";
typedef enum { ST_IDLE, ST_DIALTONE, ST_DIALING, ST_RINGBACK, ST_BUSY } st_t;
static volatile bool s_offhook;
static volatile st_t s_st = ST_IDLE;

static const char *KNOWN[] = { "12","3615","15","17","18", NULL };
static bool number_known(const char *n){
    for (int i=0; KNOWN[i]; i++) if (!strcmp(n, KNOWN[i])) return true;
    return false;
}

static void conv_task(void *arg){
    for (;;){
        vTaskDelay(pdMS_TO_TICKS(50));
        if (!s_offhook){
            if (s_st != ST_IDLE){ tones_stop(); audio_stop(); audio_pa_set(false); dialer_reset(); s_st=ST_IDLE; }
            continue;
        }
        switch (s_st){
        case ST_IDLE: tones_dialtone_start(); s_st=ST_DIALTONE; break;
        case ST_DIALTONE:
            if (!dialer_idle()){ tones_stop(); s_st=ST_DIALING; }
            break;
        case ST_DIALING: {
            const char *n = dialer_current();
            if (number_known(n)){
                ESP_LOGI(TAG, "route %s -> known", n);
                tones_ringback_start(); s_st=ST_RINGBACK;     // Stage 2: enchaîner CONNECT
            } else if (dialer_ms_since_last() > 3000){
                ESP_LOGI(TAG, "route %s -> unknown", n);
                tones_busy_start(); s_st=ST_BUSY;
            }
            break; }
        case ST_RINGBACK: /* Stage 2 remplira CONNECT/GREET ici */ break;
        case ST_BUSY: break;   // reste occupé jusqu'au raccroché
        }
    }
}
void conversation_init(void){ xTaskCreate(conv_task,"conv",4096,NULL,5,NULL); }
void conversation_on_hook_change(bool offhook){ s_offhook = offhook; if(!offhook) s_st=ST_IDLE; }
```

- [ ] **Step 3 : Brancher phone.c → conversation**

Dans la task hook de `phone.c` (là où `hook_client_report` est appelé), ajouter `conversation_on_hook_change(offhook)` (offhook = `phone_is_offhook()`). Include `conversation.h`.

- [ ] **Step 4 : Init dans main.c**

Dans `ESP32_ZACUS/plip_voice/main/main.c`, après `audio_init()` et l'init réseau, ajouter `dialer_init(); conversation_init();`. Include les headers.

- [ ] **Step 5 : Ajouter conversation.c au CMakeLists + build + flash**

Run: `cd ESP32_ZACUS/plip_voice ; idf.py build ; idf.py -p /dev/cu.usbserial-0001 flash`

- [ ] **Step 6 : Test au banc (séquence complète Stage 1)**

Décroché (ou simuler off-hook) → tonalité au HP. Puis :
```bash
curl -s "http://192.168.0.138/debug/dial?number=17"   # numéro connu
# série attendue : "route 17 -> known" + ringback au HP
curl -s "http://192.168.0.138/debug/dial?number=99"   # après reset/raccroché
# série attendue : "route 99 -> unknown" + busy au HP (après timeout 3s)
```
Raccroché → silence (PA off). Expected : tonalité → ringback (connu) / occupé (inconnu) → silence au raccroché.

- [ ] **Step 7 : Commit**

```bash
git -C ESP32_ZACUS ... commit -am "feat(plip): conversation state machine — dialtone/dialing/routing/ringback/busy (stage 1)"
```

### Task 1.5 : Lander Stage 1 (PR submodule + bump pointeur)

- [ ] **Step 1 : PR submodule ESP32_ZACUS** (branche `feat/plip-phone-stage1`), merge via API Gitea (voir conventions de session : push avec token, PR, merge, ff-only main).
- [ ] **Step 2 : Bump pointeur** dans le superprojet (`git add ESP32_ZACUS`, commit `chore: bump ESP32_ZACUS — PLIP phone stage 1`, PR, merge).

---

## STAGE 2 — Gateway `/v1/voice/turn` (voie greeting) + annuaire (téléphone jouable sens unique)

Livrable : composer un numéro → **entendre le PNJ débiter son accueil** (TTS ailiance). Sans micro ni whisper.

### Task 2.1 : Annuaire `phone_directory.yaml` + chargement gateway

**Files:**
- Create: `game/scenarios/phone_directory.yaml`
- Modify: `tools/zacus-gateway/main.py` (loader + Settings)
- Test: `tests/gateway/test_phone_directory.py`

- [ ] **Step 1 : Écrire l'annuaire**

```yaml
# game/scenarios/phone_directory.yaml — numéro → persona vocale
# persona = prompt système (personnage) ; voice = voix ailiance ; greeting = 1re réplique forcée (optionnel)
numbers:
  "12":
    label: "Renseignements"
    voice: "nova"
    persona: >
      Tu es l'opératrice des renseignements téléphoniques de France Télécom, années 80.
      Tu es polie, un peu pressée. Tu orientes l'appelant vers les bons services sans
      jamais donner directement la solution d'une énigme.
    greeting: "Renseignements, bonjour. Quel numéro demandez-vous ?"
  "15":
    label: "SAMU"
    voice: "nova"
    persona: >
      Tu es un régulateur du SAMU. Tu réponds avec calme et autorité. Dans cet escape game
      tu peux donner un indice médical déguisé, mais jamais la réponse directe.
    greeting: "SAMU, j'écoute, quelle est votre urgence ?"
  "17":
    label: "Police secours"
    voice: "alloy"
    persona: >
      Tu es un agent de Police secours, factuel et sérieux. Indices déguisés, jamais la solution.
    greeting: "Police secours, je vous écoute."
  "18":
    label: "Pompiers"
    voice: "alloy"
    persona: >
      Tu es un sapeur-pompier, direct et rassurant. Indices déguisés, jamais la solution.
    greeting: "Sapeurs-pompiers, bonjour, quel est le problème ?"
  "3615":
    label: "Minitel"
    voice: "nova"
    minitel: true
    persona: >
      Tu es un service Minitel automatisé (3615). Tu parles de façon datée, robotique,
      télématique. Réponses courtes façon serveur télétel.
    greeting: "Trois mille six cent quinze. Service en ligne. Tapez votre requête."
  "0142738200":
    label: "Professeur Zacus"
    voice: "nova"
    persona: >
      Tu es le Professeur Zacus, savant excentrique et théâtral. Tu guides les joueurs
      par des indices déguisés et des énigmes, jamais la solution directe. Tu connais le
      scénario en cours mais restes mystérieux.
    greeting: "Ah... vous avez réussi à me joindre. Ici le Professeur Zacus."
```

- [ ] **Step 2 : Écrire le test (échoue d'abord)**

`tests/gateway/test_phone_directory.py` :
```python
import sys
from pathlib import Path
REPO = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(REPO / "tools" / "zacus-gateway"))
import main

def test_directory_loads_known_numbers():
    d = main.load_phone_directory()
    assert "17" in d and d["17"]["label"] == "Police secours"
    assert "3615" in d and d["3615"].get("minitel") is True
    assert "voice" in d["12"] and "persona" in d["12"]

def test_directory_unknown_number_absent():
    d = main.load_phone_directory()
    assert "99" not in d
```

- [ ] **Step 3 : Lancer le test → échoue**

Run: `cd /Users/electron/code/zacus && python3 -m pytest tests/gateway/test_phone_directory.py -v`
Expected: FAIL (`load_phone_directory` n'existe pas).

- [ ] **Step 4 : Implémenter le loader**

Dans `tools/zacus-gateway/main.py`, près du `_load_boards_registry` (~l.32) :
```python
def load_phone_directory() -> dict:
    import yaml
    p = SCENARIOS_DIR / "phone_directory.yaml"   # SCENARIOS_DIR = REPO_ROOT/game/scenarios
    if not p.is_file():
        return {}
    data = yaml.safe_load(p.read_text(encoding="utf-8")) or {}
    return data.get("numbers", {})

PHONE_DIRECTORY = load_phone_directory()
```

- [ ] **Step 5 : Lancer le test → passe**

Run: `python3 -m pytest tests/gateway/test_phone_directory.py -v`
Expected: PASS (2 tests).

- [ ] **Step 6 : Commit**

```bash
git add game/scenarios/phone_directory.yaml tools/zacus-gateway/main.py tests/gateway/test_phone_directory.py
git -c user.name=electron-rare -c user.email=c.saillant@gmail.com commit -m "feat(gateway): phone directory loader (numéro → persona/voix)"
```

### Task 2.2 : Sessions en mémoire (historique conversation)

**Files:**
- Modify: `tools/zacus-gateway/main.py`
- Test: `tests/gateway/test_voice_session.py`

- [ ] **Step 1 : Test (échoue)**

```python
import sys, time
from pathlib import Path
REPO = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(REPO / "tools" / "zacus-gateway"))
import main

def test_session_appends_and_caps():
    s = main.VoiceSessions(ttl_s=600, max_turns=8)
    s.append("sid1", "user", "bonjour")
    s.append("sid1", "assistant", "ici Zacus")
    msgs = s.history("sid1")
    assert msgs[-2:] == [{"role":"user","content":"bonjour"},
                          {"role":"assistant","content":"ici Zacus"}]
    for i in range(40): s.append("sid1", "user", f"m{i}")
    assert len(s.history("sid1")) <= 16     # 8 tours * 2

def test_session_end_clears():
    s = main.VoiceSessions()
    s.append("sid2","user","x"); s.end("sid2")
    assert s.history("sid2") == []
```

- [ ] **Step 2 : Lancer → échoue.** Run: `python3 -m pytest tests/gateway/test_voice_session.py -v` → FAIL.

- [ ] **Step 3 : Implémenter `VoiceSessions`** dans `main.py` :
```python
class VoiceSessions:
    def __init__(self, ttl_s: int = 600, max_turns: int = 8):
        self._d: dict[str, dict] = {}
        self._ttl = ttl_s
        self._max = max_turns * 2
    def append(self, sid: str, role: str, content: str) -> None:
        import time
        e = self._d.setdefault(sid, {"msgs": [], "ts": 0.0})
        e["msgs"].append({"role": role, "content": content})
        e["msgs"] = e["msgs"][-self._max:]
        e["ts"] = time.time()
    def history(self, sid: str) -> list[dict]:
        import time
        e = self._d.get(sid)
        if not e: return []
        if time.time() - e["ts"] > self._ttl:
            self._d.pop(sid, None); return []
        return list(e["msgs"])
    def end(self, sid: str) -> None:
        self._d.pop(sid, None)

VOICE_SESSIONS = VoiceSessions()
```

- [ ] **Step 4 : Lancer → passe.** Run: `python3 -m pytest tests/gateway/test_voice_session.py -v` → PASS.

- [ ] **Step 5 : Commit**
```bash
git add tools/zacus-gateway/main.py tests/gateway/test_voice_session.py
git -c user.name=electron-rare -c user.email=c.saillant@gmail.com commit -m "feat(gateway): in-memory voice sessions (history + TTL)"
```

### Task 2.3 : LLM chat helper (ailiance)

**Files:**
- Modify: `tools/zacus-gateway/main.py` (Settings + `_chat_reply`)
- Test: `tests/gateway/test_chat_reply.py`

- [ ] **Step 1 : Test (mock httpx)**
```python
import sys, asyncio
from pathlib import Path
REPO = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(REPO / "tools" / "zacus-gateway"))
import main

class FakeResp:
    status_code = 200
    def json(self): return {"choices":[{"message":{"content":"Ici Zacus."}}]}
class FakeHTTP:
    async def post(self, *a, **k): return FakeResp()

def test_chat_reply_returns_content():
    out = asyncio.run(main._chat_reply(FakeHTTP(), "persona", [{"role":"user","content":"allo"}]))
    assert out == "Ici Zacus."
```

- [ ] **Step 2 : Lancer → échoue.** Run: `python3 -m pytest tests/gateway/test_chat_reply.py -v` → FAIL.

- [ ] **Step 3 : Implémenter** dans `main.py` (Settings : `ailiance_chat_model: str = "gpt-4o-mini"`) :
```python
async def _chat_reply(http, persona: str, history: list[dict]) -> str:
    messages = [{"role": "system", "content": persona}] + history
    resp = await http.post(
        f"{settings.ailiance_tts_url.rstrip('/')}/v1/chat/completions",
        json={"model": settings.ailiance_chat_model, "messages": messages, "max_tokens": 200},
        timeout=60.0,
    )
    if resp.status_code != 200:
        raise RuntimeError(f"chat HTTP {resp.status_code}")
    return resp.json()["choices"][0]["message"]["content"].strip()
```

- [ ] **Step 4 : Lancer → passe.** Run: `python3 -m pytest tests/gateway/test_chat_reply.py -v` → PASS.

- [ ] **Step 5 : Commit**
```bash
git add tools/zacus-gateway/main.py tests/gateway/test_chat_reply.py
git -c user.name=electron-rare -c user.email=c.saillant@gmail.com commit -m "feat(gateway): ailiance chat helper for NPC replies"
```

### Task 2.4 : Route `/v1/voice/turn` (voie greeting) + `/v1/voice/end`

**Files:**
- Modify: `tools/zacus-gateway/main.py`
- Test: `tests/gateway/test_voice_turn.py`

- [ ] **Step 1 : Test voie greeting (mock chat + TTS)**
```python
import sys, asyncio
from pathlib import Path
from fastapi.testclient import TestClient
REPO = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(REPO / "tools" / "zacus-gateway"))
import main

def test_turn_greeting_returns_wav(monkeypatch):
    async def fake_chat(http, persona, history): return "Police secours, j'écoute."
    async def fake_synth(http, text, voice): 
        # WAV 16k mono minuscule valide
        import struct
        pcm = b"\x00\x00" * 1600
        hdr = b"RIFF" + struct.pack("<I", 36+len(pcm)) + b"WAVEfmt " + struct.pack("<IHHIIHH",16,1,1,16000,32000,2,16) + b"data" + struct.pack("<I", len(pcm))
        return hdr + pcm, 0.1, False
    monkeypatch.setattr(main, "_chat_reply", fake_chat)
    monkeypatch.setattr(main, "_voice_tts_16k", fake_synth)
    c = TestClient(main.app)
    r = c.post("/v1/voice/turn",
               headers={"Authorization": f"Bearer {main.settings.token}"},
               json={"session_id":"s1","number":"17","kind":"greeting"})
    assert r.status_code == 200
    assert r.headers["content-type"] == "audio/wav"
    assert r.headers.get("x-zacus-said")  # texte de réponse en header
    assert r.content[:4] == b"RIFF"

def test_turn_unknown_number_404():
    c = TestClient(main.app)
    r = c.post("/v1/voice/turn",
               headers={"Authorization": f"Bearer {main.settings.token}"},
               json={"session_id":"s1","number":"99","kind":"greeting"})
    assert r.status_code == 404
```

- [ ] **Step 2 : Lancer → échoue.** Run: `python3 -m pytest tests/gateway/test_voice_turn.py -v` → FAIL.

- [ ] **Step 3 : Implémenter le helper TTS 16k + la route**

Helper (réutilise `_synthesise_wav` ailiance + `_wav_to_16k_mono`) :
```python
async def _voice_tts_16k(http, text: str, voice: str | None) -> tuple[bytes, float, bool]:
    from types import SimpleNamespace
    raw = await _synthesise_wav(http, SimpleNamespace(backend="ailiance", text=text, voice=voice))
    return _wav_to_16k_mono(raw, max_seconds=7.5)
```
Route :
```python
from fastapi import Response

class VoiceTurnRequest(BaseModel):
    session_id: str
    number: str
    kind: str = "reply"           # "greeting" | "reply"

@app.post("/v1/voice/turn")
async def voice_turn(body: VoiceTurnRequest, request: Request, _: None = Depends(require_token)):
    entry = PHONE_DIRECTORY.get(body.number)
    if not entry:
        raise HTTPException(404, f"numéro {body.number} non attribué")
    persona = entry.get("persona", "")
    voice = entry.get("voice")
    http = request.app.state.http
    heard = ""
    if body.kind == "greeting":
        said = entry.get("greeting") or await _chat_reply(http, persona, [])
    else:
        # Stage 3 remplira la transcription depuis le corps audio ; ici fallback vide
        heard = ""
        VOICE_SESSIONS.append(body.session_id, "user", heard or "(silence)")
        said = await _chat_reply(http, persona, VOICE_SESSIONS.history(body.session_id))
    VOICE_SESSIONS.append(body.session_id, "assistant", said)
    wav16, _dur, _trunc = await _voice_tts_16k(http, said, voice)
    return Response(content=wav16, media_type="audio/wav",
                    headers={"X-Zacus-Heard": heard[:200], "X-Zacus-Said": said[:200]})

class VoiceEndRequest(BaseModel):
    session_id: str

@app.post("/v1/voice/end")
async def voice_end(body: VoiceEndRequest, _: None = Depends(require_token)) -> dict:
    VOICE_SESSIONS.end(body.session_id)
    return {"ok": True}
```

- [ ] **Step 4 : Lancer → passe.** Run: `python3 -m pytest tests/gateway/test_voice_turn.py -v` → PASS (2 tests).

- [ ] **Step 5 : Test live contre ailiance (manuel, hors CI)**

Monter le gateway local (venv + `ZACUS_HUB_TOKEN`), puis :
```bash
curl -s -XPOST http://127.0.0.1:8400/v1/voice/turn \
  -H "Authorization: Bearer $TOK" -H "Content-Type: application/json" \
  -d '{"session_id":"t1","number":"17","kind":"greeting"}' -o /tmp/greet.wav -D -
file /tmp/greet.wav   # RIFF WAVE 16000 Hz
```
Expected : 200, header `X-Zacus-Said`, WAV 16k jouable.

- [ ] **Step 6 : Commit**
```bash
git add tools/zacus-gateway/main.py tests/gateway/test_voice_turn.py
git -c user.name=electron-rare -c user.email=c.saillant@gmail.com commit -m "feat(gateway): POST /v1/voice/turn (greeting path) + /v1/voice/end"
```

### Task 2.5 : Firmware — CONNECT/GREET appelle `/v1/voice/turn` et joue l'accueil

**Files:**
- Modify: `ESP32_ZACUS/plip_voice/main/conversation.c` (état CONNECT/GREET)
- Create: `ESP32_ZACUS/plip_voice/main/turn_client.h` / `turn_client.c` (POST /v1/voice/turn, reçoit WAV → SPIFFS → play)
- Modify: `Kconfig.projbuild` (URL gateway + token)

- [ ] **Step 1 : Kconfig gateway**
```
config PLIP_GATEWAY_URL
    string "Zacus gateway base URL"
    default "http://192.168.0.188:8400"   # ajuster à l'hôte gateway joignable du PLIP
config PLIP_GATEWAY_TOKEN
    string "Zacus gateway bearer token"
    default ""
```

- [ ] **Step 2 : `turn_client.c`** — POST greeting, écrit le WAV reçu dans `/spiffs/turn.wav`, retourne le chemin.

Calque `hook_client.c` (esp_http_client POST) mais : body JSON `{"session_id","number","kind":"greeting"}`, header `Authorization: Bearer <token>`, et **lecture de la réponse binaire** (WAV) en streaming → `fopen("/spiffs/turn.wav","wb")` + `esp_http_client_read`. Signature :
```c
// turn_client.h
#pragma once
#include <stdbool.h>
// POST /v1/voice/turn (greeting). Écrit le WAV dans out_path (/spiffs/...). true si OK.
bool turn_client_greeting(const char *session_id, const char *number, const char *out_path);
```

- [ ] **Step 3 : État CONNECT/GREET dans conversation.c**

Après RINGBACK (~2 s), au lieu de rester : générer un `session_id` (ex. `snprintf("%lld", esp_timer_get_time())`), appeler `turn_client_greeting(sid, dialer_current(), "/spiffs/turn.wav")`, puis `tones_stop(); audio_play_async("/spiffs/turn.wav");` → état CONNECTED. (Stage 3 ajoutera la boucle LISTEN.)

```c
case ST_RINGBACK:
    if (ringback_elapsed_ms() > 2000){
        tones_stop();
        snprintf(s_sid, sizeof(s_sid), "%lld", esp_timer_get_time());
        if (turn_client_greeting(s_sid, dialer_current(), "/spiffs/turn.wav"))
            audio_play_async("/spiffs/turn.wav");
        s_st = ST_CONNECTED;
    }
    break;
case ST_CONNECTED: /* Stage 3: LISTEN → turn(reply) → play, en boucle */ break;
```

- [ ] **Step 4 : Build + flash + test bout-en-bout (sens unique)**

Run: `cd ESP32_ZACUS/plip_voice ; idf.py build ; idf.py -p /dev/cu.usbserial-0001 flash`
Test : gateway prod/local joignable depuis le PLIP. Décroché → tonalité → `curl "http://192.168.0.138/debug/dial?number=17"` → série : route known → ringback → POST turn → **le combiné dit « Police secours, je vous écoute »**. (combiné décroché pour entendre, mute-on-hook oblige.)
Expected : le PNJ parle.

- [ ] **Step 5 : Commit + PR submodule + bump** (branche `feat/plip-phone-stage2-fw`).

### Task 2.6 : Lander Stage 2 (gateway + déploiement)

- [ ] **Step 1 : PR gateway** (route + annuaire + sessions) → merge.
- [ ] **Step 2 : Déployer le gateway** (scp `main.py` + `phone_directory.yaml` → `/home/electron/zacus-hub/...`, restart `zacus-hub-gateway`, `.bak` avant) — **nécessite autorisation explicite de déploiement prod**.
- [ ] **Step 3 : Vérif prod** : `POST /v1/voice/turn {number:17,kind:greeting}` → WAV.

---

## STAGE 3 — Micro + whisper → conversation deux sens

### Task 3.1 : Vérifier la capture micro (dépendance hardware)

**Files:** aucun changement code tant que non diagnostiqué.

- [ ] **Step 1 : Test capture combiné DÉCROCHÉ**

Combiné branché + **décroché** (SLIC connecte l'audio). Parler dans le combiné pendant :
```bash
curl -s -XPOST "http://192.168.0.138/voice/capture?max_ms=4000" -o /tmp/cap.wav
python3 - <<'PY'
import wave,struct
w=wave.open('/tmp/cap.wav'); n=w.getnframes(); d=w.readframes(n)
s=struct.unpack('<%dh'%(len(d)//2), d)
rms=(sum(x*x for x in s)/max(1,len(s)))**0.5
print("samples",len(s),"rms",round(rms,1))
PY
```
Expected : RMS nettement > 0 (voix captée). **Si RMS ≈ 0** : passer au Step 2.

- [ ] **Step 2 : Si zéros — basculer l'entrée ES8388 (LIN2/RIN2)**

Dans `es8388.c`, la config ADC sélectionne l'entrée (LINPUT1/RINPUT1). Si le SLIC est câblé sur l'entrée 2, changer la sélection sur LINPUT2/RINPUT2 (registre ADCCONTROL2/3 selon datasheet ES8388). Rebuild + flash + re-tester le Step 1. Documenter le pin réel. (Diagnostic possible via `GET /debug/regs` ajouté précédemment.)

- [ ] **Step 3 : Commit** (si changement entrée) : `git -C ESP32_ZACUS ... commit -am "fix(plip): ES8388 ADC input selection matches SLIC audio wiring"`.

### Task 3.2 : Endpoint STT vivant (whisper)

**Files:**
- Modify: `tools/zacus-gateway/main.py` (Settings `whisper_url` + `_transcribe`)
- Test: `tests/gateway/test_transcribe.py`

- [ ] **Step 1 : Relancer whisper** : soit la voice-bridge sur studio (`/voice/transcribe` → whisper.cpp :8300), soit whisper.cpp seul. Vérifier `curl -F file=@/tmp/cap.wav <whisper_url>` → JSON `{text}`. Noter l'URL joignable depuis le gateway host. (Infra — hors code ; documenter la commande de démarrage.)

- [ ] **Step 2 : Test `_transcribe` (mock)** `tests/gateway/test_transcribe.py` :
```python
import sys, asyncio
from pathlib import Path
REPO = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(REPO / "tools" / "zacus-gateway"))
import main
class FakeResp:
    status_code = 200
    def json(self): return {"text":"bonjour professeur"}
class FakeHTTP:
    async def post(self,*a,**k): return FakeResp()
def test_transcribe_returns_text():
    out = asyncio.run(main._transcribe(FakeHTTP(), b"RIFF....", "x.wav"))
    assert out == "bonjour professeur"
```

- [ ] **Step 3 : Lancer → échoue.** Run: `python3 -m pytest tests/gateway/test_transcribe.py -v` → FAIL.

- [ ] **Step 4 : Implémenter `_transcribe`** (Settings `whisper_url: str = "http://studio:8200"`, endpoint `/voice/transcribe` multipart) :
```python
async def _transcribe(http, wav_bytes: bytes, filename: str = "speech.wav") -> str:
    files = {"file": (filename, wav_bytes, "audio/wav")}
    resp = await http.post(f"{settings.whisper_url.rstrip('/')}/voice/transcribe",
                           files=files, timeout=60.0)
    if resp.status_code != 200:
        raise RuntimeError(f"stt HTTP {resp.status_code}")
    return (resp.json().get("text") or "").strip()
```

- [ ] **Step 5 : Lancer → passe.** Run: `python3 -m pytest tests/gateway/test_transcribe.py -v` → PASS.

- [ ] **Step 6 : Commit** : `git add ... && git commit -m "feat(gateway): whisper STT helper (_transcribe)"`.

### Task 3.3 : Voie `reply` de `/v1/voice/turn` (audio → STT → chat → TTS)

**Files:**
- Modify: `tools/zacus-gateway/main.py` (la route accepte le corps audio en `kind=reply`)
- Test: `tests/gateway/test_voice_turn.py` (ajouter un cas reply)

- [ ] **Step 1 : Test reply (mock _transcribe + _chat_reply + _voice_tts_16k)**

Ajouter à `test_voice_turn.py` un test qui POST `kind=reply` avec un corps WAV (multipart ou raw body) et `number`/`session_id` en query, mocke `_transcribe`→"allo", `_chat_reply`→"oui ?", `_voice_tts_16k`→WAV ; assert 200, header `X-Zacus-Heard: allo`.

- [ ] **Step 2 : Lancer → échoue** (la route ignore encore l'audio). Run: `python3 -m pytest tests/gateway/test_voice_turn.py -v` → le nouveau test FAIL.

- [ ] **Step 3 : Adapter la route** : pour `kind=reply`, lire le corps audio (le PLIP enverra le WAV en body brut + `number`/`session_id`/`kind` en query params, car le body est l'audio). Appeler `_transcribe(http, audio_bytes)` → `heard`, l'ajouter à l'historique, puis chat + TTS comme avant.

```python
@app.post("/v1/voice/turn")
async def voice_turn(request: Request, session_id: str, number: str,
                     kind: str = "reply", _: None = Depends(require_token)):
    entry = PHONE_DIRECTORY.get(number)
    if not entry: raise HTTPException(404, f"numéro {number} non attribué")
    http = request.app.state.http; persona = entry.get("persona",""); voice = entry.get("voice")
    heard = ""
    if kind == "greeting":
        said = entry.get("greeting") or await _chat_reply(http, persona, [])
    else:
        audio = await request.body()
        try:
            heard = await _transcribe(http, audio)
        except Exception:
            heard = ""
        VOICE_SESSIONS.append(session_id, "user", heard or "(inaudible)")
        if not heard:
            said = "Allô ? Je vous entends très mal, pouvez-vous répéter ?"
        else:
            said = await _chat_reply(http, persona, VOICE_SESSIONS.history(session_id))
    VOICE_SESSIONS.append(session_id, "assistant", said)
    wav16,_d,_t = await _voice_tts_16k(http, said, voice)
    return Response(content=wav16, media_type="audio/wav",
                    headers={"X-Zacus-Heard": heard[:200], "X-Zacus-Said": said[:200]})
```
(Note : `session_id`/`number`/`kind` passent en query params puisque le body porte l'audio. Mettre à jour le test greeting en conséquence : query params au lieu de json.)

- [ ] **Step 4 : Lancer → passe.** Run: `python3 -m pytest tests/gateway/test_voice_turn.py -v` → PASS (tous).

- [ ] **Step 5 : Commit** : `git commit -m "feat(gateway): /v1/voice/turn reply path (audio→STT→chat→TTS)"`.

### Task 3.4 : Firmware — boucle LISTEN → turn(reply) → SPEAK

**Files:**
- Modify: `ESP32_ZACUS/plip_voice/main/conversation.c` (état CONNECTED → boucle)
- Modify: `ESP32_ZACUS/plip_voice/main/turn_client.c` (fonction reply : capture → POST WAV → reçoit WAV)

- [ ] **Step 1 : `turn_client_reply`** — capture le micro (réutilise l'API `audio_capture_begin/read_frame/end`), assemble un WAV en mémoire/SPIFFS, POST en body brut à `/v1/voice/turn?session_id=..&number=..&kind=reply`, écrit la réponse WAV dans `/spiffs/turn.wav`.

```c
// turn_client.h : bool turn_client_reply(const char *sid, const char *number, const char *out_path);
```
(Capture : ~8 s max, VAD comme `/voice/capture`. Upload : `esp_http_client` POST streaming. Réutiliser le code de capture de `net.c::handle_voice_capture`.)

- [ ] **Step 2 : Boucle dans conversation.c**
```c
case ST_CONNECTED:
    // après la fin de lecture de l'accueil/réponse :
    if (audio_idle()){
        if (turn_client_reply(s_sid, dialer_current(), "/spiffs/turn.wav"))
            audio_play_async("/spiffs/turn.wav");
        // reste en CONNECTED → reboucle ; raccroché géré globalement
    }
    break;
```
(Ajouter `audio_idle()` si absent : true quand la queue est vide et aucune lecture en cours.)

- [ ] **Step 3 : Build + flash + test conversation deux sens** (combiné décroché, micro vérifié Task 3.1, whisper up) : décroché → numéro → accueil → parler → Zacus répond → reboucle → raccroché = fin.

- [ ] **Step 4 : Commit + PR submodule + bump.**

---

## STAGE 4 — 3615 Minitel (handshake + agent robotique)

### Task 4.1 : Sample handshake Minitel + lecture sur 3615

**Files:**
- Create: `ESP32_ZACUS/plip_voice/main/minitel_tone.h` (PCM embarqué, court) OU pousser un WAV sur SPIFFS
- Modify: `ESP32_ZACUS/plip_voice/main/conversation.c` (si `number=="3615"`, jouer le handshake avant GREET)

- [ ] **Step 1 : Obtenir le son handshake Minitel** : générer/approximer le handshake (séquence de tonalités modem) en WAV 16k court (~3 s), le pousser sur `/spiffs/minitel.wav` via `/game/file`, OU l'embarquer. (Sans fichier, approximer par une séquence de tones via `tones`/`audio_play_tone` : porteuse ~1300/2100 Hz alternées.)

- [ ] **Step 2 : Cas 3615 dans conversation.c** : à la connexion, si `dialer_current()=="3615"`, jouer `/spiffs/minitel.wav` (ou la séquence), PUIS enchaîner `turn_client_greeting` (l'annuaire a déjà la persona robotique + `minitel:true`). Le reste de la boucle est identique.

- [ ] **Step 3 : Build + flash + test** : composer 3615 → son modem Minitel → « Trois mille six cent quinze. Service en ligne… » → conversation robotique.

- [ ] **Step 4 : Commit + PR submodule + bump.**

### Task 4.2 : Test annuaire complet au banc

- [ ] **Step 1 :** Pour chaque numéro (12/15/17/18/3615/Zacus) : composer → accueil du bon PNJ (voix/persona). Numéro inconnu → occupé. Raccroché à tout moment → silence immédiat.
- [ ] **Step 2 :** Mode dégradé : whisper down → l'accueil joue quand même, reply → « je vous entends mal » (fallback). Documenter.

---

## Self-Review (couverture spec)

- **§2 Architecture (A, /v1/voice/turn unique)** → Tasks 2.4, 3.3 ✓
- **§3 Séquence (tonalité/dialing/routing/ringback/busy/mute)** → Tasks 1.1, 1.4 ✓
- **§4 Dialer (impulsions SHK + DTMF + debug)** → Tasks 1.2 (debug), 1.3 (impulsions) ✓ ; **DTMF Goertzel = non couvert explicitement** (voir note ci-dessous).
- **§5 Annuaire (12/3615/15/17/18 + Zacus)** → Task 2.1 ✓
- **§6 Contrat /v1/voice/turn (session_id/number/kind/audio, headers debug, /end)** → Tasks 2.4, 3.3 ✓
- **§7 Services IA (ailiance chat+TTS, whisper STT)** → Tasks 2.3, 3.2 ✓
- **§8 Dépendances (micro, whisper)** → Tasks 3.1, 3.2 ✓
- **§9 Mode dégradé** → Task 4.2 Step 2 ✓
- **§10 Erreurs (STT vide, réseau, raccroché, inconnu, cap)** → Tasks 2.4 (404 inconnu), 3.3 (fallback STT vide), 1.4 (raccroché/busy) ✓
- **§12 Build incrémental** → Stages 1-4 ✓
- **§13 Tests** → tests gateway pytest (2.x, 3.x) + tests banc firmware ✓

**Gap identifié — DTMF Goertzel** : le spec liste le DTMF comme 2ᵉ source de numérotation, mais le plan ne le détaille pas (seuls impulsions + debug sont couverts). **Décision** : le DTMF est repoussé en option post-Stage-1 (le cadran à impulsions + debug couvrent la cible « vintage à cadran » prioritaire). À ajouter comme Task 1.6 ultérieure si un téléphone à touches est utilisé : décodage Goertzel des 8 fréquences sur les frames de `audio_capture_read_frame`, derrière `CONFIG_PLIP_DIAL_DTMF`. Ce report est cohérent avec la cible (téléphone à cadran) confirmée au brainstorming.
