Documentazione: compatibilità con Codex e interruttore CLI

ADR-0002 passa ad Accettata per Claude Code e Codex con l'esito delle prove
reali: id di sessione da thread.started, output JSONL, risposta = ultimo
agent_message, ripresa senza -s e sola lettura via sandbox_mode, -- prima del
prompt. MVP, ROADMAP, INSTALL e README descrivono l'interruttore CLI, la
nuova opzione --engine e il problema del modello predefinito che richiede un
Codex più recente. TESTING.md aggiunge le righe CX, EN e ST-12.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

docs/adr/0002-motori-cli-claude-codex-antigravity.md

@@ -1,6 +1,6 @@
 # ADR-0002 — Più motori CLI (Claude Code, Codex, Antigravity) su Windows e Linux
 
-- **Stato**: Proposta
+- **Stato**: Accettata per Claude Code e Codex (verificati con prove reali); Antigravity resta da verificare
 - **Data**: 2026-10-15
 - **Collegato a**: [ADR-0001](0001-gui-multipiattaforma-avalonia.md) (GUI e piattaforme)
 
@@ -17,31 +17,45 @@ L'app lancia solo `claude -p`. Si vuole usare dalla stessa chat anche **OpenAI C
 - **Astrazione "motore"** in C#. Ogni motore descrive: nome e eseguibile, argomenti per il primo messaggio e per la ripresa, elenco modelli, supporto effort, modo per ottenere l'id di sessione. `RunClaude` diventa `RunEngine(engine, …)`.
 - **Rilevamento** dei motori cercando l'eseguibile nel PATH (su Windows anche le estensioni di PATHEXT). I motori assenti sono disabilitati nelle Impostazioni, con messaggio chiaro; la CLI esce con 127 come oggi.
 - **Una chat = un motore**. Il file JSON della chat memorizza il motore; il contesto di sessione non passa da un motore all'altro, quindi cambiare motore apre una nuova chat.
-- **Impostazioni** nella GUI: motore attivo, modello, effort (solo se supportato), persistite su disco accanto alla cronologia. La CLI ottiene `--engine`.
+- **Impostazioni** nella GUI: interruttore **CLI** (motore attivo), modello, effort. Cambiare motore apre una nuova chat; modello ed effort tornano a "Predefinito" e le liste sono quelle del motore. La persistenza su disco delle impostazioni è rinviata. La CLI ottiene `--engine <id>` (`claude`, `codex`).
+- **Sessione**: per Claude Code l'id lo sceglie l'app; per Codex lo genera Codex e l'app lo legge dall'output (`thread_id`). Il JSON della chat ha quindi un campo `Engine` e un campo `SessionId` separato dall'id della chat (che resta il nome del file). I file scritti prima (senza questi campi) si leggono come chat di Claude Code con `SessionId` = id della chat.
+- **Autore dei messaggi**: l'etichetta sulle risposte e i segnaposto del composer usano il nome del motore della chat; l'elenco chat indica il motore.
 - **Permessi**: di default sola lettura / nessun bypass dei controlli; concedere di più è un'opzione esplicita.
 - **Output**: ogni motore ha un parser che lo normalizza in testo markdown prima del rendering.
 
 ## Comandi dei motori
-Da verificare con `--help` delle versioni installate: derivano da documentazione e ricerche, non da prove su questo PC, dove `codex` e `agy` non sono installati.
+Claude Code e Codex sono verificati con prove reali (Codex 0.144.3, 2026-10-15, Linux/WSL). Antigravity deriva da documentazione e ricerche: `agy` non è installato su questa macchina.
 
 | | Claude Code | Codex CLI | Antigravity CLI |
 |---|---|---|---|
-| Comando | `claude -p <prompt>` | `codex exec <prompt>` | `agy -p <prompt>` |
-| Continuare | `--session-id <guid>` poi `--resume <guid>` | `codex exec resume <id> <prompt>` | da verificare |
+| Comando (GUI) | `claude -p <prompt>` | `codex exec --json --skip-git-repo-check -s read-only [opzioni] -- <prompt>` | `agy -p <prompt>` (da verificare) |
+| Continuare | `--session-id <guid>`, poi `--resume <guid>` | `codex exec resume --json --skip-git-repo-check -c 'sandbox_mode="read-only"' [opzioni] <id> -- <prompt>` | da verificare |
 | Modello | `--model` | `-m` / `--model` | da verificare |
