From 3d174931e9535e8ec7ffa93ad1a6f4cb67ff79b5 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Wed, 11 Nov 2026 20:36:22 +0100 Subject: [PATCH] Add the endurance run report and record the Phase 6 choices (refs #53 #54) "anubis soak" reads the bot's records over a time window and says whether the run kept control. It changes nothing, so it can run beside the working bot with docker exec. It exits with 4 when something needs a look. It checks: - the hours covered and silences longer than 15 minutes; - orders or decisions made twice; - unexplained reconciliation differences and each account's last outcome; - absences and guard interventions; - one crypto decision per daily close. ADR 0012 records what the specification leaves open in this phase: the live engine shares the backtest's decision call, run keys, recovery after an absence, the guard and its drill seams, the diary templates, the "senza bot" comparison, Telegram and the heartbeat, the screens and the endurance run. ROADMAP ticks the Phase 6 items and criteria with the tests that prove them, STATE moves on to Phase 7, and SVILUPPO explains the guard and the report. Co-Authored-By: Claude Opus 5.5 --- docs/ROADMAP.md | 26 ++-- docs/STATE.md | 24 ++- docs/SVILUPPO.md | 11 ++ docs/adr/0012-scelte-fase-6.md | 130 ++++++++++++++++ src/Anubis.Server/Program.cs | 6 + src/Anubis.Server/SoakCommand.cs | 77 ++++++++++ src/Anubis/Supervision/SoakReport.cs | 209 ++++++++++++++++++++++++++ tests/Anubis.Tests/SoakReportTests.cs | 85 +++++++++++ 8 files changed, 549 insertions(+), 19 deletions(-) create mode 100644 docs/adr/0012-scelte-fase-6.md create mode 100644 src/Anubis.Server/SoakCommand.cs create mode 100644 src/Anubis/Supervision/SoakReport.cs create mode 100644 tests/Anubis.Tests/SoakReportTests.cs 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; + } +}