diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index f43a54c..a05974e 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -13,9 +13,9 @@ aperta la fase. Se questo file e Gitea divergono, vale Gitea e si corregge quest | 1 | [Fondamenta](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/28) | Completata | | 2 | [Dati di mercato](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/29) | Completata (azioni in attesa delle chiavi Alpaca) | | 3 | [Conti, ordini, contabilità](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/30) | Completata (conti di prova in attesa delle chiavi) | -| 4 | [Backtest e laboratorio](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/31) | Da fare | -| 5 | [Strategie, portafoglio, rischio](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/32) | Da fare | -| 6 | [Motore dal vivo in simulazione](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/33) | Da fare | +| 4 | [Backtest e laboratorio](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/31) | Completata | +| 5 | [Strategie, portafoglio, rischio](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/32) | Completata (`crypto_trend` non superato, azionarie in attesa delle chiavi Alpaca) | +| 6 | [Motore dal vivo in simulazione](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/33) | Completata (prova di 48 ore in corso) | | 7 | [Notizie](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/34) | Da fare | | 8 | [Apprendimento](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/35) | Da fare | | 9 | [Rifinitura e consegna in Docker](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/milestone/36) | Da fare | @@ -184,25 +184,25 @@ Il bot che lavora da solo, in simulazione, giorno e notte, e lo racconta. **Lavori** -- [ ] [#47](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/47) Orchestrazione della giornata (5.5) e motore dal vivo in simulazione -- [ ] [#48](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/48) Processo di guardia, avvio e ripartenza sicuri -- [ ] [#49](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/49) Recupero dopo un'assenza (5.6) -- [ ] [#50](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/50) Diario con frasi in italiano dai codici motivo e confronto "senza bot" +- [x] [#47](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/47) Orchestrazione della giornata (5.5) e motore dal vivo in simulazione +- [x] [#48](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/48) Processo di guardia, avvio e ripartenza sicuri +- [x] [#49](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/49) Recupero dopo un'assenza (5.6) +- [x] [#50](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/50) Diario con frasi in italiano dai codici motivo e confronto "senza bot" - [ ] [#51](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/51) Schermate Panoramica e Diario e sistema -- [ ] [#52](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/52) Telegram e segnale di vita +- [x] [#52](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/52) Telegram e segnale di vita - [ ] [#53](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/53) Prova di durata di 48 ore in tempo reale - [ ] [#54](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/54) Chiusura della fase, revisione indipendente e tag `fase-6` **Criteri di accettazione** -- [ ] Il test di parità tra backtest e motore in simulazione passa, con correttivi e rischio attivi -- [ ] Una prova accelerata con orologio simulato copre almeno 10 giorni di mercato con guasti iniettati e termina con registro e conti riconciliati e senza ordini duplicati -- [ ] Un test blocca il ciclo principale con una vendita a metà e verifica che dopo la guardia la posizione abbia di nuovo i suoi stop e il motore sia ripartito; la stessa prova passa dentro l'immagine Docker -- [ ] Un test con orologio simulato spegne il bot per 3 ore, 20 ore e 3 giorni e verifica le righe di 5.6 i cui lavori esistono +- [x] Il test di parità tra backtest e motore in simulazione passa, con correttivi e rischio attivi (`TheLiveEngineMakesTheSameTradesAsTheBacktest` su 40 giorni di `crypto_trend`, `TheStockSideMakesTheSameTradesAsTheBacktest` su 6 settimane di `equity_meanrev`) +- [x] Una prova accelerata con orologio simulato copre almeno 10 giorni di mercato con guasti iniettati e termina con registro e conti riconciliati e senza ordini duplicati (`TenDaysWithFaultsEndReconciledWithoutDuplicateOrders`: 14 giorni con rete giù, risposta persa, ripartenza con un ordine a metà e database irraggiungibile, su SQLite e PostgreSQL) +- [x] Un test blocca il ciclo principale con una vendita a metà e verifica che dopo la guardia la posizione abbia di nuovo i suoi stop e il motore sia ripartito; la stessa prova passa dentro l'immagine Docker (`ALoopBlockedWithASaleHalfwayGetsItsStopBackAndTheEngineRestarts`, `TheGuardDrillPassesWithTheRealEngineAsChildProcess`; `docker run --rm drill` in `tasks ci` e nella CI: 7 controlli su 7) +- [x] Un test con orologio simulato spegne il bot per 3 ore, 20 ore e 3 giorni e verifica le righe di 5.6 i cui lavori esistono (`ThreeHoursOffRecoverTheCryptoDecisionAndDropAnEntryThatMovedTooFar`, `TwentyHoursOffLetTheLateDecisionsUpdateOnlyExitsAndDropExpiredEntries`, `ThreeDaysOffAreDeclaredUntilSeenAndMissedRunsAreMadeOnce`) - [ ] A fine fase parte una prova di durata in tempo reale di almeno 48 ore a cavallo di due sedute USA (solo crypto senza chiavi Alpaca) - [ ] In modalità dimostrativa la Panoramica corrisponde agli screen 01 (1440 px) e 09 (390 px) - [ ] Il Diario corrisponde allo screen 08 a 1440 px e a 390 px non scorre in orizzontale -- [ ] I comandi Telegram funzionano (o, senza token, superano i test con un finto server) +- [x] I comandi Telegram funzionano (o, senza token, superano i test con un finto server) — senza token, con un finto server: `TheCommandsWorkFromThePhoneThroughTheRealServer`, `FermaWantsAConfirmationWithinTwoMinutes`, `OnlyTheChatOfTheSettingsIsObeyedAndOldMessagesAreNot` e gli altri di `TelegramTests` ## Fase 7 — Notizie diff --git a/docs/STATE.md b/docs/STATE.md index 97e78b9..e9db65a 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -4,7 +4,7 @@ Aggiornato: 2026-11-11 ## Fase corrente -**Fase 5 — Strategie, portafoglio, rischio: completata.** La prossima è la Fase 6 (Motore dal vivo in simulazione), da iniziare con il via dell'utente. Nessuna delle tre strategie è ancora in simulazione: `crypto_trend` non ha superato il backtest e le due azionarie aspettano le chiavi di Alpaca. Restano in attesa delle chiavi demo di OKX e di Alpaca anche le prove sui conti di prova (Fase 3) e lo storico azionario (Fase 2). +**Fase 6 — Motore dal vivo in simulazione: completata.** La prova di durata di 48 ore è partita a fine fase sull'immagine Docker di questo PC (solo crypto, senza chiavi); il suo rapporto si controlla come primo passo della Fase 7 (Notizie), da iniziare con il via dell'utente. Nessuna strategia manda ordini: `crypto_trend` non ha superato il backtest e decide solo in osservazione, le due azionarie aspettano le chiavi di Alpaca. ## Fatto @@ -77,6 +77,14 @@ Aggiornato: 2026-11-11 - Stadi verso i soldi veri: osservazione, simulazione, reale ridotto, reale. Senza la procedura di 12.4 nessun ordine raggiunge un conto reale; una strategia retrocessa gestisce le uscite delle posizioni reali fino a zero; il gemello simulato resta fuori dai totali. In simulazione entra solo una strategia che ha superato il backtest. - Backtest onesti in `docs/backtests/` con `anubis backtest base`: storico Binance convertito in euro con il cambio BCE, monete tolte dal listino comprese, due universi, costi doppi e tripli, comprare e tenere accanto. **`crypto_trend` non supera** (calo massimo del 32,8% contro il 25% ammesso; probabilità di sovra-adattamento 0,84 su BTC, ETH e SOL) e resta in osservazione. Le due azionarie aspettano le chiavi di Alpaca. Gli esiti sono inclusi nell'applicazione e letti a ogni avvio. - Schermate Operazioni (con la scheda "perché" e l'esportazione CSV), Strategie e Rischio come i mockup 03, 04 e 07; in Impostazioni limiti, protezione per le operazioni in giornata e scenari. Fermare, chiudere e ripartire passano dal motore del rischio; alzare un limite mentre una strategia usa soldi veri chiede frase e password. +- **Fase 6** (scelte nell'ADR 0012): + - Motore dal vivo: ogni decisione passa dalla stessa chiamata del backtest (`DecideOnce`), agli orari di 5.5. Ogni decisione ha una chiave scritta nella stessa transazione dei suoi ordini pianificati e delle righe del diario, quindi una ripartenza non decide né manda niente due volte. Parità con il backtest provata su 40 giorni di `crypto_trend` e 6 settimane di `equity_meanrev`; 14 giorni con guasti iniettati finiscono riconciliati e senza ordini doppi. + - Recupero dopo un'assenza (5.6): l'assenza si misura dall'ultimo lavoro finito. I lavori persi si rifanno una volta o si saltano con il motivo. Le decisioni in ritardo aggiornano solo le uscite. Un'assenza di più di un giorno resta in Panoramica finché non la vedi. + - Processo di guardia: in Docker è il processo principale e il genitore del motore. Interviene dopo due minuti di silenzio, un avvio fermo dieci minuti o un'uscita senza preavviso. Annulla gli ordini a metà, rimette gli stop, avvisa e fa ripartire il motore. La terza ripartenza forzata in un'ora scrive il file STOP. La prova (`drill`) gira anche dentro l'immagine, in `tasks ci` e nella CI. + - Diario con le frasi fisse dell'appendice B e confronto "senza bot" (40% BTC, 60% SPY, ogni versamento investito nel suo giorno). + - Telegram: coda con stato, nuovi tentativi e abbandono dopo un giorno; comandi dal telefono solo dalla chat configurata e solo se recenti, `/ferma` con `/conferma`; riepilogo del mattino, stato facoltativo, segnale di vita ogni minuto. Sezione in Impostazioni. + - Schermate Panoramica e Diario e sistema come i mockup 01, 08 e 09. + - `anubis soak`: il rapporto di una prova di durata, letto dai registri del bot mentre lavora. ## In corso @@ -84,12 +92,15 @@ Nulla. ## Prossimo passo -Fase 6, motore dal vivo in simulazione: l'orchestrazione della giornata, il processo di guardia, il recupero dopo un'assenza, il Diario, Panoramica, Telegram e la prova di durata di 48 ore. Con le chiavi del conto paper di Alpaca si possono fare i backtest azionari (`anubis backtest base`) e chiudere i criteri in attesa delle Fasi 2 e 3. +1. Controllare il rapporto della prova di durata. Il container è `anubis-prova`; il comando è in `docs/SVILUPPO.md`, sezione "Guardia e prova di durata". +2. Poi la Fase 7, notizie. Con le chiavi del conto paper di Alpaca si possono anche fare i backtest azionari (`anubis backtest base`) e chiudere i criteri delle Fasi 2 e 3 in attesa. ## Da sapere - Le immagini .NET 10 sono su Ubuntu 24.04, non Debian (ADR 0006). -- La modalità dimostrativa mostra solo le parti già costruite: strategie e notizie della Panoramica arrivano con le loro fasi. Nella demo il motore di trading è spento. +- La modalità dimostrativa mostra le schermate costruite fin qui. Notizie e apprendimento appaiono solo con i dati dell'appendice F: fuori dalla demo arrivano con le Fasi 7 e 8. Nella demo il motore di trading e Telegram sono spenti. +- In Docker il processo principale è la guardia; fuori da Docker (`tasks dev`, VS Code) il server gira da solo. +- La guardia oggi apre solo i conti di prova: avrà i conti reali con la fase dei soldi veri (ADR 0012, punto 4). - Le chiavi dei conti di prova si inseriscono da Impostazioni → Conti e chiavi oppure nel file `.env`; quelle nelle variabili d'ambiente valgono di più. Una chiave OKX che permette i prelievi viene rifiutata. - Il capitale affidato si decide in euro in Impostazioni → Conti e chiavi. Finché non c'è, le strategie osservano soltanto. - `tasks dev` fuori da Docker usa la cartella dei dati vera dell'utente: per prove usa `tasks seed-demo`. @@ -97,7 +108,7 @@ Fase 6, motore dal vivo in simulazione: l'orchestrazione della giornata, il proc - OKX: WebSocket sulla porta 443, la 8443 è chiusa (API-NOTES O3). - Le coppie in EUR di OKX esistono da novembre 2023: prima di allora la storia crypto viene dagli archivi Binance in USDT. Il Laboratorio li usa nella loro valuta (ADR 0010, punto 13); i backtest delle strategie di base li convertono in euro con il cambio BCE del giorno (ADR 0011, punto 10). - `crypto_trend` resta in osservazione perché il suo backtest non è superato. Non ho ritoccato regole o soglie dopo aver visto il risultato: una nuova versione della strategia è una nuova prova, che il DSR conterà insieme alle precedenti. -- Il motore dal vivo (Fase 6) deve far girare una strategia con i parametri scritti nel suo file dell'esito (`parameters`), non con quelli predefiniti: sono quelli che si sono qualificati. +- Il motore dal vivo fa girare ogni strategia con i parametri scritti nel suo file dell'esito (`parameters`), non con quelli predefiniti: sono quelli che si sono qualificati. - Per rifare i backtest di base: `anubis backtest base --to AAAA-MM-GG --out docs/backtests` (con `--offline` usa gli archivi già scaricati). - Nella modalità dimostrativa il Laboratorio è spento: mostra l'elenco ma non esegue prove. - I dati di mercato si spengono con `ANUBIS_MARKET_DATA=off`; nella modalità dimostrativa sono sempre spenti. @@ -109,11 +120,12 @@ Fase 6, motore dal vivo in simulazione: l'orchestrazione della giornata, il proc | Cosa | Da quando serve | Senza | |---|---|---| -| Via libera per la Fase 6 | Subito | Non si parte | +| Via libera per la Fase 7 | Subito | Non si parte | | Chiavi del conto paper di Alpaca (`ALPACA_API_KEY_DEMO`, `ALPACA_API_SECRET_DEMO`) | Già dalla Fase 2 (dati azionari) | Parte azionaria spenta; storico azionario dal 2016 e backtest delle due strategie azionarie in attesa | | Chiavi demo di OKX Europe, senza permesso di prelievo | Fase 3 (ordini sui conti di prova) | Batteria di conformità su risposte d'esempio; criterio della Fase 3 in attesa | | Un token Gitea con permesso `write:package` come segreto `REGISTRY_TOKEN` | Fase 9 (pubblicazione dell'immagine) | Pubblicazione a mano | -| Token del bot Telegram e chat autorizzata (facoltativi) | Fase 6 | Test con un finto server | +| Token del bot Telegram e chat autorizzata (facoltativi), da Impostazioni → Telegram | Fase 6 | Nessun avviso sul telefono; comandi provati con un finto server | +| Un indirizzo per il segnale di vita (facoltativo, per esempio un controllo gratuito di Healthchecks.io) | Fase 6 | Nessuno avvisa se bot e guardia si spengono insieme | | Chiavi FRED e Finnhub (facoltative, gratuite) | Già dalla Fase 2 | Calendario limitato alla settimana corrente; filtro trimestrali spento | | Chiave di un modello linguistico (facoltativa) | Fase 7 | Solo classificatore locale | | Prova del template su Unraid | Fase 9 | Criterio in attesa | diff --git a/docs/SVILUPPO.md b/docs/SVILUPPO.md index 38f922a..aedd9ed 100644 --- a/docs/SVILUPPO.md +++ b/docs/SVILUPPO.md @@ -90,6 +90,17 @@ Apri la radice del repository in VS Code con l'estensione C# (`ms-dotnettools.cs Le attività `check`, `test` e `dev` sono anche in Terminale → Esegui attività. L'estensione è dell'editor, non del progetto: non entra nell'elenco dell'ADR 0004. +## Guardia e prova di durata + +- In Docker il processo principale è la guardia (`Anubis.Guard.dll`), che avvia il server come processo figlio (ADR 0012). Fuori da Docker, con `tasks dev` o da VS Code, il server gira da solo, senza guardia. +- La prova della guardia blocca davvero il motore con una vendita a metà e controlla che tutto torni a posto: + - `dotnet run --project src/Anubis.Guard -- drill` sul computer; + - `docker run --rm drill` dentro l'immagine. + + La fanno anche `tasks ci` e la CI. +- Il rapporto di una prova di durata si legge mentre il bot lavora: `docker exec -u 99:100 -e HOME=/tmp dotnet /app/Anubis.Server.dll soak --hours 48 --platform docker`, con l'utente del bot (`PUID:PGID`) perché i file del database restino suoi. Esce con 0 se tutto è regolare e con 4 se qualcosa va guardato. +- Gli appigli per le prove (`ANUBIS_FAULT`, `ANUBIS_DRILL_OKX_URL`) non si usano mai su un'installazione vera. + ## Pacchetti e consegne - **Docker**: immagine `gitea.encke-hake.ts.net/balbosoft/anubis`, pubblicata dalla CI sui tag `v*` nella sezione Packages del repository (ADR 0002). I tag `fase-N` non pubblicano nulla. diff --git a/docs/adr/0012-scelte-fase-6.md b/docs/adr/0012-scelte-fase-6.md new file mode 100644 index 0000000..e61b176 --- /dev/null +++ b/docs/adr/0012-scelte-fase-6.md @@ -0,0 +1,130 @@ +# 0012 — Scelte della Fase 6: motore dal vivo in simulazione + +Data: 2026-11-11 · Stato: accettata · Precisa la specifica (sezioni 5.5, 5.6, 7.4, 7.5, 9.3, 9.4, 13, 14) e gli ADR 0009–0011, senza aggiungere componenti esterni + +## Contesto + +La Fase 6 porta il bot che lavora da solo in simulazione: la giornata di 5.5, il recupero dopo un'assenza, il processo di guardia, il diario con le frasi dell'appendice B, Telegram con il segnale di vita, le schermate Panoramica e Diario e sistema, e la prova di durata in tempo reale. Alcune scelte non sono scritte nella specifica, o la precisano. Le raccolgo qui. + +## Decisione + +**1. Il motore dal vivo decide con la stessa chiamata del backtest.** +- Ogni decisione passa da `DecideOnce`, la stessa funzione che usa il motore di backtest, così prova e simulazione non possono divergere. Il test di parità lo controlla su 40 giorni di `crypto_trend` e su 6 settimane di `equity_meanrev`, con correttivi e rischio attivi. +- Gli orari sono quelli di 5.5: + - chiusura crypto alle 00:05 UTC; + - segnali azionari 20 minuti dopo la chiusura di Wall Street; + - uscite di `equity_meanrev` 5 minuti prima della chiusura; + - ordini azionari e stop del giorno all'apertura. +- Una strategia gira con i parametri scritti nel suo file dell'esito (`parameters`), cioè quelli che si sono qualificati, non con quelli predefiniti. +- Il motore parte dal pianificatore solo dopo che i conti sono stati riconciliati. + +**2. Ogni decisione si prende una volta sola, anche attraverso le ripartenze.** +- La decisione ha una chiave (`run_key`: strategia e chiusura su cui decide). Questa chiave viene scritta nella stessa transazione delle righe di decisione, degli ordini pianificati e delle righe del diario: o c'è tutto o non c'è niente. +- L'id di ogni ordine pianificato è l'id della decisione dell'intenzione, e da lì viene la chiave dell'ordine. Una ripartenza che trova l'esecuzione già presente non la manda una seconda volta. +- Gli ordini azionari decisi dopo la chiusura aspettano l'apertura nella tabella `planned_orders`. Ognuno ha una scadenza e un prezzo di riferimento. +- La prova accelerata copre 14 giorni con un guasto diverso nei giorni indicati: rete giù, una risposta persa, una ripartenza con un ordine a metà e il database irraggiungibile. Su SQLite e PostgreSQL termina riconciliata e senza ordini doppi. + +**3. Il recupero dopo un'assenza (5.6).** +- L'assenza si misura all'avvio dall'ultimo lavoro finito (`jobs.last_finished_at`). Sotto i 5 minuti è una ripartenza, non un'assenza. +- Ogni assenza va nel diario. Una più lunga di un giorno resta in cima alla Panoramica finché l'utente non l'ha vista. +- Ogni lavoro dichiara cosa fare con le esecuzioni perse: + - salvataggio, cambi, calendario di borsa e pulizia girano una volta alla ripartenza, comunque in ritardo; + - un lavoro con una scadenza si salta dopo quella scadenza, e il diario lo dice. +- Le azioni societarie si leggono prima che la riconciliazione rimetta gli stop. +- Una decisione presa in ritardo per l'assenza va nel diario come recuperata. Un'entrata il cui prezzo si è mosso troppo o che è scaduta si lascia cadere, con il suo motivo. + +**4. La guardia è il processo principale e il genitore del motore (9.3, 9.4).** +- In Docker il punto d'ingresso è `Anubis.Guard.dll`, che avvia `Anubis.Server.dll` come processo figlio con gli stessi argomenti. +- I due processi parlano su una pipe locale con nome (`ANUBIS_GUARD_PIPE`), un messaggio JSON per riga: + - il motore manda il battito, i passi dell'avvio, le chiavi dei conti (tenute solo in memoria) e gli stop che decide; + - la guardia manda solo "stop". +- La guardia interviene in tre casi: + - due minuti senza battito; + - un avvio fermo sullo stesso passo per dieci minuti; + - un'uscita del motore senza preavviso. +- Un salto dell'orologio oltre 30 secondi (computer sospeso) non conta come silenzio. +- Quando interviene, la guardia: + 1. ferma il motore; + 2. annulla i nostri acquisti e le nostre vendite rimasti aperti sui conti di prova; + 3. rimette gli stop che le posizioni richiedono, leggendoli dal file di stato che il motore scrive ogni dieci secondi; + 4. scrive una nota e avvisa l'utente; + 5. fa ripartire il motore. +- La terza ripartenza forzata in un'ora scrive il file STOP. +- Gli stop rimessi dalla guardia saltano 500 numeri di sequenza (`GuardRepair.SequenceGap`), così il loro id non si scontra mai con uno che il motore stava per mandare. +- Alla ripartenza il motore, prima di riconciliare: + - adotta gli stop della guardia; + - annulla gli ordini che aveva lasciato aperti (motivo `restart`); + - pianifica di nuovo le uscite già decise, che seguono così le regole di 5.6. +- Lo stop del container (SIGTERM) passa al motore, che chiude in ordine e non viene fatto ripartire. Il compose e il template Unraid concedono 60 secondi; la guardia ne aspetta 55. +- **I conti reali per ora sono fuori dalla guardia.** La guardia apre solo conti di prova. Avrà i conti reali con la fase dei soldi veri, quando riceverà anche la procedura di avvio di 12.4. Oggi nessuna strategia usa soldi veri. +- La guardia usa il runtime condiviso di ASP.NET (`FrameworkReference`): server e guardia stanno così nella stessa cartella `/app` dell'immagine, con le stesse librerie. + +**5. La prova della guardia ha due appigli, solo per la prova.** +- `ANUBIS_FAULT=hang-mid-sale` blocca il ciclo principale subito dopo l'invio di una vendita. La guardia non lo passa mai al motore che fa ripartire. +- `ANUBIS_DRILL_OKX_URL` indirizza il conto OKX della prova a un finto OKX. Funziona solo con indirizzi locali (loopback). +- La prova (`Anubis.Guard drill`) gira con processi veri in una cartella temporanea, anche dentro l'immagine Docker: lo fanno `tasks ci` e la CI. Fa sette controlli: + - la guardia è intervenuta; + - il motore è ripartito; + - la vendita era partita; + - la vendita rimasta a metà è stata annullata; + - lo stop è tornato per l'intera quantità; + - la vendita già decisa è ripartita con un ordine nuovo; + - la nota è nel diario. + +**6. Il diario si scrive con frasi fisse.** +- Le frasi nel tono dell'appendice B vengono da modelli (`DiaryText`) riempiti solo con ciò che è successo: esecuzioni con il risultato dell'operazione che chiudono, stop alzati, chiusura crypto, segnali azionari, segnali in osservazione, recupero e assenza. +- Le frasi dei codici motivo stanno nella libreria (`ReasonCatalog`), condivise da motore e schermate. Un test controlla che ogni codice abbia la sua frase. +- I generi del diario sono quelli della schermata: Ordini, Decisioni, Sistema, Notizie, Apprendimento. + +**7. Il confronto "senza bot" (7.5).** +- Ogni movimento di capitale viene investito nel suo giorno: 40% in BTC/EUR e 60% in SPY rettificato, convertito con il cambio BCE. Poi non si tocca più. +- Un prelievo vende i due nella proporzione che hanno raggiunto. +- I prezzi sono le chiusure del giorno prima, così un versamento non sembra mai un guadagno. +- Senza lo storico di SPY (niente chiavi Alpaca) la fotografia lascia vuoto il confronto, invece di mostrarne metà. + +**8. Telegram (14).** +- Ogni avviso va prima in coda (`notifications`), nella stessa transazione di ciò che racconta, e poi si spedisce. Il passo di spedizione gira ogni dieci secondi e manda al massimo 20 messaggi. +- Ogni messaggio ha uno stato: in attesa, spedito, oppure non riuscito con il suo errore. + - Rete giù e 429 si riprovano dopo 1, 2, 4… fino a 60 minuti, o dopo l'attesa indicata da Telegram se è più lunga; al massimo 8 tentativi. + - Un rifiuto di Telegram è definitivo. + - Un messaggio che non è partito entro un giorno si abbandona con il motivo, invece di arrivare tardi come se fosse una notizia. +- I comandi si leggono con il long polling. Valgono solo: + - dalla chat configurata (le altre si ignorano in silenzio); + - se hanno meno di 5 minuti, così un /pausa di ieri non mette in pausa oggi. +- `/ferma` chiede `/conferma` entro due minuti; qualsiasi altro comando nel frattempo la annulla. +- Ripartire dopo "Ferma tutto", i soldi veri, i limiti e le chiavi restano nell'interfaccia. +- Lavori in programma: + - riepilogo del mattino alle 08:00, recuperabile entro quattro ore; + - stato ogni ora o alle 20:00, solo se l'impostazione `telegram.status` lo chiede. +- Nella modalità dimostrativa Telegram è spento. +- Il passo Telegram del primo avvio resta in Impostazioni → Telegram: la pagina del primo avvio non ha ancora un database dove tenere i segreti. Quella pagina lo dice, e sul desktop raccomanda il segnale di vita. + +**9. Il segnale di vita.** Ogni minuto, se c'è un indirizzo, il bot chiama un servizio esterno (per esempio un controllo di Healthchecks.io). +- L'indirizzo viene da `ANUBIS_HEARTBEAT_URL`, oppure dal segreto `HEARTBEAT_URL` impostato da Impostazioni. +- È il servizio esterno ad avvisare se le chiamate smettono: copre il caso in cui bot e guardia sono spenti insieme. + +**10. Panoramica e Diario e sistema (13.6).** +- Le prossime mosse vengono dai lavori del pianificatore che sono mosse del bot; i lavori a intervallo (ogni minuto, ogni 5 minuti) non compaiono. Gli eventi del calendario economico tra le mosse ci sono solo nella demo, che usa i valori dell'appendice F.10; fuori dalla demo la riga "Prossima decisione" dice "tra X, alle HH:MM". +- Notizie e Apprendimento, fuori dalla demo, dicono "non ancora attivo" fino alle Fasi 7 e 8. +- Il Diario filtra per genere con semplici collegamenti, senza JavaScript. Il filtro Rischio raccoglie i codici del motore del rischio e quelli di ordini o stop rifiutati, chiavi con prelievo, conto prudente, intervento della guardia e salto dell'orologio. La ricerca ignora maiuscole e accenti, guarda le ultime 5.000 righe e ne mostra al massimo 200. "Mostra i giorni precedenti" aggiunge 7 giorni e compare solo se ci sono righe più vecchie. +- Non esiste ancora una pagina per una singola operazione: "Perché l'ho comprata e venduta" porta a Operazioni filtrata su quel titolo, dove la scheda "perché" si apre. +- Il computer che lo ospita: il processore è la quota di questo processo dall'ultima lettura; la memoria è quella del processo sul limite che .NET vede (nel container, il limite del container); lo spazio è quello del disco della cartella dei dati. +- "Scarica i registri tecnici" (`/api/registri.zip`) chiede l'accesso e mette nello zip solo i file `anubis-*.log` della cartella dei registri, già oscurati quando sono stati scritti. + +**11. La prova di durata.** +- `anubis soak` legge i registri del bot su una finestra di tempo e scrive un rapporto, senza cambiare niente. Può girare mentre il bot lavora, in Docker con `docker exec`. I suoi controlli: + - durata coperta; + - nessun silenzio oltre 15 minuti (la riconciliazione scrive una riga ogni 5); + - nessun ordine né decisione doppia; + - nessuna differenza inspiegata e ultima riconciliazione in regola per ogni conto; + - nessuno spegnimento; + - nessun intervento della guardia; + - una decisione `crypto_trend` per ogni chiusura giornaliera. +- La prova gira sull'immagine Docker di questo PC, con un volume suo, senza chiavi: conto crypto sul simulatore interno con prezzi veri di OKX, nessuna parte azionaria. +- `crypto_trend` non ha superato il backtest (ADR 0011, punto 13), quindi resta in osservazione: decide ogni notte, ma non manda ordini. Non la porto in simulazione per far vedere ordini: sarebbe aggirare il suo esito. Gli ordini, le ripartenze e i guasti sono coperti dalla prova accelerata (punto 2) e dalla prova della guardia (punto 5). + +## Conseguenze + +- Un riavvio, un crash o un'assenza non producono decisioni né ordini doppi: le chiavi e le transazioni lo garantiscono, e i test lo provano su entrambi i motori. +- I conti reali, quando arriveranno, avranno bisogno che anche la guardia sappia aprirli: è scritto qui per non dimenticarlo. +- Il rapporto della prova di durata si controlla come primo passo della Fase 7. diff --git a/src/Anubis.Server/Program.cs b/src/Anubis.Server/Program.cs index c145661..b14d60b 100644 --- a/src/Anubis.Server/Program.cs +++ b/src/Anubis.Server/Program.cs @@ -18,6 +18,12 @@ if (args.Length >= 1 && args[0] == "backtest") return await BacktestCommand.RunAsync(args[1..]).ConfigureAwait(false); } +// "anubis soak": the report of the endurance run in real time, read from the bot's records while it works (Phase 6). +if (args.Length >= 1 && args[0] == "soak") +{ + return await SoakCommand.RunAsync(args[1..]).ConfigureAwait(false); +} + var app = ServerApp.Build(args); await app.RunAsync().ConfigureAwait(false); return 0; diff --git a/src/Anubis.Server/SoakCommand.cs b/src/Anubis.Server/SoakCommand.cs new file mode 100644 index 0000000..1a1bc6b --- /dev/null +++ b/src/Anubis.Server/SoakCommand.cs @@ -0,0 +1,77 @@ +using System.Collections; +using System.Globalization; +using Anubis.Core; +using Anubis.Db; +using Anubis.Supervision; + +namespace Anubis.Server; + +/// +/// "anubis soak": the report of an endurance run in real time (SPEC 17, phase 6) from the bot's own records. It only +/// reads, so it can run while the bot works: in Docker with docker exec, on desktop from a second terminal. +/// +internal static class SoakCommand +{ + private const string Usage = + "Uso: anubis soak [--from AAAA-MM-GGTHH:MMZ] [--to AAAA-MM-GGTHH:MMZ] [--hours 48] [--out file.md]\n" + + " senza --from la prova è delle ultime --hours ore fino a --to (o adesso).\n" + + "Opzioni comuni: [--platform docker|desktop] [--data-dir ]"; + + /// 0 when the run is in order, 4 when something must be looked at, 1 when the report could not be made. + public static async Task RunAsync(string[] args, TextWriter? output = null, IReadOnlyDictionary? environment = null, IClock? clock = null) + { + output ??= Console.Out; + clock ??= new SystemClock(); + var own = new Dictionary(StringComparer.Ordinal); + var rest = new List(); + for (var i = 0; i < args.Length; i++) + { + if (args[i] is "--from" or "--to" or "--hours" or "--out" && i + 1 < args.Length) + { + own[args[i]] = args[++i]; + } + else if (args[i] is "--help" or "-h") + { + await output.WriteLineAsync(Usage).ConfigureAwait(false); + return 2; + } + else + { + rest.Add(args[i]); + } + } + + environment ??= Environment.GetEnvironmentVariables().Cast().ToDictionary(e => (string)e.Key, e => e.Value as string, StringComparer.Ordinal); + try + { + var hours = own.TryGetValue("--hours", out var h) ? double.Parse(h, CultureInfo.InvariantCulture) : 48; + var to = own.TryGetValue("--to", out var t) ? DateTimeOffset.Parse(t, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal) : clock.UtcNow; + var from = own.TryGetValue("--from", out var f) ? DateTimeOffset.Parse(f, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal) : to - TimeSpan.FromHours(hours); + var options = ServerOptions.Parse([.. rest], environment); + var config = options.LoadConfig(environment); + if (!config.IsComplete) + { + await output.WriteLineAsync("La configurazione d'avvio non è completa: avvia prima il server una volta.").ConfigureAwait(false); + return 1; + } + + Redactor.Register(config.Db!.Password); + await using var db = Database.Open(config.Db!, allowCreate: false); + var report = await SoakReporter.BuildAsync(db, from, to, TimeSpan.FromHours(hours), config.TimeZone, CancellationToken.None).ConfigureAwait(false); + var text = report.Markdown(config.TimeZone); + if (own.TryGetValue("--out", out var file)) + { + await File.WriteAllTextAsync(Path.GetFullPath(file), text).ConfigureAwait(false); + } + + await output.WriteAsync(text).ConfigureAwait(false); + return report.Passed ? 0 : 4; + } + catch (Exception ex) when (ex is IOException or FormatException or ArgumentException or InvalidOperationException or SchemaException + or System.Data.Common.DbException or UnauthorizedAccessException or TimeZoneNotFoundException) + { + await output.WriteLineAsync("Non riuscito: " + Redactor.Redact(ex.Message)).ConfigureAwait(false); + return 1; + } + } +} diff --git a/src/Anubis/Supervision/SoakReport.cs b/src/Anubis/Supervision/SoakReport.cs new file mode 100644 index 0000000..d0c0957 --- /dev/null +++ b/src/Anubis/Supervision/SoakReport.cs @@ -0,0 +1,209 @@ +using System.Globalization; +using System.Text; +using Anubis.Core; +using Anubis.Db; +using Anubis.Trading; + +namespace Anubis.Supervision; + +/// One check of the endurance run: what was looked at and whether it is in order. +public sealed record SoakCheck(string Text, bool Ok); + +/// +/// The report of an endurance run in real time (SPEC 17, phase 6): over a window of the bot's own records, whether it +/// kept working without losing control. It reads only what the bot wrote; it changes nothing. +/// +public sealed record SoakReport(DateTimeOffset From, DateTimeOffset To, IReadOnlyList Checks, IReadOnlyList Facts) +{ + public bool Passed => Checks.All(c => c.Ok); + + public string Markdown(TimeZoneInfo zone) + { + ArgumentNullException.ThrowIfNull(zone); + var text = new StringBuilder(); + text.AppendLine("# Prova di durata") + .AppendLine() + .AppendLine(CultureInfo.InvariantCulture, $"Dal {Moment(From, zone)} al {Moment(To, zone)} ({Hours(To - From)}).") + .AppendLine() + .AppendLine(Passed ? "**Esito: regolare.**" : "**Esito: da guardare.** Le righe segnate con ✗ dicono cosa.") + .AppendLine() + .AppendLine("## Controlli") + .AppendLine(); + foreach (var check in Checks) + { + text.AppendLine(CultureInfo.InvariantCulture, $"- {(check.Ok ? "✓" : "✗")} {check.Text}"); + } + + text.AppendLine().AppendLine("## Che cosa è successo").AppendLine(); + foreach (var fact in Facts) + { + text.AppendLine("- " + fact); + } + + return text.ToString(); + } + + internal static string Moment(DateTimeOffset moment, TimeZoneInfo zone) => + TimeZoneInfo.ConvertTime(moment, zone).ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture); + + internal static string Hours(TimeSpan span) => + Format.Number((decimal)Math.Round(span.TotalHours, 1), span.TotalHours % 1 == 0 ? 0 : 1) + " ore"; +} + +/// Builds the from the database. +public static class SoakReporter +{ + /// The reconciliation runs every 5 minutes: a longer silence than this means the bot stopped working. + public static readonly TimeSpan MaxSilence = TimeSpan.FromMinutes(15); + + public static async Task BuildAsync(Database db, DateTimeOffset from, DateTimeOffset to, TimeSpan minimum, TimeZoneInfo zone, + CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(db); + ArgumentNullException.ThrowIfNull(zone); + if (to <= from) + { + throw new ArgumentException("La fine della prova deve venire dopo l'inizio.", nameof(to)); + } + + return await db.ReadAsync(async s => + { + var checks = new List(); + var facts = new List(); + (string Name, object? Value)[] window = [("from", from), ("to", to)]; + + // Continuity: the reconciliation writes a row every 5 minutes, whatever it finds. + var beats = await s.QueryAsync("SELECT occurred_at FROM reconciliations WHERE occurred_at >= @from AND occurred_at <= @to ORDER BY occurred_at", + r => r.Moment("occurred_at"), window).ConfigureAwait(false); + var covered = beats.Count == 0 ? TimeSpan.Zero : beats[^1] - beats[0]; + checks.Add(new SoakCheck($"Durata coperta dal lavoro del bot: {SoakReport.Hours(covered)} (servono almeno {SoakReport.Hours(minimum)}).", covered >= minimum)); + var silences = new List<(DateTimeOffset Start, TimeSpan Length)>(); + var edges = new List { from }; + edges.AddRange(beats); + edges.Add(to); + for (var i = 1; i < edges.Count; i++) + { + if (edges[i] - edges[i - 1] > MaxSilence) + { + silences.Add((edges[i - 1], edges[i] - edges[i - 1])); + } + } + + checks.Add(new SoakCheck(silences.Count == 0 + ? $"Nessun silenzio più lungo di {Minutes(MaxSilence)} ({beats.Count} riconciliazioni)." + : $"Silenzi più lunghi di {Minutes(MaxSilence)}: " + + string.Join(", ", silences.Select(g => $"dal {SoakReport.Moment(g.Start, zone)} per {Minutes(g.Length)}")) + ".", silences.Count == 0)); + + // No order twice: one order per client id, one execution per order key, one decision per run key. + var doubled = await s.CountAsync("SELECT COUNT(*) FROM (SELECT client_order_id FROM orders GROUP BY client_order_id HAVING COUNT(*) > 1) d").ConfigureAwait(false) + + await s.CountAsync("SELECT COUNT(*) FROM (SELECT order_key FROM executions GROUP BY order_key HAVING COUNT(*) > 1) d").ConfigureAwait(false) + + await s.CountAsync("SELECT COUNT(*) FROM (SELECT run_key FROM engine_runs GROUP BY run_key HAVING COUNT(*) > 1) d").ConfigureAwait(false); + checks.Add(new SoakCheck(doubled == 0 ? "Nessun ordine né decisione doppia." : $"Ordini o decisioni doppie: {doubled}.", doubled == 0)); + + // Reconciliations: never an unexplained difference, and every account ends in agreement. + var outcomes = await s.QueryAsync( + "SELECT a.name AS account, r.outcome AS outcome, COUNT(*) AS n FROM reconciliations r JOIN accounts a ON a.id = r.account_id " + + "WHERE r.occurred_at >= @from AND r.occurred_at <= @to GROUP BY a.name, r.outcome ORDER BY a.name, r.outcome", + r => (Account: r.Text("account"), Outcome: r.Text("outcome"), Count: r.Number("n")), window).ConfigureAwait(false); + var different = outcomes.Where(o => o.Outcome == ReconcileOutcomes.Different).Sum(o => o.Count); + checks.Add(new SoakCheck(different == 0 ? "Nessuna differenza inspiegata tra registro e conti." : $"Riconciliazioni con differenze inspiegate: {different}.", different == 0)); + var last = await s.QueryAsync( + "SELECT a.name AS account, r.outcome AS outcome FROM reconciliations r JOIN accounts a ON a.id = r.account_id " + + "WHERE r.occurred_at = (SELECT MAX(x.occurred_at) FROM reconciliations x WHERE x.account_id = r.account_id AND x.occurred_at <= @to) ORDER BY a.name", + r => (Account: r.Text("account"), Outcome: r.Text("outcome")), ("to", to)).ConfigureAwait(false); + var agreed = last.All(l => l.Outcome is ReconcileOutcomes.Clean or ReconcileOutcomes.Healed); + checks.Add(new SoakCheck(last.Count == 0 + ? "Nessun conto riconciliato." + : "Ultima riconciliazione: " + string.Join(", ", last.Select(l => $"{l.Account} {Outcome(l.Outcome)}")) + ".", last.Count > 0 && agreed)); + foreach (var group in outcomes.GroupBy(o => o.Account, StringComparer.Ordinal)) + { + facts.Add($"Riconciliazioni di {group.Key}: " + string.Join(", ", group.Select(o => $"{o.Count} {Outcome(o.Outcome)}")) + "."); + } + + // The bot was never away and the guard never had to step in. + var absences = await s.QueryAsync("SELECT started_at, ended_at FROM absences WHERE ended_at >= @from AND started_at <= @to ORDER BY started_at", + r => (Start: r.Moment("started_at"), End: r.Moment("ended_at")), window).ConfigureAwait(false); + checks.Add(new SoakCheck(absences.Count == 0 + ? "Il bot non si è mai spento." + : "Spento: " + string.Join(", ", absences.Select(a => $"dal {SoakReport.Moment(a.Start, zone)} per {Minutes(a.End - a.Start)}")) + ".", absences.Count == 0)); + var interventions = await s.CountAsync("SELECT COUNT(*) FROM journal WHERE code = 'guard_intervention' AND occurred_at >= @from AND occurred_at <= @to", window) + .ConfigureAwait(false); + checks.Add(new SoakCheck(interventions == 0 ? "La guardia non è mai dovuta intervenire." : $"Interventi della guardia: {interventions}.", interventions == 0)); + + // A crypto decision at every daily close in the window (00:05 UTC), whatever the stage of the strategy. + var closes = DailyCloses(from, to); + var runs = await s.QueryAsync("SELECT strategy, mode, COUNT(*) AS n FROM engine_runs WHERE created_at >= @from AND created_at <= @to GROUP BY strategy, mode ORDER BY strategy, mode", + r => (Strategy: r.Text("strategy"), Mode: r.Text("mode"), Count: r.Number("n")), window).ConfigureAwait(false); + var crypto = runs.Where(r => r.Strategy == StrategyNames.CryptoTrend).Sum(r => r.Count); + checks.Add(new SoakCheck($"Decisioni di {StrategyNames.CryptoTrend}: {crypto} su {closes} chiusure giornaliere.", crypto >= closes)); + facts.Add(runs.Count == 0 + ? "Nessuna decisione del motore." + : "Decisioni del motore: " + string.Join(", ", runs.Select(r => $"{r.Strategy} {r.Count} ({Mode(r.Mode)})")) + "."); + + // What the bot did and wrote, for the record. + facts.Add(Counted("Ordini", await GroupAsync(s, "SELECT status AS k, COUNT(*) AS n FROM orders WHERE created_at >= @from AND created_at <= @to GROUP BY status", window) + .ConfigureAwait(false))); + facts.Add(Counted("Esecuzioni", await GroupAsync(s, "SELECT status AS k, COUNT(*) AS n FROM executions WHERE created_at >= @from AND created_at <= @to GROUP BY status", window) + .ConfigureAwait(false))); + facts.Add(Counted("Ordini pianificati", await GroupAsync(s, + "SELECT status AS k, COUNT(*) AS n FROM planned_orders WHERE created_at >= @from AND created_at <= @to GROUP BY status", window).ConfigureAwait(false))); + facts.Add(Counted("Righe del diario", await GroupAsync(s, "SELECT kind AS k, COUNT(*) AS n FROM journal WHERE occurred_at >= @from AND occurred_at <= @to GROUP BY kind", window) + .ConfigureAwait(false))); + facts.Add(Counted("Messaggi Telegram", await GroupAsync(s, + "SELECT status AS k, COUNT(*) AS n FROM notifications WHERE created_at >= @from AND created_at <= @to GROUP BY status", window).ConfigureAwait(false))); + facts.Add(Counted("Eventi di rischio", await GroupAsync(s, "SELECT kind AS k, COUNT(*) AS n FROM risk_events WHERE occurred_at >= @from AND occurred_at <= @to GROUP BY kind", window) + .ConfigureAwait(false))); + facts.Add(Counted("Problemi nei dati", await GroupAsync(s, + "SELECT kind || ' ' || status AS k, COUNT(*) AS n FROM data_issues WHERE created_at >= @from AND created_at <= @to GROUP BY kind, status", window).ConfigureAwait(false))); + var failing = await s.QueryAsync("SELECT name, last_error FROM jobs WHERE last_error IS NOT NULL AND last_finished_at >= @from ORDER BY name", + r => r.Text("name") + " (" + Redactor.Redact(r.Text("last_error")) + ")", ("from", from)).ConfigureAwait(false); + facts.Add(failing.Count == 0 ? "Nessun lavoro in programma è finito con un errore all'ultima esecuzione." : "Lavori con un errore all'ultima esecuzione: " + string.Join("; ", failing) + "."); + return new SoakReport(from, to, checks, facts); + }, cancellationToken).ConfigureAwait(false); + } + + /// How many crypto daily decisions (00:05 UTC) fall in the window. + public static int DailyCloses(DateTimeOffset from, DateTimeOffset to) + { + var count = 0; + for (var day = DateOnly.FromDateTime(from.UtcDateTime); ; day = day.AddDays(1)) + { + var close = new DateTimeOffset(day.ToDateTime(new TimeOnly(0, 5)), TimeSpan.Zero); + if (close > to) + { + return count; + } + + if (close >= from) + { + count++; + } + } + } + + private static Task> GroupAsync(DbSession s, string sql, (string Name, object? Value)[] window) => + s.QueryAsync(sql, r => (Key: r.TextOrNull("k") ?? "?", Count: r.Number("n")), window); + + private static string Counted(string what, List<(string Key, long Count)> groups) => + groups.Count == 0 ? what + ": nessuno." : $"{what}: {groups.Sum(g => g.Count)} (" + string.Join(", ", groups.Select(g => $"{g.Key} {g.Count}")) + ")."; + + private static string Minutes(TimeSpan span) => + span.TotalMinutes < 120 ? Format.Number((decimal)Math.Round(span.TotalMinutes)) + " minuti" : SoakReport.Hours(span); + + private static string Outcome(string outcome) => outcome switch + { + ReconcileOutcomes.Clean => "in regola", + ReconcileOutcomes.Healed => "sistemate da sole", + ReconcileOutcomes.Different => "con differenze", + ReconcileOutcomes.Unreachable => "conto non raggiungibile", + _ => outcome, + }; + + private static string Mode(string mode) => mode switch + { + DecisionModes.Observation => "in osservazione", + DecisionModes.ExitsOnly => "solo uscite", + DecisionModes.Full => "complete", + _ => mode, + }; +} diff --git a/tests/Anubis.Tests/SoakReportTests.cs b/tests/Anubis.Tests/SoakReportTests.cs new file mode 100644 index 0000000..b8c0e75 --- /dev/null +++ b/tests/Anubis.Tests/SoakReportTests.cs @@ -0,0 +1,85 @@ +using Anubis.Core; +using Anubis.Data; +using Anubis.Supervision; +using Anubis.Trading; + +namespace Anubis.Tests; + +/// The report of the endurance run (SPEC 17, phase 6): regular when the bot kept working, and it says what was not. +[TestClass] +public sealed class SoakReportTests +{ + private static readonly DateTimeOffset From = new(2026, 11, 11, 18, 0, 0, TimeSpan.Zero); + private static readonly DateTimeOffset To = From.AddHours(49); + + [TestMethod] + public void TheDailyCryptoClosesAreCountedInTheWindow() + { + Assert.AreEqual(2, SoakReporter.DailyCloses(From, To)); // 12 and 13 November at 00:05 UTC + var close = new DateTimeOffset(2026, 11, 11, 0, 5, 0, TimeSpan.Zero); + Assert.AreEqual(1, SoakReporter.DailyCloses(close, close)); + Assert.AreEqual(3, SoakReporter.DailyCloses(close, To)); + Assert.AreEqual(0, SoakReporter.DailyCloses(From, From.AddHours(5))); + } + + [TestMethod] + [TestCategory(Category.Integration)] + public async Task AQuietRunIsRegularAndTroublesAreNamed() + { + await using var rig = await TradingRig.CreateAsync().ConfigureAwait(false); + var okx = await rig.AccountAsync("okx", "demo").ConfigureAwait(false); + var reconciliations = new List(); + for (var at = From.AddMinutes(1); at <= To; at += TimeSpan.FromMinutes(5)) + { + reconciliations.Add(await ReconciledAsync(rig, okx.AccountId, at, ReconcileOutcomes.Clean).ConfigureAwait(false)); + } + + foreach (var day in new[] { 12, 13 }) + { + var at = new DateTimeOffset(2026, 11, day, 0, 5, 0, TimeSpan.Zero); + await rig.Db.WriteAsync(s => s.ExecuteAsync( + "INSERT INTO engine_runs (id, strategy, run_key, decision_day, decision_id, mode, state, proposed, created_at) VALUES (@id, @s, @k, @d, @dec, @m, NULL, NULL, @at)", + CancellationToken.None, ("id", Guid.NewGuid()), ("s", StrategyNames.CryptoTrend), ("k", $"{StrategyNames.CryptoTrend}:2026-11-{day - 1}"), + ("d", $"2026-11-{day - 1}"), ("dec", Guid.NewGuid()), ("m", DecisionModes.Observation), ("at", at))).ConfigureAwait(false); + } + + var report = await SoakReporter.BuildAsync(rig.Db, From, To, TimeSpan.FromHours(48), Zones.Rome).ConfigureAwait(false); + Assert.IsTrue(report.Passed, report.Markdown(Zones.Rome)); + var text = report.Markdown(Zones.Rome); + Assert.Contains("**Esito: regolare.**", text); + Assert.Contains("Decisioni di crypto_trend: 2 su 2 chiusure giornaliere.", text); + Assert.Contains("crypto_trend 2 (in osservazione)", text); + Assert.Contains("Ordini: nessuno.", text); + + // Half an hour of silence, an unexplained difference at the end and a guard intervention: each one is named. + await rig.Db.WriteAsync(async s => + { + foreach (var id in reconciliations.Skip(100).Take(6)) + { + await s.ExecuteAsync("DELETE FROM reconciliations WHERE id = @id", CancellationToken.None, ("id", id)).ConfigureAwait(false); + } + + rig.Clock.Set(From.AddHours(20)); + await Diary.WriteAsync(s, rig.Clock, DiaryKinds.System, "guard_intervention", "La guardia è intervenuta.", null, CancellationToken.None).ConfigureAwait(false); + }).ConfigureAwait(false); + await ReconciledAsync(rig, okx.AccountId, To, ReconcileOutcomes.Different).ConfigureAwait(false); + + report = await SoakReporter.BuildAsync(rig.Db, From, To, TimeSpan.FromHours(48), Zones.Rome).ConfigureAwait(false); + Assert.IsFalse(report.Passed); + var failed = report.Checks.Where(c => !c.Ok).Select(c => c.Text).ToList(); + Assert.HasCount(4, failed, string.Join(" | ", failed)); + Assert.IsTrue(failed.Any(f => f.StartsWith("Silenzi più lunghi di 15 minuti: dal 12/11/2026 03:16 per 35 minuti", StringComparison.Ordinal)), string.Join(" | ", failed)); + Assert.Contains("Riconciliazioni con differenze inspiegate: 1.", failed); + Assert.Contains("Interventi della guardia: 1.", failed); + Assert.IsTrue(failed.Any(f => f.Contains("con differenze", StringComparison.Ordinal))); + Assert.Contains("**Esito: da guardare.**", report.Markdown(Zones.Rome)); + } + + private static async Task ReconciledAsync(TradingRig rig, Guid account, DateTimeOffset at, string outcome) + { + var id = Guid.NewGuid(); + await rig.Db.WriteAsync(s => s.ExecuteAsync("INSERT INTO reconciliations (id, account_id, outcome, details, occurred_at, created_at) VALUES (@id, @a, @o, @d, @at, @at)", + CancellationToken.None, ("id", id), ("a", account), ("o", outcome), ("d", new Anubis.Db.DbJson("{}")), ("at", at))).ConfigureAwait(false); + return id; + } +}