-| Effort | `--effort` | via `--config` (da verificare) | non noto |
+| Effort | `--effort` | `-c model_reasoning_effort=<livello>` | non noto |
+| Output usato | testo su stdout | JSONL su stdout (vedi sotto) | da verificare |
+
+**Codex: esito delle prove**
+- L'id di sessione non si sceglie: compare nel primo evento JSONL `{"type":"thread.started","thread_id":"<uuid>"}`. Nel testo normale compare solo nell'intestazione su stderr.
+- Con `--json`, stdout contiene solo eventi: `thread.started`, `turn.started`, `item.completed` (con `item.type = "agent_message"` e il testo della risposta; con `"error"` sono avvisi non fatali), `turn.completed`, e in caso di errore `error` e `turn.failed`. Il messaggio di errore è una stringa che contiene a sua volta un JSON (`error.message`): l'app estrae il messaggio interno. L'exit code è 1 se il turno fallisce.
+- La risposta mostrata è l'**ultimo** `agent_message` del turno (come `--output-last-message`).
+- `exec resume` **non accetta `-s/--sandbox`**: la sola lettura si ottiene con `-c 'sandbox_mode="read-only"'`, verificato (un file richiesto in scrittura non viene creato). Accetta `-m` e `-c`.
+- `--skip-git-repo-check` serve perché la cartella dell'exe non è un repository Git.
+- `--` prima del prompt evita che un prompt che inizia con `-` sia letto come opzione (verificato).
+- Lo stdin va chiuso subito, come per Claude Code: altrimenti Codex stampa "Reading additional input from stdin…" e attende.
+- Il modello predefinito è quello di `~/.codex/config.toml`. Se richiede una versione più recente di Codex l'errore è chiaro (`requires a newer version of Codex`): l'app lo mostra e [INSTALL.md](../INSTALL.md) indica `codex update`.
+- Il catalogo modelli di Codex è dinamico (`~/.codex/models_cache.json`); l'app ne usa uno fisso, da aggiornare, con "Predefinito" e "Altro ID…" sempre disponibili.
 
 ## Conseguenze
 **Positive**: un solo flusso di avvio; nuovi motori aggiungibili con una definizione; elimina la duplicazione CLI/GUI.
 **Negative**: i flag delle CLI cambiano nel tempo e vanno mantenuti; le sessioni non si trasferiscono tra motori; più superficie da testare su due sistemi operativi.
 
 ## Rischi e da verificare
-- [ ] **Codex**: l'id di sessione lo genera Codex e non l'app; va letto dall'output (probabilmente con output JSON) per riprendere la chat.
+- [x] **Codex**: l'id di sessione lo genera Codex; letto dall'evento `thread.started` (vedi sopra).
 - [ ] **Antigravity**: segnalato un blocco di `agy -p` da sottoprocesso con output rediretto su Windows ([issue #318](https://github.com/google-antigravity/antigravity-cli/issues/318)). Provare con `--print-timeout` e prevedere un messaggio d'errore. I flag vanno messi prima di `-p`. Da provare anche su Linux.
 - [ ] **Forma dell'eseguibile**: `claude` è un .exe nativo avviabile direttamente; Codex e Antigravity, se installati con un gestore di pacchetti (es. npm), su Windows possono essere script `.cmd` che richiedono `cmd.exe /c`. Su Linux sono normali eseguibili o script con shebang. Verificare e gestire per motore.
 - [ ] Autenticazione: ogni CLI deve essere già autenticata; l'app mostra l'errore del motore senza gestire login.
-- [ ] Formato dell'output (testo o JSON) e normalizzazione per ciascun motore.
-- [ ] Mappatura effort e modelli per motore, con elenco modelli aggiornabile.
+- [x] Formato dell'output di Codex: JSONL, normalizzato in testo markdown. Antigravity ancora da verificare.
+- [x] Mappatura effort e modelli per Codex (liste fisse, da aggiornare). Antigravity da verificare.
 
 ## Riferimenti
 - Passi: [ROADMAP.md](../ROADMAP.md), Fase 4.

docs/adr/0003-strategia-di-test.md

@@ -22,7 +22,7 @@ Oggi non esistono test. L'app gira su due sistemi operativi, ha una CLI, una GUI
 - **Livelli**: unitari (Core, ViewModel, renderer markdown), componenti GUI headless (finestra, template, tastiera), end-to-end sull'eseguibile pubblicato (CLI e codice 127) e smoke di publish per `win-x64` e `linux-x64`.
 - **Predisposizioni di testabilità** nel codice (da fare insieme ai primi test):
   - `ChatStore` diventa un'istanza con cartella iniettata, non uno statico legato a `LocalApplicationData`.
-  - L'esecuzione di `claude` sta dietro un'interfaccia (`IClaudeRunner`) iniettata nel ViewModel; l'implementazione reale resta in `Core/Claude.cs`. I test del ViewModel usano un finto runner; quelli di `Claude` usano `FakeClaude`.
+  - L'esecuzione dei motori sta dietro un'interfaccia (`IEngineRunner`) iniettata nel ViewModel; l'implementazione reale resta in `Core/EngineRunner.cs`. I test del ViewModel usano un finto runner; quelli di `EngineRunner` usano `FakeClaude` (che con la configurazione giusta imita anche Codex).
   - La conferma di eliminazione, gli appunti e il focus sono già delegati (`ConfirmDelete`, `CopyText`, `FocusInput`) e restano sostituibili.
   - Gli ADR-0002 (motori) richiedono che ogni motore abbia la propria batteria di test sugli argomenti e sul parser dell'output.
 - **Struttura del repo**: codice dell'app in `src/agent-wiki-ui/`, test in `tests/`, soluzione unica alla radice. Così il globbing del csproj dell'app non include i sorgenti dei test. Il progetto dell'app espone gli `internal` ai test con `InternalsVisibleTo`.