32 Commits
Author SHA1 Message Date
Alby96andClaude Opus 5.5 b033896ebb 5.1 verifica finale prima del rilascio: screenshot rifatti sul server campione, /logout fra le rotte libere del contratto, due controlli dell'interfaccia nella suite
Verifica indipendente della 5.1 e delle sue due revisioni prima del push e dell'immagine: compilazione con 0 avvisi e 0 errori, 561 test verdi (anche nella cartella di Verifica della catena), classi di concorrenza e web ripetute. Server vero su una sandbox con password: cookie, 401 senza sessione, 415 e 403 con il file intatto, salvataggio JSON subito nel tick, AVVIA senza chiavi rifiutato in italiano, arresto pulito. Server --sample: 50 rotte a 200, 12 scritture a 400, cartella temporanea cancellata. Le nove pagine in Edge senza errori né scorrimento orizzontale a 1440 e 420 px; docs/API.md confrontato campo per campo con il JSON vero.

- Screenshot di docs/img rifatti con scripts/screenshots.ps1: mostrano l'interfaccia dopo le revisioni.
- docs/API.md e UI_GUIDELINES: /logout è libera senza sessione; il codice lo permetteva già, il contratto non lo diceva.
- EmbeddedUiTests: ogni icona nominata dai moduli esiste in icons.js, e solo api() di util.js chiama il server e manda Content-Type: application/json a ogni scrittura. I controlli della corsia interfaccia stavano solo fuori dal repository; i due nuovi falliscono entrambi su una mutazione.
- STATE e CHANGELOG: 561 test e la verifica finale nell'elenco dei commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 19:01:11 +02:00
Alby96andClaude Opus 5.5 1cbd5a801a 5.1 seconda revisione: stato della 5.0 al conto giusto, kill-switch protetti fino alla fine, perdita giornaliera con lo storico in ritardo, cookie che non è più un tentativo di password
Una seconda verifica indipendente delle correzioni della revisione ha trovato nove punti ancora aperti; ognuno ha ora un test che lo riproduce.

- Stato della 5.0: il mode di baskets_state.json della 5.0 era la modalità, non il conto. Un file Live scritto con etoro.environment demo finiva nel file del conto reale e al primo Live il saldo del demo diventava un prelievo di oltre 100 000 USD (equity stop e perdita giornaliera misurati sulla cifra sbagliata); un file Paper riprendeva basket simulati sul conto demo. L'importazione registra ora su che conto operava la 5.0 (legacyState in import-5.1.json) e la migrazione porta lì il file, con il mode del conto; Paper, o una modalità diversa da quella registrata, restano solo come .migrato. Anche la guardia a motore fermo conta il file per quel conto.
- Comandi critici: kill-switch, chiusure e chiusura dei residui li conta il motore dalla coda alla fine sul thread di decisione (IEngine.CriticalCommand), non il chiamante: una scheda chiusa, un 504 dopo 120 s o Telegram spento a metà /kill liberavano FERMA a metà kill-switch.
- Chiavi salvate durante la verifica (fino a 25 s): conto in uso e motore si rileggono sotto il lucchetto; chiavi non più del conto del motore non lo riavviano e un motore Live non viene mai riavviato senza la frase (prima restava fermo con i basket reali sui soli stop nativi).
- Guardia del cambio di conto: il motore riconcilia con il conto prima di contare, così una gamba rimasta sola (richiusura rifiutata) conta come orfana; posizioni non lette: rifiutato.
- Perdita giornaliera con lo storico in ritardo: la sospensione resta fino alla spiegazione anche se l'equity recupera e la lettura che spiega il calo giudica la giornata sul minimo toccato (una perdita la blocca, un movimento di cassa no); la vista lo mostra per tutto il tempo.
- Apprendimento: l'avvio sull'altro conto che corregge righe della 4.0-5.0 dopo il ritiro rimaschera lastNOutcomes fino ad allora e rifà la sola logistica (ReplayLogistic); a motore fermo una parte mai letta bene resta «valori iniziali» anche alle letture successive.
- Accesso: il cookie di sessione contiene un segreto del server (/config/session.key), quindi non si calcola da una password indovinata e non passa più dall'attesa: una scheda rimasta aperta dopo un cambio di password non tiene fuori la password giusta (prima 429 finché restava aperta), una pagina già entrata non viene fermata da chi tenta password dallo stesso indirizzo; l'interfaccia torna al login a un 401 o 429; la risposta a una password errata arriva solo ad attesa davvero finita.
- Test del preset d'ingresso rafforzati (togliere una delle due righe non faceva fallire niente).

API.md, ADR, QUESTIONS (D-53, D-54, D-56), RUNBOOK, guida Unraid, CHANGELOG e STATE aggiornati. Build 0 avvisi, 559 test verdi.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 18:32:09 +02:00
Alby96andClaude Opus 5.5 dcb274e603 5.1.0: versione e documenti allineati al codice della 5.1 e della sua revisione
Fino a qui i documenti descrivevano ancora la 5.0 (variabili d'ambiente, token, Paper,
--confirm-live, comando preset, interfaccia Material 3, un solo file di stato) e il codice
era già la 5.1: chi aggiornava il container o riprendeva il lavoro avrebbe seguito
istruzioni sbagliate. Ora ogni documento dice ciò che il codice fa.

- Versione di sviluppo 5.1.0 (D-50).
- ADR nuovi: 0010 configurazione dall'interfaccia con una sola password (con stato per
  conto, guardia del cambio di conto nel motore, attesa dopo password errata, richieste da
  altri siti, rete solo nel container), 0011 realizzato dallo storico eToro (con il blocco
  della perdita giornaliera fino a mezzanotte e la verifica per conto), 0012 viste
  pubblicate, tick condiviso e lucchetto del ciclo di vita, 0013 interfaccia in stile
  Mimante, 0014 ciclo di apprendimento in background con un solo scrittore; 0005, 0006,
  0007 e 0008 segnati come superati in parte.
- QUESTIONS: D-38…D-58 con i default applicati, in attesa di conferma del proprietario
  (D-53 stato per conto, D-54…D-58 dalla revisione); D-31 superata, note su D-23, D-32, D-33.
- README, CLAUDE.md, RUNBOOK, DOCKER e guida Unraid: solo la password nel container,
  conto, chiavi e Telegram da Impostazioni, aggiornamento da un container 5.0 passo per
  passo (variabili tenute al primo avvio e poi tolte, ENCELADO_WEB_TOKEN rinominata con lo
  stesso valore, segreti bloccati con una password diversa), comandi senza preset né
  --confirm-live, F5 e run-dev su localhost, reverse proxy.
- ARCHITECTURE, GLOSSARY, LEDGER_SCHEMA (righe correzione, verifica per conto, preset
  d'ingresso, una posizione una riga, stato per conto con i campi nuovi, data/models),
  DATA_SOURCES, RISK_RULES, STRATEGY, ML_AND_LEARNING, UI_GUIDELINES riallineati al codice;
  API: quotazioni nullable e risposte dopo un riavvio fallito.
- KNOWN_ISSUES: tolti i limiti chiusi, aggiunti quelli trovati dalla revisione (gamba
  aperta e chiusa fra due riconciliazioni, kill-switch interni, heartbeat durante comandi
  lunghi, costPips del modello vivo, messaggi Telegram passati con i proceeds, Actions
  senza runner).
- Skill di progetto aggiornate (diagnosi sui file per conto, interfaccia 5.1, verifica).
- CHANGELOG 5.1.0 (richieste, correzioni della revisione, cosa fare all'aggiornamento) e
  STATE (prossimi passi: push, immagine e release 5.1.0, aggiornamento su Unraid, conferma
  delle domande, prova sul conto demo).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 17:18:55 +02:00
Alby96andClaude Opus 5.5 54504ab9fe 5.1 revisione, apprendimento: contributi che spiegano la p mostrata, ritiro dei modelli tutto o niente, sessione e conteggio dal ledger corretto, pagina a motore fermo che segue le correzioni e tiene l'ultima lettura buona, nessun braccio mai provato segnato come migliore
- La p di un basket viaggia con ciò che l'ha prodotta: a ogni chiusura di barra il motore prende
  insieme p, contributi e intercetta dello stesso modello, e li salva con l'ingresso anche in
  learning_state.json. La pagina non spiega più una p con un modello che non l'ha data; un basket
  aperto riprende dopo un riavvio la p d'ingresso con i suoi contributi (tick, pagina, righe nuove
  del ledger). A motore fermo un basket piatto mostra la p della riga solo se il modello salvato la
  ridà, altrimenti quella ricalcolata, detta «ricalcolata con il modello di oggi». Campo nuovo
  baskets[].intercept in /api/learning.
- Il ritiro dei modelli addestrati sui proceeds sposta prima i file e solo dopo sostituisce i
  modelli: un errore lascia tutto com'era, e una riga del registro che non si scrive non fa più
  ripetere il ritiro sopra le ricompense imparate dopo. Anche la riga di disattivazione in Observe
  non fa più saltare il salvataggio.
- Dopo la verifica del realizzato all'avvio il motore rilegge dal ledger corretto gli esiti di
  lastNOutcomes e il conteggio, anche se il ritiro fallisce: le righe di valutazione della sessione
  non portano più un lastNOutcomes calcolato dalle etichette sbagliate.
- I basket etichettati del tick sono contati come li conta il dataset (con le feature d'ingresso):
  all'avvio, dopo la verifica, a ogni ciclo e a ogni chiusura con l'ingresso ricordato.
- Il dataset della pagina si ricalcola appena il ledger riceve una correzione pnl_realizzato o la
  marca feature_inaffidabile (lette in modo incrementale), non più fino a un'ora dopo.
- A motore fermo un file dei modelli illeggibile lascia l'ultima lettura buona di quella parte
  (bandit, stato, MLP, ultimo ciclo), come l'avviso già diceva; senza una lettura buona l'avviso
  dice che sono mostrati i valori iniziali.
- Un braccio del bandit mai provato non è mai il migliore del contesto: un'installazione nuova non
  mostra bracci dorati.
- Pagina Basket: le feature di un basket in posizione sono dette «all'ingresso».

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 16:40:18 +02:00
Alby96andClaude Opus 5.5 2d59c4e94d 5.1 revisione, segreti e web: un file 5.0 Live+demo resta sul conto demo, password errate pagate anche via Bearer e cookie, richieste da altri siti rifiutate, --sample senza file né segreti dell'operatore, rete solo nel container
- Quando etoro.environment esce dal file (salvataggio dalle Impostazioni o importazione) viene scritta la modalità che il file intendeva: un Live (o LiveAuto/LiveApprove) accanto a "demo" era letto Demo ma diventava Live al primo salvataggio qualsiasi, scavalcando la guardia del cambio di conto, il controllo delle chiavi e la frase. La verifica sulla copia usa esattamente ciò che verrà scritto, letto con l'overlay vero.
- Una password errata via Bearer o cookie (derivato dalla password, quindi anch'esso un tentativo) costa come al login, con un'attesa per indirizzo condivisa da tutte le porte d'ingresso: 1, 2, 4... fino a 30 s. Nel frattempo nessuna password di quell'indirizzo viene controllata (429), così i tentativi in parallelo non servono più; gli altri indirizzi non aspettano.
- Sotto /api/ POST e DELETE solo con Content-Type application/json (415 altrimenti); 403 per Sec-Fetch-Site di un'altra origine o per un Origin estraneo (login e logout solo l'Origin); senza password 403 a ogni Host diverso da localhost, contro il DNS rebinding.
- --sample lavora in cartelle temporanee cancellate all'uscita: non legge né scrive configurazione, segreti e dati dell'operatore e non apre il suo bot Telegram (un secondo poller rubava i comandi); le Impostazioni mostrano i valori di fabbrica e ogni scrittura risponde 400.
- Il server ascolta sulla rete solo nel container o con --listen-all: F5 e run-dev tengono la password per i segreti della sandbox ma restano su localhost.
- Il tick porta statusLines (righe della striscia di attività, 20-2000): il valore veniva salvato e mai letto. Non è più legato a bufferedLines.
- L'importazione segue l'ordine della 5.0: chiavi dell'ambiente, poi quelle del file, poi etoro.keys.enc.
- Un numero di iterazioni PBKDF2 fuori da 100 000-10 000 000 nell'intestazione di secrets.enc è un file danneggiato, bloccato senza derivare la chiave (prima: minuti di avvio fermo).
- /api/learning: strategy.json entra nell'impronta dell'ETag e ogni salvataggio di un campo strategy: fa avanzare la versione, così a motore fermo la pagina non resta sui vecchi interruttori.
- run-docker non stampa più la password: dice da dove viene.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 15:59:15 +02:00
Alby96andClaude Opus 5.5 7e3ace4ae7 5.1 revisione, soldi: perdita giornaliera bloccata fino alle 00:00 UTC, ogni posizione registrata una volta sola, verifica del realizzato per conto, preset d'ingresso nella riga e nel bandit, scelta esplicita sulle posizioni esterne nel kill-switch
La revisione ha trovato che il blocco della perdita giornaliera cadeva appena l'equity risaliva sopra la soglia (motore e backtest) mentre interfaccia e ledger promettevano «fino a domani»; che una chiusura vista da due percorsi (residuo del kill-switch, uscita del basket, riconciliazione, orfana richiusa da una lista vecchia) finiva due volte in baskets.csv e raddoppiava il P&L nei riepiloghi; che la verifica del realizzato 4.0-5.0 usava una soglia unica per i due conti e lasciava per sempre le righe Live con i proceeds come P&L, insegnati ai modelli; che il kill-switch chiudeva le posizioni esterne anche quando l'operatore aveva lasciato spenta la casella del dialogo.

- Perdita giornaliera (D-52): raggiunta una volta, niente nuove entrate né aggiunte fino alle 00:00 UTC anche se l'equity recupera, nel motore e nel backtest (stessa regola, DailyLossLatch e ReplayDailyLoss). Si giudica a ogni lettura del conto e a ogni decisione; il giorno del blocco è nello stato del conto (dailyLossDay) e sopravvive al riavvio. Un calo del saldo che lo storico eToro non spiega ancora (forse un prelievo) sospende subito le entrate ma blocca la giornata solo quando risulta una perdita. Campo dailyLossLatched nel tick; testi di Telegram, decisore, log e impostazioni: «fino alle 00:00 UTC»; il caso del saldo da chiarire ha il suo testo in dashboard, avvisi, Telegram e console.
- Una posizione, una riga: una chiusura già in baskets.csv (marcatore «posizioni:») o in attesa dello storico non viene registrata di nuovo da nessun percorso. Le gambe di un basket rimaste nel residuo del kill-switch diventano una riga sola, come basket (exit kill_switch), quando tutte sono chiuse; il residuo che il conto non mostra più esce dall'elenco alla riconciliazione; un'orfana chiusa esce subito dalla classificazione e il kill-switch o l'equity stop non la richiudono.
- Verifica del realizzato: una soglia per conto (mode nella nota verifica_realizzato; le note senza conto non contano, la verifica è idempotente); LiveAuto e LiveApprove della 4.0 contano come Live.
- Gambe singole 4.0-5.0: la nota si abbina solo a righe con lo stesso basket_id, una nota per riga, righe e note in ordine di tempo; un abbinamento ambiguo lascia la riga non verificabile invece di indovinare.
- Origini delle posizioni: la riga di un'aggiunta richiusa non trasforma più le gambe del suo basket in orfane (Storico, P&L oggi).
- Storico: la cache serve solo richieste che partono dopo quanto ha letto («anno» e «tutto» non escono più calcolati su 90 giorni).
- Preset d'ingresso: salvato nel basket, nell'ingresso in sospeso e nello stato; la riga di baskets.csv (anche closed_by_broker) e la ricompensa del bandit nominano il preset con cui il basket è entrato, non quello in vigore alla chiusura.
- Kill-switch: foreign esplicito di POST /api/commands/kill vince su risk.closeForeignOnKill (false le lascia, true le chiude; senza il campo vale l'impostazione, come per Telegram /kill e il file STOP; altro valore 400). Campo closeForeignOnKill nel tick, da cui parte la casella del dialogo; la console chiede solo se ci sono posizioni esterne e propone l'impostazione come risposta. La nota kill_switch_avviato dice chi ha deciso.
- docs/API.md: i campi nuovi del tick e le regole di kill e residue.
- Test: 34 nuovi (blocco attraverso recupero, riavvio e mezzanotte, anche nel backtest; calo del saldo non spiegato e testi di Telegram; i tre percorsi della doppia registrazione; soglia per conto; abbinamento delle note; origini; cache dello storico; preset nella riga e nel bandit; scelta esplicita nel motore e sul web). Ognuno fallisce con la sua correzione tolta.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 15:11:14 +02:00
Alby96andClaude Opus 5.5 28db7706b0 Ledger: la rotazione mensile delle decisioni va solo in avanti e non sovrascrive mai un file già ruotato
Al cambio di mese una riga di decisione porta l'ora della barra (il mese vecchio) mentre eventi e
correzioni portano l'ora attuale (il mese nuovo): l'ultima barra del mese valutata dopo la mezzanotte
faceva ruotare il file all'indietro, e alla riga successiva lo spostamento falliva sul file già
esistente, perdendo la riga. Ora una riga tardiva del mese precedente resta nel file corrente (ogni
riga ha la sua ora) e un file ruotato con lo stesso nome prende il primo nome libero (_02), che si
ordina subito dopo. Il test che il cambio di mese di oggi aveva rotto legge tutti i file delle
decisioni; due test nuovi coprono la riga tardiva e il file già esistente.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 14:20:23 +02:00
Alby96andClaude Opus 5.5 c618f9fc01 5.1 revisione, conti: stato separato per conto e cambio Demo↔Live deciso dal motore, saldo all'avvio giudicato solo con lo storico completo
La revisione ha trovato che la guardia del cambio di conto leggeva la vista pubblicata (piatta a metà di un ingresso e durante l'avvio), che il file di stato unico veniva riscritto dal motore dell'altro conto (perdendo chiusure in attesa del P&L, equity stop, kill-switch, residuo, pausa e picco) e che all'avvio una perdita non ancora nello storico eToro veniva registrata come prelievo.

- Stato per conto (D-53): data/state/baskets_state.demo.json e baskets_state.live.json. Il cambio non sovrascrive né scarta basket, ingressi in attesa, chiusure in attesa del P&L, picco, flussi di cassa, blocchi, residuo, pausa e giornata della perdita giornaliera dell'altro conto: tornando lo si ritrova com'era. Il file unico della 5.0/5.1 va una volta sola al conto scritto nel suo mode (il più recente vince) e resta come .migrato; niente viene cancellato. I basket di un conto non seguito oltre la soglia ricevono il recupero dopo inattività.
- Registro degli ordini: pending_orders.json resta unico, ma ogni motore vede, risolve, fa fallire e pota solo gli ordini del suo conto.
- Guardia C8 autorevole: a motore acceso è un comando sul thread di decisione che prima blocca nuove entrate e aggiunte, poi conta sui propri slot (posizioni, gambe in attesa, ingressi/aggiunte/uscite in corso, errori con una gamba, ordini senza esito, orfane e residui, chiusure in attesa dello storico); le entrate restano bloccate fino al riavvio, il blocco si toglie se il cambio non avviene. Rifiutato mentre il motore si avvia o si ferma o se non risponde in 30 s. Dopo l'arresto il file del conto lasciato dal motore viene ricontrollato: se non è piatto (o parte un kill-switch nel frattempo) encelado.json e strategy.json tornano byte per byte come prima e il motore resta fermo. A motore fermo decide il file del conto in uso. Il messaggio dice cosa resta e cosa fare.
- Saldo all'avvio: si giudica solo quando lo storico mostra ogni posizione chiusa dopo l'ultimo saldo (sparite dal conto, sparite senza verdetto, chiusure in attesa); altrimenti il saldo salvato resta il riferimento e giudica la riconciliazione che le vede, come in sessione. In sessione le posizioni che spiegano il saldo si dimenticano solo dopo un verdetto su una lettura riuscita del conto.
- Test: cambio rifiutato con un ingresso in corso che la vista mostra piatto, con chiusure in attesa (motore acceso e fermo), durante l'avvio e il riscaldamento, senza risposta del motore; annullamento dopo l'arresto e con un kill-switch partito nel frattempo; Live→Demo→Live che conserva equity stop, kill-switch, residuo, pausa e picco; chiusure in attesa scritte quando il conto torna; migrazione del file unico; registro per conto; avvio con storico in ritardo senza prelievo e con prelievo vero ancora giudicato.
- docs/API.md: i motivi del rifiuto del cambio di conto e l'annullamento dopo l'arresto.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 23:55:07 +02:00
Alby96andClaude Opus 5.5 b80638d949 5.1: interfaccia corretta dopo la revisione: kill-switch che fa quello che l'operatore sceglie, impostazioni salvabili dopo due modifiche, stati dei basket spenti non più nascosti, parole del ledger in italiano
- Kill-switch: la casella «chiudi anche le esterne» parte come l'impostazione (tick.closeForeignOnKill), con una riga che lo dice, e il dialogo manda sempre foreign esplicito: la scelta fatta lì è quella che succede. Nelle conferme distruttive il fuoco parte su «Annulla», così un Invio tenuto premuto non esegue un kill-switch o una chiusura.
- Impostazioni: una modifica si giudica contro il valore che il server ha adesso, non contro quello di quando la pagina è stata costruita; dopo due salvataggi tornare al valore di prima si vede come modifica e si può salvare.
- Basket: vale la parola del server; un basket spento in Attesa B, Errore o Uscita lo dice ed è attenuato solo quando è spento e senza niente sul conto.
- Storico e Mercato: un filtro ricordato resta visibile e annullabile (opzioni ricostruite al primo tick, strumenti dai basket anche a motore fermo, un chip per ogni valuta ricordata).
- Mercato: bid, ask, spread ed età degli strumenti dei basket seguono il tick ogni secondo, l'età delle coppie di conversione cresce con l'orologio. Dashboard e Apprendimento mostrano «—» per una quotazione mai arrivata e per i terzili sconosciuti, non 0.
- Contratto condiviso: righe del registro in dashboard da tick.statusLines, perdita giornaliera bloccata fino alle 00:00 UTC (dailyLossLatched) su tessera, allarme e pallino, heartbeat giudicato sul suo intervallo (heartbeatSeconds, soglia di /api/health), Content-Type: application/json su ogni POST e DELETE anche senza corpo.
- labels.js: evento del ledger, codici di motivo, motivi d'uscita, stati degli ordini, vincolo della size e sorgenti del log in italiano (Basket, Storico, Log, Apprendimento, Posizioni), il codice resta nel tooltip. Icona «list» per il registro dei modelli e nessuna X al posto di un'icona sconosciuta.
- UI_GUIDELINES: le regole nuove (casella del kill-switch, fuoco, labels.js, statusLines, Content-Type, controllo dei moduli con node --check su copie .mjs).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 23:17:22 +02:00
Alby96andClaude Opus 5.5 07a00cd91c 5.1 revisione, ciclo di vita del motore: un solo lucchetto per avvio, arresto e riavvii, nessun comando senza risposta, chiusura all'arresto sul thread di decisione
FERMA arrivato mentre AVVIA (o un riavvio automatico delle impostazioni) costruiva il motore dichiarava il bot fermo e lasciava un motore che operava senza che kill-switch, FERMA e comandi lo raggiungessero. Ora il supervisore ha un unico lucchetto del ciclo di vita che serializza avvio, arresto, riavvio automatico, rilascio di un motore in errore e ciclo di apprendimento a motore fermo; ogni avvio ha un numero di generazione e un arresto pulisce solo il motore che ha fermato; lo stato resta «stopping» finché il motore vecchio non ha lasciato instance.lock, così AVVIA subito dopo FERMA aspetta invece di fallire con «un'altra istanza». Un motore il cui ciclo finisce senza che nessuno l'abbia fermato è un errore, non un arresto silenzioso.

Il riavvio automatico passa dallo stesso lucchetto, rilegge lo stato e riavvia solo un motore ancora acceso: FERMA arrivato durante un salvataggio o durante la verifica delle chiavi non viene più annullato. Un kill-switch, una chiusura o la chiusura dei residui in corso non vengono mai tagliati a metà: FERMA e i salvataggi che riavvierebbero il motore rispondono 409 prima di scrivere; solo l'arresto del processo li interrompe, dopo 30 s, e un kill-switch interrotto registra il residuo (Halted-Residuo) invece di un blocco pulito.

Ogni comando riceve risposta: quelli in coda o interrotti quando il motore si ferma (anche quando l'avvio fallisce) rispondono subito «comando interrotto: il motore si è fermato» e finiscono nel ledger; un'attesa scaduta risponde 504 con un messaggio esplicito, mai 500. Con closeOnShutdown la chiusura all'arresto è un comando eseguito dal motore sul suo thread di decisione (blocca nuove entrate e aggiunte, chiude entro 30 s, poi il ciclo viene annullato): nessun metodo del motore è più chiamato da un altro thread e una chiusura oltre il tempo non lascia più il supervisore bloccato in «stopping» con il motore che continua a operare. Lo stato si scrive con un file temporaneo unico.

«Esegui ciclo» risponde 409 finché il ciclo di decisione non è partito. SnapshotHub non tiene più un iscritto quando il primo tick fallisce (e un file del modello non leggibile per permessi non fa più fallire ogni tick). Il motore pubblica l'intervallo dell'heartbeat, che si cambia a caldo fino a 600 s: campo heartbeatSeconds nel tick, in /api/system e in /api/health, e il controllo di salute usa 3 × intervallo + 15 s invece dei 105 s fissi. docs/API.md aggiornato.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 23:11:29 +02:00
Alby96andClaude Opus 5.5 fef00c5cd7 5.1: nuova interfaccia web in stile Mimante, integrata con il server e verificata sui dati veri del server campione
L'interfaccia della 5.0 (un app.js e un app.css Material 3) lascia il posto a quella della 5.1:
moduli ES statici in wwwroot/js e wwwroot/js/pages, fogli di stile in wwwroot/css (token, componenti,
una pagina per file), nove pagine (Dashboard, Basket, Posizioni, Mercato, Storico, Apprendimento, Log,
Sistema, Impostazioni) e la pagina di accesso. Risponde alle richieste del proprietario: dashboard che
riassume tutto in una schermata, layout fluido senza fascia grigia a destra, controlli allineati, stato
del motore nella barra in alto con i simboli (niente scritte in fondo al menu), niente selettore della
valuta nella barra, orologi con le bandiere, log su una riga con il livello colorato, pagina
Apprendimento, pagina leggera (circa 64 ms di lavoro ogni 10 s sulla dashboard, heap 2 MB).

Verifica contro il server vero (--sample e motore fermo senza chiavi), campo per campo con docs/API.md:
- lo stato del collegamento eToro è "connesso"/"errore"/"fermo", non "ok": colori corretti in Sistema;
- l'errore di accesso ha la classe login-error che il server scrive (il CSS stilizzava form-error);
- un numero con allowEmpty lasciato vuoto torna "dal preset" invece di essere rifiutato;
- l'etichetta del prossimo evento porta l'ora UTC: ora è mostrata nel fuso del browser con il conto
  alla rovescia, come nel resto della pagina;
- le celle delle azioni di riga erano display:flex e smettevano di essere celle: la colonna perdeva
  la larghezza e il bottone finiva all'estremo destro delle tabelle larghe;
- l'icona della pill d'allarme non aveva dimensione (sotto 560 px restava una pill vuota);
- le unità lunghe in Impostazioni coprivano il valore: ora stanno accanto all'etichetta;
- la barra del Log andava su tre righe per il percorso del file: ora mostra il nome, il percorso nel tooltip;
- Posizioni cede Margine e Aperta prima di scorrere a 1024 px; il mercato vuoto e i riquadri senza dati
  dell'apprendimento non sono più rossi né muti;
- avviso "SENZA CHIAVI" al primo avvio, quando il deposito dei segreti è vuoto e il motore non può partire;
- dopo un riavvio del server le righe del log ripartono da 1: la pagina se ne accorge e le ricarica
  invece di ignorarle fino al refresh.

Test: EmbeddedUiTests riscritti per la nuova struttura (XHTML ben formato, ogni file citato da
index.html incorporato, ogni import statico risolto con i nomi esportati, nessun altro host, token con
i due temi, stream e CONFERMO LIVE, login con il campo password senza script); WebHostTests servono ogni
file con il suo tipo e controllano l'errore al posto del segnaposto. 416 test verdi, 0 avvisi.

Screenshot: scripts/screenshots.ps1 e .sh fotografano le undici pagine più il tema chiaro; la foto da
telefono passa dal protocollo DevTools (Edge per desktop non stringe la finestra sotto 500 px).
docs/img rigenerata, README aggiornato alle nuove immagini, docs/UI_GUIDELINES.md riscritto per la 5.1,
docs/API.md completato (forma di positions[] dei comandi, etichetta dell'evento, file dell'interfaccia).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 15:45:27 +02:00
Alby96andClaude Opus 5.5 50eb330fbc 5.1: pagina Apprendimento (/api/learning), ciclo di apprendimento in background con un solo scrittore dei file, correzioni dell'apprendimento
Perché: il proprietario vuole una pagina con tutto ciò che l'apprendimento sa e ha
imparato. Fino alla 5.0 il ciclo calcolava AUC con intervallo, Brier, calibrazione,
P&L filtrato, Sharpe e DSR e ne teneva una riga di testo; «Esegui ciclo» con il bot
acceso creava un secondo scrittore dei file dei modelli (aggiornamenti persi, JSON
scritti a metà che alla lettura azzeravano tutto, versioni duplicate, il motore che
non ricaricava mai il modello); il ciclo settimanale addestrava sul thread di
decisione con il lock dell'apprendimento preso, fermando quotazioni e uscite; la
seconda valutazione prima dell'invio ignorava learning.enabled (ADR-0006 aggirabile);
l'AUC mobile usava la p ricalcolata alla chiusura; il previsore di volatilità accodava
una previsione a ogni lettura delle quotazioni (coda senza limite, confronti su
previsioni vecchie di ore, e dopo 20 000 barre avrebbe smesso di accodare); le note
d'ingresso senza feature diventavano righe di addestramento inventate; un motore
rifiutato dal lock di istanza salvava comunque i file dell'apprendimento.

Cosa cambia:
- Core: i record del rapporto (LearningReport e parti, forma di docs/API.md) e le
  letture pure dei modelli: OnlineLogistic.Summarize/Explain (pesi per |w|, contributi
  w·z che sommati all'intercetta danno il logit), RollingStandardizer.Stats,
  SmallMlp.Summarize, ThompsonBandit.Arms/Explorations/Summarize (intervallo di
  credibilità dai quantili della Beta, nuovo BetaDistribution), VolForecaster con al
  più una previsione in coda per barra (numeri di barra assoluti oltre il tetto della
  storia). RollingMetrics, DatasetStats (con le etichette sospette dei proceeds),
  ActivationRules, LearningSchedule, MlGate, CycleTrainer, LearningKnowledge (insight
  con l'anno della settimana ISO), LearningJson (API e last_cycle.json).
  ModelEvaluator annullabile fra fold, semi, epoche e con le p all'ingresso del
  walk-forward.
- Engine: il ciclo è una funzione pura in background (LearningCycle, CycleRunner) che
  legge solo il ledger (LearningDataset: righe in condivisione con FileShare.Delete,
  filtro ordinale, cache per file); LearningState.Apply lo applica sul thread di
  decisione in millisecondi (modelli sostituiti, basket chiusi nel frattempo rigiocati,
  versione, file interi con .tmp unico, last_cycle.json con valutazione e dataset, AUC
  mobile ripartita dalle p all'ingresso del walk-forward). Il settimanale usa lo stesso
  percorso. Il thread di decisione pubblica un LearningLiveReport immutabile (chiusura
  di barra e di basket, ciclo, comandi, avvio, ogni minuto); IEngine.Learning,
  BotSupervisor.LearningLive; il tick prende da lì i suoi numeri.
- «Esegui ciclo»: motore acceso → comando Learn con risposta immediata; motore fermo o
  in errore → manutenzione che prende il lock di istanza, con AVVIA rifiutato (409
  refused) finché dura; rifiutato con un ciclo già in corso o il lock di un altro
  processo. backtest learn prende il lock o si rifiuta. Un motore in errore viene
  rilasciato (lock compreso) prima di un nuovo avvio o di una manutenzione.
- LearningDiskReader: la pagina a motore fermo dai file, in sola lettura (niente Ledger
  né LearningState costruiti, nessuna cartella creata, righe a metà scartate, cache per
  impronta dei file, un aggiornamento alla volta), più la base di conoscenza in ogni
  stato. GET /api/learning (features=all, ETag = versione + impronta, 304); /api/research
  tolto.
- Correzioni: cancello ML con learning.enabled anche nella seconda valutazione e nello
  snapshot; challenger addestrato e aggiornato solo con enabled e challenger; p
  all'ingresso salvata con le feature e l'ingresso salvato subito; le chiusure del
  broker insegnano (o dimenticano l'ingresso se restano una stima); le note d'ingresso
  portano il vettore della decisione e senza feature non sono righe di addestramento;
  LearningState costruito dopo il lock e salvato sotto il suo lock solo se il lock era
  preso; ultima proposta del bandit e AUC nel tempo persistite; learning_state.json
  schema 2 (legge quello della 5.0).
- --sample: un rapporto d'esempio ricco e coerente con il tick e lo Storico (i quaranta
  basket d'esempio come dataset, logistica e bandit veri su dati finti).
- docs/ML_AND_LEARNING.md riallineato al codice (feature, tasso, finestre HAR,
  dimensioni della calibrazione, uscite dello strumento) con la pagina e il ciclo;
  docs/API.md: refused → 409 e il comando learn precisati.
- 37 test nuovi (411 in tutto).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 14:52:34 +02:00
Alby96andClaude Opus 5.5 58d5ea73a8 5.1: il motore pubblica viste immutabili, un tick al secondo condiviso da tutti i client, sezioni a richiesta con ETag, feed in background, dati d'esempio per ogni rotta
Perché: fino alla 5.0 ogni connessione SSE ricostruiva e serializzava lo snapshot
intero ogni secondo (N schede, N costruzioni da 35-45 KB, con 200 righe di log in
ogni frame) leggendo dal thread web lo stato che il thread di decisione modifica,
senza sincronizzazione (righe strappate, "Collection was modified" all'avvio), con
effetti collaterali (VolForecaster.Describe accodava previsioni e cambiava il modello
in uso) e prendendo a ogni costruzione i lock del motore. Il ciclo di decisione
aspettava il download di tredici feed; la latenza API includeva le attese del
limitatore; a motore fermo mancavano Telegram, segreti e contesto; i file statici
erano sette rotte scritte a mano, senza ETag.

Cosa cambia:
- Il thread di decisione pubblica un EngineView immutabile (Volatile.Write) dopo ogni
  iterazione, lettura delle quotazioni, transizione, comando e riconciliazione: per
  basket valutazione, decisione (codici, costi, sizing), contesto, feature del
  meta-modello, volatilità, posizione con le gambe e i numeri del conto, ingresso in
  attesa, le ultime 20 decisioni di chiusura barra; quotazioni con mediana 24 h e ATR,
  cambi con la coppia d'origine, posizioni classificate, registro ordini, quote HTTP,
  allarmi, conto e giornata. Web, console e Telegram leggono solo quello:
  BotSupervisor.Snapshot adatta la vista, VolForecaster.Stats/Describe sono puri, lo
  snapshot a motore fermo rilegge strategy.json solo quando cambia.
- SnapshotHub: il tick v2 di docs/API.md, costruito una volta al secondo per tutti i
  client e mai senza client; un canale di un frame per client che tiene il più recente
  (un client lento non rallenta gli altri); primo frame subito, retry: 3000;
  /api/snapshot risponde con lo stesso tick. Nel tick solo le righe di log nuove (seq,
  al più 100, su una riga) e le versioni delle sezioni.
- Nuove rotte: /api/positions, /api/market, /api/baskets/detail, /api/system (assorbe
  /api/info, che resta come alias), /api/log con seq, timeUtc e sorgente (gli a capo
  diventano " ⏎ "), /api/health leggero (nessuno snapshot, prova del disco al più una
  volta al minuto). Ogni sezione ha ETag e risponde 304 se non è cambiata.
- EtoroHttp misura il solo viaggio HTTP (ultima latenza e media del minuto), conta i 429
  per classe di quota e tiene l'ultimo errore; i feed tengono per sorgente ultimo
  successo, errore, backoff e verdetto di robots.txt.
- Calendario e notizie si scaricano in background (ContextRefresher), mai dentro il
  ciclo; il provider appartiene al processo, pubblica un ContextView immutabile e resta
  aggiornato anche a motore fermo.
- File statici: ogni file incorporato sotto wwwroot/ è servito al suo percorso con il
  tipo, l'ETag e il 304; i nomi delle risorse usano "/" anche per le sottocartelle
  compilate su Windows.
- --sample: dati d'esempio realistici e coerenti per ogni rotta (tick che cambia ogni
  secondo, righe di log che arrivano, posizioni delle tre origini, calendario con il
  blackout, notizie, sentiment, dettaglio dei cinque basket, sistema, storico).
- 41 test nuovi (374 in tutto): hub, forma del tick e di ogni sezione, ETag e 304, rotte
  libere senza sessione, log, health senza motore, feed che non bloccano il ciclo,
  coerenza dei dati d'esempio. docs/API.md precisato dove il contratto era vago.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 13:49:32 +02:00
Alby96andClaude Opus 5.5 9875ab64eb 5.1: impostazioni tutte dall'interfaccia e applicate dal bot in esecuzione, segreti cifrati con la password, niente Paper, conto legato alla modalità
Perché: il proprietario vuole che il container abbia una sola variabile (la
password dell'interfaccia) e che ogni impostazione si faccia dalla pagina web e
valga subito. Fino alla 5.0 un salvataggio scriveva solo il file (il motore lo
leggeva al riavvio del container), le variabili d'ambiente sovrascrivevano a ogni
avvio le scelte fatte nell'interfaccia, e modalità e conto erano due impostazioni
separate: Demo + real mandava ordini al conto reale senza il cancello del Live.

Cosa cambia:
- Paper rimosso ovunque (enum, PaperBroker, paperStartingBalance/paperSlippagePips,
  catalogo): un file con "Paper" si legge come Demo con un avviso. Le righe storiche
  del ledger con mode=Paper restano come sono.
- Modalità e conto fusi: run.executionMode Demo | Live sceglie anche il conto;
  etoro.environment esce dal file (regola di fusione per i file della 5.0: Live solo
  se Live e real, altrimenti Demo con un avviso) e sparisce al primo salvataggio.
- Cancello del Live: interruttore allowLive più la frase CONFERMO LIVE scritta
  nell'interfaccia (AVVIA con confirm, POST /api/settings con confirm). Niente più
  ENCELADO_CONFIRM_LIVE né --confirm-live; il Live non parte mai da solo (allarme
  liveNeedsConfirmation e avviso Telegram); BotSupervisor.StartAsync(liveConfirmed)
  senza flag appiccicoso; il cambio di conto è rifiutato con basket aperti, in
  attesa o ordini senza esito.
- Password: ENCELADO_PASSWORD (alias deprecato ENCELADO_WEB_TOKEN), campo password
  del login (token ancora accettato), cookie encelado_session = HMAC derivato dalla
  password (mai la password), POST /logout, Bearer per gli script, confronti a tempo
  costante e un secondo di attesa dopo una password errata.
- SecretStore: secrets.enc (AES-256-GCM, PBKDF2-SHA256 600 000 iterazioni, sale
  conservato, nonce nuovo a ogni scrittura, header autenticato) con le chiavi eToro
  del conto demo e del conto reale e il token Telegram; senza password una chiave
  locale in secrets.key, migrata alla password quando compare; password cambiata =
  bloccato, sblocco con la precedente o ricomincia con un .bak. I segreti non entrano
  mai nella BotConfig condivisa: motore e storico costruiscono EtoroOptions privati.
- Importazione una tantum dalla 5.0 (import-5.1.json, idempotente): chiavi e token
  nel deposito solo negli slot vuoti, il vecchio etoro.keys.enc importato e rinominato
  .migrato, impostazioni solo se diverse dal default di fabbrica e il file lo
  conserva ancora; poi ogni variabile rimasta è ignorata ed elencata nel log, in
  /api/settings e nello snapshot (ignoredEnv). Il loader non legge più l'ambiente.
- run.autostart (predefinito acceso) al posto di ENCELADO_AUTOSTART; --no-autostart
  resta per lo sviluppo.
- Preset solo in strategy.json, scelto in Impostazioni ▸ Strategia: comando preset
  tolto da motore, web e console; i basket aperti tengono zStop e aggiunte con cui
  sono entrati (salvati in BasketPosition, PendingEntry e nello stato).
- Applicazione a caldo: SettingsRuntime con un lock di scrittura, catalogo con file
  (config/strategy) e momento d'effetto (immediate/engine/restart), ConfigWriter con
  encoder rilassato e cancellazione di chiavi (e le righe _ di documentazione
  aggiornate), BotConfig.CopyFrom, comando ApplySettings sul thread di decisione
  (CopyFrom/SameStructure della strategia, BasketDecider.Reload, impronta ricalcolata
  e riga "configurazione" nel ledger), intervalli letti a ogni tick, timeout delle
  richieste per richiesta, basket spenti che continuano a gestire le uscite, pausa
  persistita nello stato, NotifierHub che accende, spegne e cambia Telegram e il
  poller dei comandi, Log.Reconfigure, LogBuffer.Resize, HistoryService.Invalidate,
  riavvio automatico del motore senza chiudere i basket per i cambi che lo
  richiedono (409 needsPhrase prima di scrivere se riparte in Live).
- API di Impostazioni e Segreti secondo docs/API.md (campi aggiunti documentati lì).
- Deploy: template Unraid con porta, /config, /data e la sola "Password
  interfaccia"; compose con la sola ENCELADO_PASSWORD (sviluppo); Dockerfile senza
  ENCELADO_AUTOSTART; launch.json e run-dev con la stessa password del compose;
  run-docker senza PUID/PGID.
- 75 test nuovi o riscritti (333 in tutto): deposito dei segreti, importazione,
  password, runtime con un motore finto, strategia a caldo, uscite dei basket
  spenti, log e notifiche, avvio automatico, scrittura della configurazione.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 12:48:31 +02:00
Alby96andClaude Opus 5.5 9cb58822b0 5.1: il realizzato viene dallo storico eToro, P&L oggi e perdita giornaliera corretti, dati 4.0-5.0 corretti con righe nuove
Perché: dalla 4.0.0 il bot registrava come P&L di ogni chiusura il campo
proceeds della risposta di chiusura eToro, che è il contante restituito
(margine liberato + profitto), non il profitto. Da qui «P&L oggi» di circa
47 000 USD su 139 000 di equity, la regola della perdita giornaliera che non
scattava mai dopo la prima chiusura del giorno, righe di baskets.csv con
etichetta quasi sempre 1 e modelli (logistica, bandit, lastNOutcomes)
addestrati su quelle etichette.

Cosa cambia:
- CloseOutcome non porta più un P&L inventato: RealizedPnl è NaN per eToro,
  proceeds e conversionRate restano solo come diagnostica e per la stima;
  GetClosedTradesAsync lancia un errore invece di restituire una lista vuota;
  ClosedTrade.NetUsd = netProfit − fees; i simulatori seguono lo stesso
  significato (niente fee sottratte due volte).
- L'esecutore non legge mai NaN come 0, non trascina il prezzo di uscita a
  zero per una chiusura vista solo sulla lista delle posizioni, restituisce
  la chiusura delle gambe richiuse (leg_risk_unwind) e le righe di chiusura
  di orders.jsonl portano il position_id.
- Il motore regola ogni chiusura con una coda persistente (pendingSettlements
  al posto di todayRealized): la riga di baskets.csv si scrive con
  netProfit − fees dello storico eToro, oppure con la stima marcata
  «P&L: stima» dopo 30 minuti, che non insegna niente ai modelli.
- «P&L oggi» si ricalcola dallo storico (posizioni del bot chiuse nel giorno
  UTC, stessa classificazione della scheda Storico) più le stime provvisorie;
  sconosciuto finché lo storico non è stato letto. Nuovi campi nello
  snapshot: todayPnlProvisional, todayEquityChange, dayStartEquity,
  todayClosed, dailyLossUsedPct, dailyLossHit.
- La perdita giornaliera è il calo dell'equity netta (cassa esclusa) dalla
  mezzanotte UTC, con la stessa funzione del backtest (DailyLoss.IsHit); una
  chiusura non ancora spiegata dallo storico non viene giudicata movimento
  di cassa.
- I dati sbagliati non vengono toccati: all'avvio (Demo/Live) una verifica
  idempotente cerca il realizzato vero per position id e scrive righe
  correzione pnl_realizzato; un lettore corretto le applica; lastNOutcomes è
  mascherata a 0,5 prima della correzione; i modelli addestrati sulle
  etichette sbagliate vengono messi da parte in models/ritirati, la
  logistica rifatta sulle etichette corrette e il bandit riparte dal prior.
- Telegram, console e log mostrano «—» per un valore sconosciuto, mai NaN;
  il kill-switch somma solo i risultati noti e separa bot ed esterne.
- Lo stato salvato non viene più sovrascritto da un avvio fallito prima
  di averlo letto.
- Documenti: DATA_SOURCES (rotte di chiusura, significato di proceeds,
  storico per positionId con minDate sulla chiusura), LEDGER_SCHEMA
  (correzioni, eventi realizzato e verifica_realizzato, pendingSettlements),
  RISK_RULES (formula della perdita giornaliera). 48 test nuovi.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 11:49:42 +02:00
Alby96andClaude Fable 5.1 02acd6059b Stato e cronologia dopo il rilascio 5.0.0
La 5.0.0 è sul registro e nelle release di Gitea; i documenti dicono cosa manca
perché i workflow girino (runner e segreto) e qual è il passo successivo
(installazione su Unraid e test sul conto demo).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 14:22:54 +02:00
Alby96andClaude Fable 5.1 e2e471f12c Workflow Gitea Actions (ci e release) e guida all'installazione su Unraid
ci.yml compila con gli avvisi come errori, esegue i test e costruisce l'immagine a
ogni push; release.yml pubblica l'immagine sul registro di Gitea e crea la release
con il template Unraid a ogni tag, in modo idempotente rispetto alla catena locale.
Sul server non c'è ancora un runner: docs/DOCKER.md spiega come registrarlo e quale
segreto serve. Il README di deploy/unraid guida passo per passo l'installazione,
compreso il registro in HTTP da dichiarare a Docker di Unraid.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 14:19:43 +02:00
Alby96andClaude Fable 5.1 e9ace47501 5.0: avvio in locale nella sandbox deploy/local, script di avvio e screenshot, arresto pulito del container verificato
Per vedere e provare il bot senza Unraid: F5 in VS Code, scripts/run-dev e
scripts/run-docker usano tutti deploy/local come /config e /data, con la stessa
disposizione del container, così chiavi e configurazione valgono in ogni modo.
ENCELADO_DATA_DIR separa i dati anche fuori dal container. scripts/screenshots
rigenera docs/img dal server campione; /api/health in --sample non finge più un
motore acceso. docker stop ora termina in un secondo con «SIGTERM: arresto»
(PosixSignalRegistration), provato sull'immagine 5.0.0 costruita dalla catena.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 13:59:56 +02:00
Alby96andClaude Fable 5.1 d7559d36a5 5.0 Fase 8: immagine Docker come pacchetto, template Unraid, catena senza Inno Setup
Il container è la sola forma di esecuzione (ADR-0008): Dockerfile multi-stage con i
test dentro la build, entrypoint con TZ e PUID/PGID, compose per le prove locali,
healthcheck via --health. Il template Unraid installa dall'immagine sul registro di
Gitea con l'icona servita dal repository (D-29). La catena di rilascio pubblica la
cartella portabile, costruisce l'immagine, tagga a pacchetto pronto e spinge
l'immagine sul registro con lo stesso token della release; l'installatore Windows
non ha più senso e viene tolto.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 13:26:12 +02:00
Alby96andClaude Fable 5.1 9c1bab5224 5.0 Fase 9: documenti, screenshot, risposte D-28/29/36/37, piano concluso
README con gli screenshot e l'avvio rapido Docker; CLAUDE.md, architettura, runbook,
problemi noti, glossario, fonti dei dati e apprendimento riscritti per il container e
l'interfaccia web; il post-mortem spiega gli accrediti del demo (uno per ordine
ridotto, dal ledger ricevuto); le skill seguono la catena nuova. Lo stato dice che il
piano 5.0 è completo e che il rilascio 5.0.0 resta una decisione dell'utente.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 13:24:30 +02:00
Alby96andClaude Fable 5.1 a69efe7df3 5.0 Fasi 6-7: motore in Encelado.Engine, server Kestrel e interfaccia web al posto di WPF
Il bot deve girare solo nel container (D-28, ADR-0007): la finestra WPF e le chiavi
DPAPI se ne vanno. Il motore diventa la libreria Encelado.Engine; l'eseguibile
Encelado.Server (nessun NuGet) serve un'API JSON scritta a mano, lo stream SSE con uno
snapshot al secondo e l'interfaccia Material 3 incorporata: dashboard con margine e
contatori, storico ordini (ordini, posizioni classificate, profitti per periodo, CSV),
log, impostazioni con chiavi cifrate (AES-GCM + passphrase), ripristino in cinque passi,
ricerca, diagnostica, valuta di visualizzazione, token locale in cookie.

Lo strumento acquista il comando learn; VS Code avvia il server con F5 e la modalità
campione; ~45 membri mai usati e i test WPF sono rimossi. Test dell'HTML incorporato,
del token e dello stream, dello storico: 210 verdi.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 13:20:59 +02:00
Alby96andClaude Fable 5.1 21fa04690a 5.0: apprendimento in ombra (ADR-0006), skill di progetto, documenti della sessione
Con il backtest negativo e zero basket chiusi nel forward test, un meta-modello
attivo e un bandit che cambia il preset da solo sono rumore: learning.enabled
= false di fabbrica lascia il ledger, la calibrazione, la previsione di
volatilità e la logistica in ombra, e spegne ciclo settimanale e challenger
finché non valgono 300 basket chiusi e un P&L forward non negativo. Le skill
in .claude/skills dicono come si comincia, si verifica, si diagnostica, si
chiude e si rilascia una sessione. CLAUDE.md, glossario e problemi noti
aggiornati alla 5.0; catena Verifica verde con 219 test.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 11:27:46 +02:00
Alby96andClaude Fable 5.1 9f040ade76 5.0 Fase 5: notifiche e comandi Telegram
Il bot riferisce al telefono: stato ogni ora, riepilogo giornaliero ed eventi
(avvio e arresto, basket aperti e chiusi, gambe in attesa, ordini risolti,
orfane, kill-switch, equity stop, perdita giornaliera, margin guard, recupero,
reset, preset, API in errore, scarto orologio) e accetta comandi dalla sola
chat autorizzata (/stato, /posizioni, /storico, /pausa, /riprendi, /chiudi,
/kill CONFERMO, /reset). Il canale è solo HttpClient: coda non bloccante, un
messaggio al secondo, retry con backoff e retry_after, long polling da un solo
task; il token vive nell'ambiente. Ogni comando eseguito, da qualunque origine,
è una riga «comando» nel ledger. Test (s)-(u).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 11:23:18 +02:00
Alby96andClaude Fable 5.1 c5f2b7d852 5.0 Fase 4: recupero dopo inattività, heartbeat e lock di istanza
Un riavvio, una sospensione del PC o un container fermo lasciavano i basket
aperti senza che nessuno applicasse le regole di uscita per il tempo perso.
Ora un heartbeat ogni 30 s misura l'inattività; oltre la soglia il bot blocca
le entrate, risolve gli ordini senza esito, riconcilia, riscalda le serie con le
barre perse e rivaluta ogni basket aperto come a una chiusura di barra
ordinaria (chiudi o tieni), chiude le orfane, riporta le esterne, scrive
reports/recupero_<run_id>.csv e riapre le entrate dopo il riscaldamento; a
mercato chiuso aspetta. Un lock tenuto in esclusiva impedisce due istanze
sulla stessa cartella dati. Sezione recovery in strategy.json. Test (r).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 11:14:06 +02:00
Alby96andClaude Fable 5.1 aaec965241 5.0 Fase 3: kill-switch che chiude davvero e ripristino in cinque passi
Il kill-switch della 4.0.0 chiudeva gli slot, non le posizioni, e «riusciva»
con venti gambe ancora sul conto. Ora annulla gli ordini senza esito e ne
attende la risoluzione, chiude basket, gambe in attesa e orfane (le esterne
solo su richiesta o con risk.closeForeignOnKill), rilegge il conto finché le
posizioni del bot non sono sparite e, se qualcosa resta, dichiara
Halted-Residuo con l'elenco invece di «tutto chiuso». Il reset è una procedura
in cinque passi (stato, file STOP, motivazione, riconciliazione con
riscaldamento e picco, ripartenza con entrate bloccate) rifiutata finché il
conto non è piatto. INotifier per le notifiche della Fase 5. Test (v)-(x).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 11:08:47 +02:00
Alby96andClaude Fable 5.1 327d3c6981 5.0 Fase 2: il margine come vincolo di primo livello del sizing
Un solo basket sizato a rischio aveva impegnato il 100 % del margine del conto
(16/9). Ora strategy.json ha la sezione risk (12 % dell'equity per basket, 40 %
in totale, disponibile con buffer del 25 %), la size è il minimo fra rischio e
margine e il ledger scrive quale vincolo ha deciso; il conto viene riletto
prima della gamba B e, se non copre, A viene richiusa; i segnali della stessa
barra vanno per |z| decrescente con rilettura del conto; sotto equity/margine
1,5 niente entrate, sotto 1,2 si chiude il basket peggiore. Il backtest applica
gli stessi limiti. Test (y), (z).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 11:01:58 +02:00
Alby96andClaude Fable 5.1 13d64d1830 5.0 Fase 1: registro persistente degli ordini, stati Pending, orfane adottate e chiuse
Un ordine dall'esito ignoto non viene più abbandonato: entra in
data/state/pending_orders.json prima della chiamata HTTP, l'esito si legge per
orderId (il server non registra il referenceId degli ordini v2) e in mancanza
si ricostruisce dalla posizione comparsa sul conto. Una gamba senza esito porta
il basket in PendingA/PendingB invece di rifiutarlo; alla risoluzione parte la
gamba B, ridimensionata sulle unità eseguite, oppure la gamba A viene richiusa.
Ogni posizione del conto è classificata basket / orfana-bot / esterna: le orfane
del bot vengono adottate e chiuse, le esterne contate e mai toccate. Il picco di
equity ignora i movimenti di cassa. Bonifica da headless, orders.jsonl, contatori
in dashboard, bandit che propone e non applica. ADR-0009, test (m)-(q).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 10:54:50 +02:00
Alby96andClaude Fable 5.1 f97f1e1fc3 Fase 0 della 5.0: piano, post-mortem degli ordini pendenti, domande D-26…D-37
Verifica della diagnosi sul codice e sul conto demo via API: il lookup per
referenceId fallisce perché il server registra un riferimento nullo per gli
ordini v2, e dal terzo ordine eToro ha ridotto ogni esecuzione a 2 000 USD di
margine. Il piano fissa l'ordine delle fasi e le decisioni vincolanti
(orderId come chiave, registro persistente degli ordini, margine come vincolo
di primo livello, picco al netto dei movimenti di cassa).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-23 10:24:54 +02:00
Alby96andClaude Fable 5.1 b8c3c75647 Registra l'esito della sessione demo di quattro ore
Perché: lo stato del lavoro deve dire cosa ha fatto il bot davvero. In quattro
ore di Demo autonomo 31 segnali sono stati rifiutati dal solo cancello di
correlazione (ρ_W mai sotto −0,6): è il primo dato da leggere nel ledger prima
di proporre un cambiamento di soglia.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-16 18:57:01 +02:00
Alby96andClaude Fable 5.1 4c26fd3209 Passa ai Correlation Baskets su eToro e rimuove i motori precedenti (4.0.0)
Perché: l'utente ha chiesto un bot che operi cinque basket di coppie forex
correlate su eToro, autonomo, con ledger, feed gratuiti e apprendimento
costruito da zero, e ha deciso di eliminare tutto ciò che restava delle
gestioni precedenti (Binance, cTrader/proba, ricerca con SQLite, GBDT, RL,
TA-Lib) e di non avere approvazioni manuali sui singoli ordini.

Cosa cambia:
- nuovo Core dei basket (cross sintetici, decisore, cost gate, sizing,
  esecutore leg-risk, backtest con PSR/DSR/PBO, livelli 0-3 di apprendimento),
  adattatore eToro Public API, motore autonomo con equity stop, kill-switch,
  riconciliazione, ledger append-only, calendario e notizie con sentiment;
- modalità Paper / Demo / Live (Live con flag e frase CONFERMO LIVE);
- interfaccia rifatta: barra in alto con tre schede, dashboard con i soli
  numeri principali, fuso orario selezionabile, test di rendering in PNG;
- corretto il parser dei costi eToro (campo "value"): markup e overnight
  non venivano letti;
- strumento di ricerca ridotto a ticks / baskets / falsify con due scenari di
  costo; risultati in results/ e reports/: nessuna configurazione è
  profittevole al netto dei costi (docs/STRATEGY.md lo dice con i numeri);
- documentazione completa (STRATEGY, ML_AND_LEARNING, RUNBOOK, GLOSSARY,
  KNOWN_ISSUES, ADR-0004, ADR-0005) e catena di rilascio aggiornata.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-16 15:45:55 +02:00
Alby96andClaude Fable 5.1 b39e08b15c Aggiunge il meta-modello, il database locale e la pipeline di ricerca della guida
Il bot ora ha un secondo parere prima di ogni ingresso: un classificatore GBDT
(scritto in C#, senza dipendenze native) addestrato sugli esiti dei segnali passati
con triple-barrier e meta-labeling, validato con CPCV, PBO e Sharpe deflazionato
contando tutte le configurazioni provate. Il modello non propone mai operazioni:
può solo rifiutarne una sotto la probabilità minima o ridurne la size, e si
sospende da solo quando le feature dal vivo derivano da quelle di addestramento.
Senza un campione promosso il bot opera come prima.

Perché tutto questo serve, e nell'ordine in cui è stato fatto:

- I log del giro reale sul testnet mostravano zero barre chiuse in tre giorni: il
  decodificatore saltava l'oggetto annidato dei kline. Corretto con test di
  regressione. Lo stesso giro restava a 1499/1500 barre di riscaldamento perché
  Binance ne serve al massimo 1500 per richiesta: il client ora pagina e il motore
  chiede quante ne servono davvero.
- Il log è diventato una tabella `;` con data, livello, sorgente, evento ed
  eccezione (grep `;ERR;` trova ogni errore), con rotazione a dimensione impostabile
  dalla finestra. Anche decisions.csv/executions.csv/trades.csv hanno intestazione
  stabile, id monotoni e colonna `motivazione`, e vengono scritti anche in SQLite.
- La configurazione vive in Documenti\Encelado (con migrazione dal file accanto
  all'eseguibile), le credenziali restano in LocalAppData, il database in
  %ProgramData%\Encelado: tre cartelle per tre ruoli diversi.
- In modalità demo gli ordini partono davvero sul testnet (dryRun spento di
  fabbrica): è l'unico modo di provare il percorso di esecuzione come in produzione.
- Lo strumento di backtest copre le fasi 0-4 della guida: qualità dei dati,
  baseline buy&hold/SMA con PSR e DSR, Engle-Granger + Johansen + Kalman con costo
  di break-even, dataset e addestramento del meta-modello, DQN su molti seed.
  Ogni tabella è CSV `;` con motivazione, e la promozione a campione avviene solo
  se il modello supera i criteri della Fase 3.

Sui dati disponibili nessuna coppia supera quei criteri, quindi nessun campione è
stato promosso: il bot resta sulla sola regola statistica, che a sua volta non
regge fuori campione. Il risultato è documentato, non nascosto.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-08 20:19:14 +02:00
Alby96andClaude Opus 5 a4e297f77a Passa a Binance Futures con arbitraggio statistico su coppie cointegrate
Il bot smette di operare direzionalmente su un singolo asset e passa a coppie
delta-neutral: long una gamba, short l'altra nel rapporto che il test di
cointegrazione produce, scommettendo solo sul fatto che la distanza fra le due
si richiuda. È questo che gli permette di girare da una connessione domestica,
perché su barre da 15 minuti la latenza smette di contare.

Cosa cambia
- Encelado.Alpaca sostituito da Encelado.Binance: REST firmato in HMAC-SHA256
  con correzione dello scarto d'orologio, uno stream combinato per kline, book
  e mark price, e lo stream ordini autenticato con listen key rinnovata.
- Nuovo livello statistico in Core: OLS, test di Dickey-Fuller aumentato con
  scelta del ritardo per AIC, ed Engle-Granger con i valori critici di MacKinnon
  per la cointegrazione.
- Il rischio ragiona per coppia: divide il controvalore fra le gambe secondo β,
  così le due si annullano invece di lasciare un residuo direzionale, e corregge
  la dimensione con il funding netto atteso.
- Interfaccia da sette pagine a quattro. I grafici a candele sono spariti: su una
  coppia coperta la candela di una gamba non dice niente, lo z-score sì.
- Ripristino dei valori predefiniti da Impostazioni, con copia datata del file
  precedente. Ripristina il documento, commenti compresi, non solo i numeri.

L'ordine che non partiva
Il segnale diceva di entrare e non succedeva niente perché il router registrava
quasi tutti i rifiuti a livello debug: alla verbosità predefinita il bot
annunciava l'ingresso, rinunciava per un motivo che nessuno poteva vedere, e
sembrava aver ignorato la propria decisione. Adesso ogni intento produce una
riga a info o warn con il nome della coppia e il motivo esatto, la frase che
l'operatore legge e la decisione che il motore prende vengono dallo stesso
stato, e una barra che lo stream non consegna viene recuperata via REST.

Che cosa dice il backtest
Il banco di prova rigioca le coppie attraverso la STESSA classe che gira in
produzione, con la calibrazione che cammina in avanti. Su 6,6 anni di ETHUSDT,
BTCUSDT, SOLUSDT e AVAXUSDT: a 5 minuti nessuna combinazione di soglie supera
i filtri di taratura; a 15 minuti e a un'ora la griglia trova combinazioni che
rendono in taratura e in verifica, ma nessuna delle prime dieci resta positiva
sulla terza fetta. La finestra dello z-score va molte volte oltre l'emivita del
rientro — le 100 barre della guida sono le peggiori misurate — e il filtro di
cointegrazione è ciò che tiene in piedi tutto: senza, ogni combinazione passa
da leggermente positiva a −73%/−87%.

Per questo dryRun parte attivo. I valori consegnati sono i meglio supportati
fra quelli provati, non una strategia dimostrata, e il file lo dice.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-28 13:01:47 +02:00
412 changed files with 73479 additions and 23642 deletions

No files matched your search

@@ -0,0 +1,16 @@
---
name: encelado-diagnose
description: Riconcilia ledger, registro degli ordini, heartbeat e posizioni del conto eToro e produce un rapporto CSV con separatore ; e colonna motivazione.
---
# Diagnosi di una sessione di Encelado
Cartella dati: `/data/data` nel container (`/mnt/user/appdata/encelado/data/data` su Unraid), `deploy/local/data/data` nella sandbox di sviluppo, `Documenti\Encelado\data` per l'installazione 4.0. Se l'utente indica un'altra cartella, usa quella. Leggi i file in sola lettura: con il bot acceso non scrivere niente nella cartella.
1. **Ledger delle decisioni** `data/ledger/decisions.jsonl` (e i mensili `decisions_YYYYMM.jsonl`, anche `_02`): conta gli `evento` (`segnale_ingresso`, `rifiuto`, `ingresso`, `pending`, `pending_risolto`, `leg_risk_unwind`, `uscita`, `orfana_adottata`, `orfana_chiusa`, `movimento_di_cassa`, `kill_switch_*` compreso `kill_switch_interrotto`, `recupero_*`, `comando`, `configurazione`, `realizzato`, `verifica_realizzato`, `correzione`). Per ogni `rifiuto` riporta `basket`, `ts`, `unitsA`, `unitsB`, `sizing_bound`, `motivazione`. Le righe `correzione` con `tipo = pnl_realizzato` danno il P&L vero delle righe della 4.0.0-5.0.0 (che erano i proceeds delle chiusure): applicale sempre prima di sommare P&L.
2. **Registro degli ordini** `data/ledger/orders.jsonl` e `data/state/pending_orders.json` (un file per i due conti: ogni ordine ha il suo `mode`): per ogni `client_ref` prendi l'ultima riga; elenca gli ordini con `esito = Pending` o `stato = Unknown` (sono le anomalie), quelli con `unita_eseguite ≠ unita_richieste` (il server ha ridotto l'ordine), gli slippage oltre 1 pip.
3. **Basket** `data/ledger/baskets.csv`, letto con le correzioni: numero, win rate, P&L netto (dalla 5.1 è `netProfit − fees` dello storico eToro; le righe «P&L: stima» e quelle non verificabili vanno contate a parte), `exit_reason` (attenzione a `orphan_closed`, `bonifica_orfana`, `leg_risk_unwind`, `margin_guard`, `kill_switch`), preset d'ingresso. Una posizione (marcatore `posizioni:` della motivazione) deve comparire una volta sola.
4. **Heartbeat** `data/state/heartbeat.json` (uno per i due conti) e **stato del conto** `data/state/baskets_state.demo.json` o `baskets_state.live.json` (quello del conto in uso; il vecchio `baskets_state.json` resta solo come `.migrato`): ultimo battito, run, basket aperti e in attesa, `pendingSettlements` (chiusure che aspettano lo storico), `haltResidue`, `cumulativeCashFlow`, `peakNetEquity`, `dailyLossDay`, `pausedByOperator`.
5. **Conto eToro** (solo via collegamento MCP dell'utente, e solo in lettura; le chiavi del bot sono cifrate in `secrets.enc` e non si leggono): posizioni aperte (`GET api/v1/trading/info/demo/pnl`), storico (`GET api/v1/trading/info/trade/demo/history?minDate=…`, P&L di record = `netProfit − fees` per `positionId`). Classifica ogni posizione come `basket` (id nello stato), `orfana-bot` (id nel registro, o strumento + verso + orario entro 90 s da una riga del ledger), `esterna`. Mai rotte che cambiano stato (ordini, chiusure).
6. Scrivi `reports/diagnosi_<data>.csv` con separatore `;`, intestazione e colonna finale `motivazione`: una riga per anomalia (`tipo;riferimento;quando;dettaglio;motivazione`) e in fondo le righe di riepilogo. Nessuna riga del ledger va modificata: le correzioni sono righe nuove.
7. Riassumi all'utente: cosa non torna, cosa è già stato gestito dal bot, cosa richiede una mano (chiusure su eToro, reset, segreti bloccati, chiusure in attesa sull'altro conto).
@@ -0,0 +1,13 @@
---
name: encelado-docs
description: Chiude una sessione di lavoro su Encelado: aggiorna STATE, CHANGELOG, ADR e QUESTIONS, poi propone il messaggio di commit.
---
# Chiusura della sessione: documenti e commit
1. `docs/STATE.md`: data, fase in corso, cosa è stato fatto in questa sessione (con i numeri: test, file, commit), prossimi passi numerati, problemi aperti, domande in attesa. È la memoria fra una sessione e l'altra: chi legge solo questo deve poter ripartire.
2. `CHANGELOG.md`: una voce in alto con la data e il titolo della sessione; punti brevi su cosa cambia e perché, non l'elenco dei file. Per un rilascio, la voce porta la versione e una parte «Da sapere» con ciò che l'operatore deve fare all'aggiornamento.
3. ADR: una scelta non ovvia = un file `docs/adr/ADR-NNNN-<slug>.md` con Contesto, Decisione, Alternative scartate, Conseguenze; un ADR superato in parte riceve lo stato aggiornato e un paragrafo «Aggiornamento». Aggiorna la mappa in `CLAUDE.md` se compare un documento nuovo.
4. `docs/QUESTIONS.md`: ogni dubbio è una riga numerata (D-xx) con il default applicato e «in attesa di conferma del proprietario»; le risposte arrivate si segnano con la data.
5. Se sono cambiati campi o rotte dell'API web: `docs/API.md` nello stesso commit. Se sono cambiati schema del ledger, file di stato, regole di rischio, impostazioni o file in `/config` e `/data`: `docs/LEDGER_SCHEMA.md`, `docs/DATA_SOURCES.md`, `docs/RISK_RULES.md`, `docs/RUNBOOK.md`, `docs/DOCKER.md`, `docs/KNOWN_ISSUES.md` (togli ciò che si chiude, aggiungi ciò che resta).
6. Verifica (`/encelado-verify`), poi proponi il messaggio di commit: titolo di una riga che dice cosa cambia, corpo che dice perché; un commit per sessione, un commit per fase se la sessione ne copre più d'una. Il push lo decide l'utente.
@@ -0,0 +1,16 @@
---
name: encelado-release
description: Rilascio di Encelado: verifica, zip portabile, immagine Docker, tag, push dell'immagine sul registro di Gitea e release con il template Unraid, in quest'ordine e solo dopo il commit e il push del ramo.
---
# Rilascio di Encelado
Presupposti: albero pulito, ultima sessione committata e pushata, `/encelado-verify` verde, Docker in esecuzione con spazio su disco (l'immagine e la sua cache pesano qualche GB), `build/gitea.json` presente (mai committato: vedi `build/gitea.example.json`; il token deve avere anche `package: read and write`), versione decisa dall'utente (semver; la 5.0.0 è la prima con web UI e Docker, la 5.1.0 la prima con la sola password nel container). `Directory.Build.props` porta la stessa versione come seme di sviluppo; quella rilasciata viene dal tag.
1. `dotnet msbuild build/Release.proj -t:Verifica`.
2. `dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=<x.y.z>` (note in `ENCELADO_NOTE`): pubblica la cartella portabile, costruisce l'immagine `192.168.30.23:3000/alby96/encelado:<x.y.z>` e `:latest` (i test girano anche dentro la build), crea il tag, lo spinge e lo verifica sul remoto, fa il push dell'immagine sul registro di Gitea, crea la release con lo zip portabile e il template Unraid allegati. La versione viene dal tag, non da un file.
3. Template Unraid: aggiorna `deploy/unraid/encelado.xml` solo se cambiano porte, volumi o la variabile (dalla 5.1 c'è solo `ENCELADO_PASSWORD`: ogni altra impostazione sta nell'interfaccia); l'`Icon` è `assets/encelado.png` raw su Gitea (D-29). Il file finisce comunque allegato alla release con la versione nel nome.
4. Su Unraid: *Docker ▸ Controlla aggiornamenti*; il container riparte con SIGTERM pulito e recupero dopo inattività (in Live resta fermo fino ad AVVIA con la frase). Da un container 5.0: la guida passo per passo è in `deploy/unraid/README.md` (variabili tenute per il primo avvio e poi tolte, `ENCELADO_WEB_TOKEN` rinominata `ENCELADO_PASSWORD` con lo stesso valore).
5. `CHANGELOG.md` e `docs/STATE.md` riportano la versione rilasciata; il tag e la release hanno lo stesso testo del CHANGELOG.
Senza Docker: `-p:SaltaDocker=true` produce solo lo zip (non è un rilascio completo, e va detto). Non modificare `build/Release.proj` se non richiesto: la catena è condivisa con Mimante e AutoBidder.
@@ -0,0 +1,14 @@
---
name: encelado-start
description: Avvia una sessione di lavoro su Encelado: legge lo stato, compila, riassume fase e problemi aperti, chiede cosa fare.
---
# Avvio di una sessione su Encelado
1. Leggi, in quest'ordine: `CLAUDE.md`, `docs/STATE.md`, `docs/QUESTIONS.md` (le domande in attesa: dalla 5.1, D-38…D-58), `docs/KNOWN_ISSUES.md`; per toccare l'interfaccia o l'API anche `docs/API.md` e `docs/UI_GUIDELINES.md`.
2. Controlla l'albero di lavoro: `git status --short` e `git log --oneline -5`. Un albero sporco va capito prima di toccare qualcosa (`Modifiche.txt` nella radice è un appunto dell'utente: non si committa).
3. Compila: `dotnet build Encelado.slnx`. Se non compila, la prima cosa da fare è farlo compilare, e va detto subito.
4. Riassumi in dieci righe: fase in corso, cosa è stato fatto nell'ultima sessione, prossimi passi, domande senza risposta, problemi aperti, esito della compilazione.
5. Chiedi all'utente cosa fare in questa sessione. Non iniziare un lavoro senza che sia chiaro quale.
Regole che valgono sempre: niente pacchetti NuGet nell'applicazione, UTC ovunque, ledger append-only, il realizzato solo dallo storico eToro, mai un ordine reale senza `run.allowLive` e la frase `CONFERMO LIVE` scritta nell'interfaccia, impostazioni solo dall'interfaccia (una sola variabile nel container), un commit a fine sessione dopo la verifica.
@@ -0,0 +1,23 @@
---
name: encelado-ui
description: Regole per toccare l'interfaccia web di Encelado: i token e le linee guida in stile Mimante di docs/UI_GUIDELINES.md, nessuna libreria, il contratto di docs/API.md, test dei moduli e dello stream.
---
# Lavorare sull'interfaccia di Encelado
L'interfaccia è servita dal bot (`src/Encelado.Server/Web/wwwroot/`, incorporata come `EmbeddedResource` e servita file per file con `ETag`): `index.html` (lo scheletro), `login.html` (senza script), `css/tokens.css`, `css/app.css`, `css/pages/<pagina>.css`, `js/boot.js` (il tema prima del primo disegno), `js/app.js` (ingresso, modulo ES) con i moduli `state`, `stream`, `util`, `grid`, `ui`, `charts`, `dialog`, `actions`, `baskets`, `labels`, `icons`, `flags`, `clocks`, `split` e una pagina per file in `js/pages/`. Il contratto dei dati è `docs/API.md`; il server scrive il tick in `Web/TickWriter.cs`, le sezioni in `Web/SectionJson.cs` e `Web/SystemJson.cs`, le impostazioni in `Web/SettingsApi.cs`; i dati d'esempio di `--sample` stanno in `Engine/SampleData.cs` e `SampleData.Learning.cs`. Leggi `docs/UI_GUIDELINES.md` prima di scrivere una riga. In sintesi:
- HTML (scritto come XHTML: tag chiusi, attributi con valore) + CSS + moduli ES vanilla importati staticamente; nessun framework, nessuna libreria, nessun font remoto, nessun `<script src=http…>`, nessun `@import`, nessun `import()`.
- La UI non decide niente: legge il tick v2 (`/api/stream`, SSE, uno al secondo condiviso; `?once=1` per una sola lettura) e le sezioni a richiesta con `watch()` quando cambia la loro versione nel tick; manda comandi (`POST /api/commands/<nome>`) e impostazioni (`POST /api/settings`) con `api()` di `util.js`, sempre con `Content-Type: application/json` (il server rifiuta gli altri con 415). Un campo nuovo passa da `EngineView` → `TickWriter`/`SectionJson` → `SampleData` → `docs/API.md` → la pagina → test.
- Token di `css/tokens.css` (colore con un significato: neutro, accento, verde/ambra/rosso, oro), tema scuro di default e chiaro con gli stessi nomi (`ui.theme`), testo a 13 px con cifre tabulari, controlli da 30 px, niente `max-width`.
- DOM costruito una volta e aggiornato cella per cella (`Grid` con righe a chiave); mai `innerHTML` con dati; formattatori `Intl` in cache; niente toast: finestra centrale (`dialog.js`) solo per errori, conferme e risultati importanti, con il fuoco su «Annulla» nelle azioni distruttive; tooltip su ogni numero.
- Le parole del ledger e del motore (evento, codici, motivi d'uscita, stati degli ordini, sorgenti del log) passano da `js/labels.js`: italiano a schermo, codice nel tooltip. Un valore che può essere `null` si mostra «—», mai un conto fatto su `null`.
- Ogni importo convertito nella valuta di visualizzazione porta nel tooltip il valore in USD e il tasso usato; il ledger resta in USD.
- Accessibilità: tastiera completa, `aria-label` sui bottoni a icona, focus visibile, `prefers-reduced-motion`, `prefers-color-scheme`.
Prima di dichiarare finita una modifica:
1. `dotnet test tests/Encelado.Tests --filter "FullyQualifiedName~EmbeddedUi|FullyQualifiedName~WebHost|FullyQualifiedName~SampleApi|FullyQualifiedName~StoppedApi"` verde (XHTML ben formato, ogni `import` risolto con i nomi esportati, nessun altro host, file serviti con il loro tipo, password, cookie, stream, forma del tick).
2. `node --check` su una copia `.mjs` dei moduli toccati, se Node c'è (su un `.js` Node legge uno script e non vede gli errori propri dei moduli).
3. `dotnet run --project src/Encelado.Server -- --sample --port 8085` e controllo a occhio nel browser (ogni pagina toccata, tema chiaro e scuro, larghezza da telefono, console pulita). In `--sample` comandi e salvataggi rispondono «modalità dimostrativa».
4. Se una pagina è cambiata, rifai gli screenshot in `docs/img/` (`scripts\screenshots.ps1`, comando in `docs/UI_GUIDELINES.md`) e chiedi la revisione visiva all'utente.
@@ -0,0 +1,19 @@
---
name: encelado-verify
description: La verifica completa di Encelado prima di un commit: compilazione, test (inclusi HTML incorporato e stream), controllo dei file di configurazione e catena di rilascio.
---
# Verifica di Encelado
Esegui nell'ordine e riporta l'esito di ciascun passo con i numeri (errori, avvisi, test superati/non superati), senza abbellire:
1. `dotnet build Encelado.slnx` — deve chiudere con 0 errori e 0 avvisi (`TreatWarningsAsErrors` è attivo: un avviso è un errore). Se un server locale tiene bloccata `Encelado.Server.dll`, fermalo prima (`stop` sulla sua console o Ctrl+C).
2. `dotnet test tests/Encelado.Tests --no-build` — tutti verdi. Un test rosso si legge e si corregge; non si esclude. I test di concorrenza (ciclo di vita, impostazioni, attese dopo una password errata) si possono ripetere due o tre volte per escludere instabilità.
3. Coerenza dei file di fabbrica: `config/strategy.json` deve essere identico a `BasketStrategyConfig.DefaultJson` e `config/encelado.json` a `ConfigDefaults.Json` (ci sono test che lo verificano: se falliscono, rigenera i file dalle costanti, non il contrario).
4. Interfaccia web: `EmbeddedUiTests` (XHTML ben formato, ogni `import` dei moduli risolto con i nomi esportati, nessun riferimento esterno, token con i due temi, login senza script) e `WebHostTests`, `SampleApiTests`, `StoppedApiTests` (file serviti con il loro tipo, password, cookie, attesa e 429 dopo una password errata, 415/403 per le richieste da altrove, stream con un tick al secondo, forma del tick, storico CSV) sono nella suite del passo 2; se hai toccato una pagina, anche `node --check` sui moduli e il controllo a occhio con `--sample` (`/encelado-ui`).
5. `docs/API.md` dice la verità sui campi toccati (il contratto si aggiorna nello stesso commit).
6. `dotnet msbuild build/Release.proj -t:Verifica` — la catena di rilascio compila e testa nella cartella di verifica.
7. Se hai toccato `Dockerfile`, `deploy/` o la catena: `dotnet msbuild build/Release.proj -t:Docker` (o `docker build .`) deve produrre l'immagine; `docker run --rm <immagine> --health` non è un test valido a freddo (il server non gira): usa `docker compose up` e `docker inspect --format '{{.State.Health.Status}}' encelado`.
8. Riepilogo: una tabella `passo;esito;dettaglio`. Se un passo fallisce, fermati lì e proponi la correzione.
Non toccare `build/` se non richiesto: è condiviso con Mimante e AutoBidder.
+21
View File
@@ -0,0 +1,21 @@
# Ciò che non serve dentro il contesto di build. .git resta fuori: il commit
# arriva dal build-arg GIT_COMMIT (vedi build/Release.proj e la Dockerfile).
.git
.gitignore
.vscode
.claude
**/bin
**/obj
**/TestResults
bin
obj
results
reports
docs/img
deploy/local
build/gitea.json
*.md
!docs/**/*.md
Modifiche.txt
*.local.json
.env
+36
View File
@@ -0,0 +1,36 @@
# Verifica a ogni push e pull request: compilazione con gli avvisi come errori e la
# suite dei test. Un secondo lavoro costruisce l'immagine (senza pubblicarla) per
# accorgersi subito di una Dockerfile rotta: richiede un runner con Docker.
#
# Runner: act_runner con l'etichetta ubuntu-latest (vedi docs/DOCKER.md, «Gitea Actions»).
name: ci
on:
push:
branches: [main]
pull_request:
jobs:
verifica:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-dotnet@v4
with:
dotnet-version: "10.0.x"
- name: Compilazione (avvisi = errori)
run: dotnet build Encelado.slnx -c Release -nologo -warnaserror
- name: Test
run: dotnet test tests/Encelado.Tests -c Release --no-build --nologo -v q
immagine:
runs-on: ubuntu-latest
needs: verifica
steps:
- uses: actions/checkout@v4
- name: Costruzione dell'immagine (i test girano anche dentro la build)
run: |
docker build --pull \
--build-arg VERSION=ci \
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
-t encelado:ci .
+78
View File
@@ -0,0 +1,78 @@
# Rilascio a ogni tag vX.Y.Z: l'immagine sul registro dei container di Gitea
# (<host>/alby96/encelado:X.Y.Z e :latest) e la release con il template Unraid allegato.
#
# È la stessa cosa che fa build/Release.proj -t:Rilascia dal PC; qui gira sul runner
# quando il tag arriva sul server. Idempotente: un'immagine già presente viene
# sovrascritta con lo stesso contenuto, una release già creata dalla catena viene
# lasciata com'è e le manca solo l'allegato, che viene aggiunto se non c'è.
#
# Serve il segreto REGISTRY_TOKEN (Impostazioni ▸ Actions ▸ Segreti del repository):
# un token dell'utente con i permessi package:write e repository:write.
# Solo linux/amd64: la build esegue la suite dei test, e sotto QEMU (arm64) sarebbe
# lentissima; il server Unraid è amd64.
name: release
on:
push:
tags: ["v*"]
jobs:
immagine:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Versione e registro dal tag e dall'indirizzo del server
run: |
echo "VERSION=${GITHUB_REF_NAME#v}" >> "$GITHUB_ENV"
echo "REGISTRY=$(echo "${{ gitea.server_url }}" | sed -E 's#^https?://##; s#/$##')" >> "$GITHUB_ENV"
echo "OWNER=$(echo "${{ gitea.repository_owner }}" | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_ENV"
- uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY }}
username: ${{ gitea.actor }}
password: ${{ secrets.REGISTRY_TOKEN }}
- uses: docker/setup-buildx-action@v3
with:
# Il registro di Gitea è in HTTP: buildx deve poterlo trattare come insicuro.
driver-opts: network=host
buildkitd-config-inline: |
[registry."${{ env.REGISTRY }}"]
http = true
insecure = true
- uses: docker/build-push-action@v6
with:
context: .
platforms: linux/amd64
push: true
build-args: |
VERSION=${{ env.VERSION }}
GIT_COMMIT=${{ gitea.sha }}
tags: |
${{ env.REGISTRY }}/${{ env.OWNER }}/encelado:${{ env.VERSION }}
${{ env.REGISTRY }}/${{ env.OWNER }}/encelado:latest
- name: Release con il template Unraid allegato
env:
TOKEN: ${{ secrets.REGISTRY_TOKEN }}
API: ${{ gitea.server_url }}/api/v1/repos/${{ gitea.repository }}
run: |
set -eu
TAG="${GITHUB_REF_NAME}"
ASSET="encelado-unraid-${VERSION}.xml"
cp deploy/unraid/encelado.xml "$ASSET"
ID=$(curl -sf -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | sed -n 's/.*"id":\([0-9]*\).*/\1/p' | head -1 || true)
if [ -z "$ID" ]; then
BODY=$(printf '{"tag_name":"%s","name":"Encelado %s","body":"Versione %s.\\n\\nImmagine: `%s/%s/encelado:%s` (anche `:latest`). Template Unraid allegato.","draft":false,"prerelease":false}' "$TAG" "$VERSION" "$VERSION" "$REGISTRY" "$OWNER" "$VERSION")
ID=$(curl -sf -H "Authorization: token $TOKEN" -H "Content-Type: application/json" --data-binary "$BODY" "$API/releases" | sed -n 's/.*"id":\([0-9]*\).*/\1/p' | head -1)
echo "release $TAG creata (id $ID)"
else
echo "release $TAG già presente (id $ID): aggiungo solo l'allegato mancante"
fi
if ! curl -sf -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" | grep -q "\"name\":\"$ASSET\""; then
curl -sf -H "Authorization: token $TOKEN" -F "attachment=@$ASSET" "$API/releases/$ID/assets?name=$ASSET" > /dev/null
echo "allegato $ASSET caricato"
fi
+6
View File
@@ -16,3 +16,9 @@ logs/
# build/gitea.example.json; questo file contiene una credenziale e non entra
# mai nel repository.
build/gitea.json
# Output dei test (coverlet)
TestResults/
# Volumi di docker-compose per le prove in locale (configurazione e dati del container)
deploy/local/
+4 -4
View File
@@ -4,9 +4,9 @@
"ms-dotnettools.csharp",
"ms-dotnettools.csdevkit",
// Colora installer\Encelado.iss e ne conosce direttive e costanti. Serve solo a
// leggere e scrivere quel file: l'installer si costruisce con il task
// "installer", che non dipende da nessuna estensione.
"idleberg.innosetup"
// Colora la Dockerfile e la docker-compose.yml e mostra container e immagini
// locali. L'immagine si costruisce con il task "immagine docker", che non
// dipende da nessuna estensione.
"ms-azuretools.vscode-docker"
]
}
+55 -7
View File
@@ -1,17 +1,65 @@
{
// One way to launch, on purpose. Encelado is a desktop application: F5 here starts
// the same window you get by double-clicking Encelado.exe. Everything else — login,
// start/stop, backtest, settings — lives inside that window.
// F5 avvia il server (motore + interfaccia web) come processo locale, fuori dal
// container, con configurazione e dati nella sandbox deploy/local (ignorata da git,
// stesse cartelle che il compose monta come /config e /data). Il browser si apre da
// solo appena Kestrel è in ascolto. La password dell'interfaccia è "sviluppo", la
// stessa del compose: i segreti cifrati della sandbox (chiavi eToro, token Telegram,
// inseriti da Impostazioni) restano leggibili sia da F5 sia dal container. La password
// serve ai segreti, non apre la rete: fuori dal container il server ascolta solo su
// localhost (per la rete servirebbe l'argomento --listen-all).
// "Encelado (campione)" serve l'interfaccia con dati finti, senza chiavi né mercato e
// senza password, in cartelle temporanee: non legge né scrive Documenti\Encelado o la
// sandbox, non tocca segreti né Telegram. È quello che si usa per lavorare sulle pagine.
"version": "0.2.0",
"configurations": [
{
"name": "Encelado",
"name": "Encelado (server)",
"type": "coreclr",
"request": "launch",
"preLaunchTask": "build",
"program": "${workspaceFolder}/src/Encelado.Bot/bin/Debug/net10.0-windows/Encelado.exe",
"cwd": "${workspaceFolder}/src/Encelado.Bot/bin/Debug/net10.0-windows",
"console": "internalConsole",
"program": "${workspaceFolder}/src/Encelado.Server/bin/Debug/net10.0/Encelado.Server.dll",
"args": ["--no-autostart"],
"cwd": "${workspaceFolder}/src/Encelado.Server/bin/Debug/net10.0",
"console": "integratedTerminal",
"stopAtEntry": false,
"env": {
"ENCELADO_WEB_PORT": "8080",
"ENCELADO_PASSWORD": "sviluppo",
"ENCELADO_CONFIG_DIR": "${workspaceFolder}/deploy/local/config",
"ENCELADO_DATA_DIR": "${workspaceFolder}/deploy/local/data",
"DOTNET_ENVIRONMENT": "Development"
},
"serverReadyAction": {
"action": "openExternally",
"pattern": "in ascolto su (http://\\S+)",
"uriFormat": "%s"
}
},
{
"name": "Encelado (campione)",
"type": "coreclr",
"request": "launch",
"preLaunchTask": "build",
"program": "${workspaceFolder}/src/Encelado.Server/bin/Debug/net10.0/Encelado.Server.dll",
"args": ["--sample", "--port", "8081"],
"cwd": "${workspaceFolder}/src/Encelado.Server/bin/Debug/net10.0",
"console": "integratedTerminal",
"stopAtEntry": false,
"serverReadyAction": {
"action": "openExternally",
"pattern": "in ascolto su (http://\\S+)",
"uriFormat": "%s"
}
},
{
"name": "Backtest (baskets)",
"type": "coreclr",
"request": "launch",
"preLaunchTask": "build",
"program": "${workspaceFolder}/tools/Encelado.Backtest/bin/Debug/net10.0/backtest.dll",
"args": ["baskets", "--data", "${env:USERPROFILE}/Documents/Encelado/data/market", "--out", "results", "--quick"],
"cwd": "${workspaceFolder}",
"console": "integratedTerminal",
"stopAtEntry": false
}
]
+51 -15
View File
@@ -3,7 +3,8 @@
// MSBuild versionato col codice, e qui restano soltanto i nomi e le domande.
// MSBuild non può chiedere niente a nessuno — i prompt stanno in "inputs".
//
// È la stessa impostazione di Mimante/AutoBidder.
// È la stessa impostazione di Mimante/AutoBidder, con l'immagine Docker al
// posto dell'installatore.
"version": "2.0.0",
"tasks": [
{
@@ -39,7 +40,7 @@
},
{
"label": "backtest",
"detail": "Rigioca una serie storica di prezzi: taratura contro verifica, con il confronto sul comprare e tenere.",
"detail": "Ricerca sui basket: ticks (tick MT5 → barre), baskets (griglia, PSR/DSR, PBO, walk-forward), falsify (falsificazione), learn (ciclo di apprendimento in ombra su un ledger).",
"type": "process",
"command": "dotnet",
"args": [
@@ -55,14 +56,14 @@
"problemMatcher": []
},
{
"label": "crea installatore",
"detail": "Verifica, pubblica ed esegue Inno Setup: bin/installer/Encelado-<versione>-setup.exe. Crea il tag a pacchetto pronto. Non tocca Gitea.",
"label": "immagine docker",
"detail": "Verifica e costruisce l'immagine 192.168.30.23:3000/alby96/encelado:<versione> (e :latest) con la Dockerfile alla radice. Non pubblica niente.",
"type": "process",
"command": "dotnet",
"args": [
"msbuild",
"${workspaceFolder}/build/Release.proj",
"-t:Pacchetto",
"-t:Docker",
"-p:Versione=${input:versione}",
"-nologo",
"-v:m"
@@ -71,8 +72,8 @@
"problemMatcher": "$msCompile"
},
{
"label": "crea installatore (senza rieseguire i test)",
"detail": "Solo pubblicazione e Inno Setup. Da usare quando i test sono appena passati.",
"label": "pacchetto",
"detail": "Verifica, pubblica la cartella portabile (bin/installer/Encelado_<versione>_portabile.zip) e costruisce l'immagine. Crea il tag a pacchetto pronto. Non tocca Gitea.",
"type": "process",
"command": "dotnet",
"args": [
@@ -80,7 +81,6 @@
"${workspaceFolder}/build/Release.proj",
"-t:Pacchetto",
"-p:Versione=${input:versione}",
"-p:SaltaVerifica=true",
"-nologo",
"-v:m"
],
@@ -89,7 +89,7 @@
},
{
"label": "rilascia su Gitea",
"detail": "Verifica, pubblica, installatore, tag e release su Gitea con i file allegati. La versione viene dal tag su HEAD. Richiede build/gitea.json.",
"detail": "Verifica, pacchetto, immagine, tag, push dell'immagine sul registro di Gitea e release con lo zip e il template Unraid allegati. Richiede build/gitea.json.",
"type": "process",
"command": "dotnet",
"args": [
@@ -110,13 +110,49 @@
},
"presentation": { "reveal": "always", "panel": "dedicated" },
"problemMatcher": "$msCompile"
},
{
"label": "avvia in locale (script)",
"detail": "scripts/run-dev.ps1: compila e avvia il server nella sandbox deploy/local, senza container. Ctrl+C per fermare.",
"type": "shell",
"command": "powershell -ExecutionPolicy Bypass -File scripts/run-dev.ps1",
"options": { "cwd": "${workspaceFolder}" },
"presentation": { "reveal": "always", "panel": "dedicated" },
"problemMatcher": []
},
{
"label": "avvia in docker",
"detail": "scripts/run-docker.ps1: costruisce l'immagine e avvia il container dalla docker-compose.yml (deploy/local come /config e /data), poi segue il log.",
"type": "shell",
"command": "powershell -ExecutionPolicy Bypass -File scripts/run-docker.ps1",
"options": { "cwd": "${workspaceFolder}" },
"presentation": { "reveal": "always", "panel": "dedicated" },
"problemMatcher": []
},
{
"label": "ferma docker",
"detail": "docker compose down: SIGTERM al bot, stop pulito, container rimosso (cartelle in deploy/local conservate).",
"type": "shell",
"command": "docker compose down",
"options": { "cwd": "${workspaceFolder}" },
"presentation": { "reveal": "always", "panel": "dedicated" },
"problemMatcher": []
},
{
"label": "screenshot",
"detail": "scripts/screenshots.ps1: server in modalità campione e Edge headless, rigenera docs/img/*.png.",
"type": "shell",
"command": "powershell -ExecutionPolicy Bypass -File scripts/screenshots.ps1",
"options": { "cwd": "${workspaceFolder}" },
"presentation": { "reveal": "always", "panel": "dedicated" },
"problemMatcher": []
}
],
"inputs": [
{
"id": "versione",
"type": "promptString",
"description": "Versione — lascia vuoto se hai già taggato (git tag v3.3.0), o per la minor successiva",
"description": "Versione — lascia vuoto se hai già taggato (git tag v5.0.0), o per la minor successiva",
"default": ""
},
{
@@ -128,15 +164,15 @@
{
"id": "dati",
"type": "promptString",
"description": "File CSV con la serie storica dei prezzi",
"default": "C:\\Users\\alber\\Downloads\\BTC\\btcusd_bitstamp_1min_2012-2025.csv"
"description": "Cartella dei dati: data/market (barre M15) per baskets e falsify, la cartella dei tick MT5 per ticks, la cartella data del bot per learn",
"default": "C:\\Users\\alber\\Documents\\Encelado\\data\\market"
},
{
"id": "comando",
"type": "pickString",
"description": "Cosa misurare",
"options": ["split", "walk", "frequency", "costs", "sweep", "explore"],
"default": "split"
"description": "Comando del backtest",
"options": ["baskets", "falsify", "ticks", "learn"],
"default": "baskets"
}
]
}
+154
View File
@@ -0,0 +1,154 @@
# Cronologia
Formato: una voce per sessione di lavoro, con data. Le voci più recenti in alto.
## 2026-09-30/10-01 — 5.1.0: tutto dall'interfaccia, una sola password nel container, P&L oggi corretto, nuova interfaccia in stile Mimante
Le richieste dell'utente (`Modifiche.txt` del 2026-09-30), poi una revisione completa del codice con le correzioni. Versione di sviluppo 5.1.0 (`Directory.Build.props`, D-50); 561 test verdi, compilazione senza avvisi. Le scelte fatte senza risposta sono in `docs/QUESTIONS.md` (D-38…D-58, in attesa di conferma); le decisioni in ADR-0010…ADR-0014.
### Le richieste
- **Solo la password nel container** (ADR-0010): l'unica variabile è `ENCELADO_PASSWORD` («Password interfaccia» nel template Unraid; `ENCELADO_WEB_TOKEN` resta come alias deprecato). Conto, chiavi eToro dei due conti, Telegram, valuta, log, avvio automatico e strategia si impostano dalla pagina. Le chiavi e il token Telegram vivono in `/config/secrets.enc`, cifrati con la password (AES-256-GCM, PBKDF2 600 000 iterazioni); se la password cambia, i segreti si sbloccano con quella precedente o si ricomincia. Il cookie di sessione è un HMAC della password e di un segreto del server (`/config/session.key`), mai la password; `POST /logout`. Al primo avvio le variabili di un container 5.0 vengono importate una volta (`import-5.1.json`) e poi ignorate ed elencate; il caricatore non legge più l'ambiente. `run.autostart` al posto di `ENCELADO_AUTOSTART`; template, compose e Dockerfile senza PUID/PGID/TZ.
- **Paper eliminata**: il conto demo di eToro è il simulatore. Le modalità sono `Demo` e `Live` e scelgono anche il conto (`etoro.environment` non esiste più): chiuso il buco per cui `Demo` + ambiente `real` mandava ordini sul conto reale senza il cancello del Live. Il Live chiede `run.allowLive` e la frase `CONFERMO LIVE` scritta nell'interfaccia a ogni avvio, **non parte mai da solo** (allarme e avviso Telegram) e non ha più `ENCELADO_CONFIRM_LIVE` né `--confirm-live`. Il cambio Demo ↔ Live è rifiutato finché il conto non è piatto.
- **Orologi con le bandiere** (D-49): uno per fuso delle valute trattate (Nuova Zelanda, Australia, Europa centrale/Svizzera, USA/Canada), più quello del computer solo se diverso; UTC nei tooltip.
- **Log**: il livello è un'etichetta colorata e ogni messaggio sta su una riga (gli a capo diventano « ⏎ »); le parole del ledger sono in italiano (`labels.js`), il codice nel tooltip.
- **Pagina Apprendimento** (`/api/learning`): dataset, criteri di attivazione, pesi imparati e contributi, bandit 3×3 con gli intervalli di credibilità, ultimo ciclo con la valutazione completa, AUC mobile, calibrazione, proposte, registro, file, intuizioni. «Esegui ciclo» in ogni stato: il ciclo gira in background con un solo scrittore dei file (ADR-0014; nella 5.0 il ciclo dalla pagina era un secondo scrittore dei modelli e il settimanale fermava il thread di decisione).
- **Nuova interfaccia in stile Mimante** (ADR-0013): dashboard compatta che riassume tutto in una schermata (9 tessere, basket, eventi, quotazioni, registro) e nove pagine di dettaglio (Basket, Posizioni, Mercato, Storico, Apprendimento, Log, Sistema, Impostazioni); lo stato di Telegram e il dettaglio del collegamento eToro passano in Sistema. Moduli ES vanilla, nessuna libreria, tema scuro e chiaro.
- **Layout fluido**: niente larghezza massima, niente fascia grigia a destra; tabelle che cedono colonne e scorrono nel loro pannello, mai la pagina; provata da 420 a 2560 px.
- **Controlli allineati**: barre strumenti su una riga, tutti i controlli alti 30 px (anche «Segui» del Log, ora una levetta allineata al filtro e alla ricerca).
- **Niente valuta nella barra in alto**: si sceglie in Impostazioni ▸ Interfaccia.
- **Impostazioni applicate a caldo**: ogni campo dice quando vale (⚡ subito, ⚙ nel motore in esecuzione, ↻ con un riavvio automatico del motore che non chiude i basket) e la risposta lo dice campo per campo; tutta la strategia, il rischio, il recupero e l'apprendimento sono nel form (Avanzate chiuso).
- **Preset fisso**: si sceglie in Impostazioni ▸ Strategia ed è parte della strategia; il comando per cambiarlo a caldo è tolto ovunque (web, console, Telegram). Un cambio vale per i basket nuovi: quelli aperti tengono z di stop, aggiunte, TP, perdita massima e preset con cui sono entrati.
- **Stato fuori dal menu**: le scritte «in esecuzione» e «demo» in fondo al menu diventano la pill del motore nella barra in alto (pallino colorato per lo stato, `DEMO`/`LIVE` per il conto).
- **«P&L oggi» corretto** (ADR-0011): il vecchio numero (circa 47 000 USD su 139 000 di equity) sommava i `proceeds` delle chiusure, cioè margine restituito **più** profitto. Sul conto demo, dal 23 al 30 settembre, il bot ha chiuso 102 posizioni con un risultato netto di **−269,42 USD**, mentre la somma registrata superava i 903 000 USD; il 24/9 sei chiusure da +48,34 USD di netto contavano come circa 53 900. Ora il realizzato di ogni posizione è quello dello **storico di eToro** (`netProfit − fees`, per `positionId`), lo stesso della pagina Storico; «P&L oggi» è il realizzato delle posizioni del bot chiuse oggi (UTC), con le stime provvisorie segnate «stima» e «—» quando non è noto; accanto c'è la variazione dell'equity netta da mezzanotte. Le righe di `baskets.csv` aspettano lo storico in una coda persistente (dopo 30 minuti la stima, che non addestra). La perdita giornaliera, che con i proceeds non scattava mai dopo la prima chiusura del giorno, guarda l'equity netta dalla mezzanotte. **Il passato è corretto con righe nuove**: all'avvio una verifica idempotente scrive righe `correzione` (`pnl_realizzato`) per le righe della 4.0.0-5.0.0, `lastNOutcomes` è neutralizzata prima della correzione, i modelli addestrati sui proceeds vengono messi da parte e la logistica riaddestrata, il bandit riparte dal prior.
- **Interfaccia leggera** (ADR-0012): il motore pubblica viste immutabili e il server costruisce un solo tick al secondo per tutti i browser (niente se nessuno guarda), con le righe di log nuove e le versioni delle sezioni; le parti pesanti si leggono a richiesta con `ETag`; il browser aggiorna cella per cella solo la pagina visibile. Circa 64 ms di lavoro ogni 10 s sulla dashboard, tick da ~40 KB a pochi KB. Calendario e notizie si scaricano in background, anche a motore fermo.
- `--sample` serve dati d'esempio coerenti per ogni rotta; `/api/info` diventa un alias di `/api/system`, `/api/research` è assorbita da `/api/learning`; screenshot rifatti (`docs/img/`, 11 pagine più il tema chiaro e il telefono).
### Correzioni della revisione
Una revisione del codice della 5.1 ha trovato 51 problemi; quelli confermati sono corretti, ciascuno con un test che fallisce senza la correzione.
- **Ciclo di vita del motore**: un solo lucchetto per avvio, arresto, riavvii automatici e ciclo di apprendimento a motore fermo; FERMA durante un avvio aspetta il motore e lo ferma (prima restava un motore che operava irraggiungibile); un riavvio automatico non annulla più un FERMA arrivato prima; AVVIA subito dopo FERMA aspetta che il motore precedente lasci la cartella dati. Un kill-switch, una chiusura o la chiusura dei residui in corso non vengono mai interrotti da FERMA o da un salvataggio (409); solo `docker stop` li interrompe dopo 30 s, registrando il residuo. Ogni comando riceve una risposta («comando interrotto: il motore si è fermato», 504 con un messaggio per un'attesa scaduta, mai 500). La chiusura all'arresto (`closeOnShutdown`) è un comando sul thread di decisione, che prima blocca le entrate. «Esegui ciclo» risponde 409 finché il ciclo di decisione non è partito. Lo stream non tiene più un iscritto il cui primo tick fallisce. L'heartbeat pubblica il suo intervallo e `/api/health` usa 3 × intervallo + 15 s.
- **Conti**: lo stato del motore è **per conto** (`baskets_state.demo.json`, `baskets_state.live.json`, D-53): passare da un conto all'altro non sovrascrive più chiusure in attesa del P&L, equity stop, kill-switch, residuo, pausa e picco dell'altro. Il registro degli ordini resta unico ma ogni motore tocca solo i suoi. La guardia del cambio di conto è un comando sul thread di decisione (prima leggeva la vista, piatta a metà di un ingresso), con un nuovo controllo dopo l'arresto e l'annullamento del salvataggio se il conto non è piatto. All'avvio il saldo si giudica solo quando lo storico mostra ogni chiusura: una perdita non ancora nello storico non diventa più un prelievo.
- **Soldi**: la perdita giornaliera, raggiunta, **blocca fino alle 00:00 UTC anche se l'equity recupera** (D-52), nel motore e nel backtest, anche dopo un riavvio (prima il blocco cadeva appena l'equity risaliva, mentre l'interfaccia prometteva «fino a domani»); un calo del saldo che lo storico non spiega ancora sospende senza bloccare la giornata (D-54). Una posizione finisce in `baskets.csv` una volta sola (prima una chiusura vista da due percorsi poteva raddoppiare il P&L dei riepiloghi). La verifica del realizzato ha una soglia per conto (prima le righe Live restavano con i proceeds e li insegnavano ai modelli). Le gambe singole della 4.0-5.0 si abbinano alla loro nota senza indovinare. La riga di un'aggiunta richiusa non trasforma più le gambe del basket in orfane. La cache dello Storico rispetta il periodo chiesto («anno» e «tutto» non escono più calcolati su 90 giorni). La riga di `baskets.csv` e il premio del bandit nominano il preset con cui il basket è entrato. Il kill-switch fa ciò che sceglie l'operatore nel dialogo (prima chiudeva le esterne anche con la casella spenta, se l'impostazione era accesa) (D-55).
- **Segreti e web**: un file 5.0 con `Live` e ambiente `demo` resta sul conto demo dopo un salvataggio qualsiasi (prima diventava Live, scavalcando guardia, chiavi e frase). Una password errata costa un'attesa anche via Bearer, per indirizzo e fino a 30 s, e durante l'attesa non si controlla niente (D-56). Le richieste da altri siti sono rifiutate (`Content-Type: application/json` obbligatorio sotto `/api/`, controllo di `Origin` e `Sec-Fetch-Site`, `Host` locale senza password). `--sample` lavora in cartelle temporanee e non tocca più segreti, configurazione o il bot Telegram dell'operatore. La rete si apre solo nel container o con `--listen-all` (D-57). Il tick porta `statusLines` (le righe della striscia della dashboard, prima salvate e mai lette). L'importazione segue l'ordine delle chiavi della 5.0; un `secrets.enc` con un numero di iterazioni assurdo è danneggiato, non un avvio fermo per minuti; `run-docker` non stampa più la password; la pagina Apprendimento a motore fermo segue subito le modifiche di `strategy.json`.
- **Apprendimento**: i contributi mostrati spiegano sempre la `p_ML` accanto (vengono dal modello che l'ha data, salvati con l'ingresso; dopo un riavvio un basket aperto riprende la sua p); il ritiro dei modelli è tutto o niente e non si ripete; dopo la verifica del realizzato la sessione rilegge esiti e conteggio dal ledger corretto; i basket etichettati sono contati come li conta il dataset ovunque; a motore fermo la pagina segue subito le correzioni e tiene l'ultima lettura buona di un file illeggibile; un braccio del bandit mai provato non è mai «il migliore».
- **Interfaccia**: impostazioni salvabili dopo due modifiche allo stesso campo; gli stati di un basket spento non sono più nascosti; filtri ricordati sempre visibili; quotazioni del Mercato che seguono il tick; «—» invece di 0 per i valori sconosciuti; fuoco su «Annulla» nelle conferme distruttive (un Invio tenuto premuto non esegue più un kill-switch); `Content-Type: application/json` su ogni POST e DELETE.
- **Ledger**: la rotazione mensile delle decisioni va solo in avanti e non sovrascrive mai un file già ruotato (l'ultima barra del mese valutata dopo la mezzanotte faceva ruotare all'indietro e perdeva una riga).
### Correzioni della seconda revisione (2026-10-01)
Una seconda verifica indipendente delle correzioni ha trovato nove punti rimasti aperti; ciascuno ha un test che lo riproduce.
- **Stato della 5.0 al conto giusto**: il `mode` di `baskets_state.json` della 5.0 era la modalità, non il conto. Un file `Live` scritto con `etoro.environment` demo finiva nel file del conto reale, e al primo Live il saldo del demo diventava un «prelievo» di oltre 100 000 USD, con equity stop e perdita giornaliera misurati sulla cifra sbagliata; un file Paper riprendeva basket simulati sul conto demo. Ora l'importazione registra su che conto operava la 5.0 (`legacyState` in `import-5.1.json`) e il file va lì; Paper, o una modalità diversa, non vengono ripresi.
- **Comandi critici fino alla fine**: un kill-switch, una chiusura o la chiusura dei residui tengono fermi FERMA e i riavvii finché il motore li ha in mano, non finché chi li ha chiesti aspetta: chiudere la scheda, una risposta 504 dopo 120 s o Telegram spento a metà `/kill` non liberano più FERMA a metà kill-switch.
- **Chiavi salvate mentre il conto cambia**: dopo la verifica (fino a 25 s) si rilegge il conto in uso; chiavi che non sono più del conto del motore non lo riavviano, e un motore Live non viene mai riavviato senza la frase (prima restava fermo, con i basket reali sui soli stop nativi).
- **Guardia del cambio di conto**: il motore riconcilia con il conto prima di contare, così una gamba rimasta sola (richiusura rifiutata) conta come orfana invece di restare sul conto lasciato; posizioni non lette: cambio rifiutato.
- **Perdita giornaliera con lo storico in ritardo**: un calo del saldo non ancora spiegato sospende le entrate fino alla spiegazione anche se l'equity recupera (prima tornavano permesse), e la lettura che lo spiega blocca la giornata se, al minimo toccato nel frattempo, la perdita di trading superava la soglia (prima non la bloccava mai); un movimento di cassa non la blocca. Il cruscotto mostra la sospensione per tutto il tempo.
- **Apprendimento, il secondo conto**: le righe della 4.0-5.0 dell'altro conto si correggono quando quel conto gira; quell'avvio ora neutralizza di nuovo `lastNOutcomes` fino ad allora e rifà la logistica sulle etichette corrette (prima restavano l'etichetta sbagliata nel modello e una feature sbagliata, non mascherata, nelle righe della sessione intermedia).
- **Pagina Apprendimento a motore fermo**: un file mai letto bene resta «valori iniziali» anche alle letture successive (prima diventava «l'ultima lettura buona» mostrando il prior); lo stesso per `last_cycle.json`.
- **Accesso**: il cookie di sessione contiene un segreto del server (`/config/session.key`, D-56 aggiornata), quindi non è più un tentativo di password: una scheda rimasta aperta dopo un cambio di password non tiene più fuori la password giusta (prima 429 finché restava aperta), una pagina già entrata non viene fermata da chi tenta password dallo stesso indirizzo né gli azzera il conto, e l'interfaccia torna alla pagina di accesso a un 401 o 429. Serve un nuovo accesso dopo l'aggiornamento. La risposta a una password errata arriva solo a attesa davvero finita (un nuovo tentativo immediato riceveva ancora 429).
- **Test**: il preset d'ingresso è verificato dall'esecutore alla posizione e nello stato salvato (togliere una delle due righe non faceva fallire nessun test).
### Da sapere (aggiornamento dalla 5.0)
1. Al primo avvio della 5.1 **tieni le variabili della 5.0** (anche `ENCELADO_KEY_PASSPHRASE` se le chiavi erano in `etoro.keys.enc`): vengono importate una volta. **Rinomina `ENCELADO_WEB_TOKEN` in `ENCELADO_PASSWORD` con lo stesso valore**, così i segreti restano leggibili. Poi togli dal container tutte le altre variabili (la striscia degli allarmi e Sistema ▸ Segreti le elencano). Passo per passo in `deploy/unraid/README.md`.
2. Con una password diversa i segreti risultano bloccati: Impostazioni ▸ Conto ▸ «Sblocca con la password precedente», o «Ricomincia» e reinserisci chiavi e token.
3. Il primo avvio sposta lo stato nel file del conto su cui operava la 5.0 (`baskets_state.json` resta come `.migrato`; lo stato di Paper non viene ripreso), corregge il realizzato della 4.0.0-5.0.0 con righe nuove e ritira una volta i modelli addestrati sui proceeds: poi premi **Esegui ciclo** e segna `respinta` in `knowledge/proposals.csv` le proposte nate dalle etichette sbagliate.
4. I messaggi Telegram e i log già inviati dalla 4.0.0 alla 5.0.0 con il «netto» e il «P&L oggi» sbagliati restano come sono: il ledger è corretto, la cronologia no.
5. In Live il motore non riparte più da solo dopo un riavvio: AVVIA e `CONFERMO LIVE`, ogni volta.
6. Gli script che chiamano l'API devono mandare `Content-Type: application/json` su ogni POST e DELETE; dietro un reverse proxy il proxy deve passare l'`Host` originale (`docs/DOCKER.md`).
7. Il preset si cambia solo da Impostazioni ▸ Strategia; il comando `preset` (console, web) non esiste più.
8. Dopo l'aggiornamento serve un nuovo accesso alla pagina (il cookie contiene ora un segreto del server, `/config/session.key`; cancellarlo chiude tutte le sessioni).
## 2026-09-23 — 5.0.0 rilasciata; workflow Gitea Actions; guida Unraid
- **Versione 5.0.0**: tag `v5.0.0`, immagine `192.168.30.23:3000/alby96/encelado:5.0.0` e `:latest` sul registro dei container di Gitea, release con la cartella portabile e il template Unraid allegati (catena `-t:Rilascia`).
- `.gitea/workflows/ci.yml` (compilazione con avvisi come errori, test, `docker build` a ogni push) e `release.yml` (immagine sul registro e release a ogni tag `v*`, idempotente rispetto alla catena). Servono un runner e il segreto `REGISTRY_TOKEN`, oggi assenti.
- `deploy/unraid/README.md`: installazione passo per passo (registro in HTTP, template, campi, primo avvio, aggiornamento).
## 2026-09-23 — 5.0, Fasi 6-9: solo container, interfaccia web, Docker e Unraid, pulizia
- **Ritirata la finestra WPF** (D-28, ADR-0007): `src/Encelado.Bot` diventa la libreria `src/Encelado.Engine`; l'eseguibile è `src/Encelado.Server` (Kestrel, nessun NuGet) che ospita il motore e serve l'interfaccia. Chiavi eToro da variabili d'ambiente o dal file cifrato `etoro.keys.enc` (AES-256-GCM, `ENCELADO_KEY_PASSPHRASE`) al posto di DPAPI. Cartelle `/config` e `/data` nel container, `Documenti\Encelado` fuori.
- **Interfaccia web Material 3** senza librerie (`Web/wwwroot`): navigation rail, barra con orologi UTC e fuso, valuta di visualizzazione (otto valute, tasso dalle quotazioni, tooltip in USD), AVVIA/FERMA e KILL-SWITCH con dialoghi (esterne, motivazione, `CONFERMO LIVE`); dashboard con sei KPI e la tabella dei basket (cards da telefono); **Storico ordini** (ordini, posizioni classificate `basket`/`orfana-bot`/`esterna`/`movimento di cassa`, profitti per periodo con curva dell'equity, CSV); Log; Impostazioni con configurazione validata, chiavi, ripristino in cinque passi, Ricerca (stato dell'apprendimento e ciclo a richiesta), Diagnostica (percorsi, quote, bonifica), Informazioni (versione, data di build, commit). SSE `/api/stream` a uno snapshot al secondo; token `ENCELADO_WEB_TOKEN` in cookie HttpOnly; senza token solo localhost. Tema scuro e chiaro. Regole in `docs/UI_GUIDELINES.md`, screenshot in `docs/img/`.
- **Docker e Unraid** (ADR-0008): `Dockerfile` multi-stage con i test nello stadio di build, `entrypoint.sh` con TZ e PUID/PGID, `docker-compose.yml`, `HEALTHCHECK` via `--health`; template `deploy/unraid/encelado.xml` con l'icona servita da Gitea (D-29); catena di rilascio senza Inno Setup: `Pubblica` framework-dependent, `Docker`, `Pacchetto` (zip + template + tag), `Rilascia` con push dell'immagine sul registro di Gitea. VS Code: F5 sul server (browser aperto da solo), modalità campione `--sample`, attività Docker.
- **Strumento**: comando `learn` (ciclo di apprendimento in ombra su un ledger esportato).
- **Pulizia**: rimossi WPF, DPAPI, i test di rendering e di binding, ~45 membri mai usati nel Core e nell'Engine (statistiche di ricerca, `Psi`, `EmptyContextProvider`, `EnvironmentKeyStore`, display helper dello snapshot, `INotifyPropertyChanged`), `build/Encelado.iss`. `PROMPT.md` → `docs/PROMPT_5.0.md`.
- **Documenti**: ADR-0007, ADR-0008, `docs/DOCKER.md`, `docs/UI_GUIDELINES.md`, `README.md`, `CLAUDE.md`, ARCHITECTURE, RUNBOOK, KNOWN_ISSUES, GLOSSARY, DATA_SOURCES, ML_AND_LEARNING, QUESTIONS (D-28, D-29, D-36, D-37), POSTMORTEM (gli accrediti del demo erano uno per ordine ridotto), skill, `build/README.md`.
- **Avvio in locale**: sandbox `deploy/local/` con la stessa disposizione del container (`ENCELADO_DATA_DIR` vale anche fuori dal container), F5 in VS Code sulla sandbox, script `scripts/run-dev`, `run-docker`, `screenshots` (`.ps1` e `.sh`), attività di VS Code per avviare, fermare e fotografare. Arresto pulito su SIGTERM (`PosixSignalRegistration`) verificato con `docker stop`; `/api/health` in `--sample` non finge un motore acceso.
- Test nuovi: `EmbeddedUiTests`, `WebHostTests` (token, cookie, stream, storico), `HistoryBuilderTests`, `KeyStoreTests`; 210 verdi, anche su Linux dentro `docker build`. Versione di sviluppo 5.0.0.
## 2026-09-23 — 5.0, apprendimento in ombra (ADR-0006) e skill di progetto
- Sezione `learning` in `strategy.json` (`enabled`, `weeklyCycle`, `challenger`, tutti `false` di fabbrica): il ciclo settimanale e il challenger non girano nel bot, il cancello ML non può attivarsi, la logistica resta in ombra con `p_ML` nel ledger, il bandit propone e basta. Criterio di riattivazione in `docs/ML_AND_LEARNING.md`.
- Skill di progetto in `.claude/skills/`: `encelado-start`, `encelado-verify`, `encelado-diagnose`, `encelado-docs`, `encelado-release`, `encelado-ui`.
- `CLAUDE.md` aggiornato (esecuzione 5.0, `--bonifica`, variabili Telegram, skill); glossario e problemi noti aggiornati.
- Catena di verifica (`build/Release.proj -t:Verifica`) verde.
## 2026-09-23 — 5.0, Fase 5: notifiche e comandi Telegram
- `TelegramNotifier` nel Core (solo `HttpClient`): coda non bloccante, un messaggio al secondo, tre tentativi con backoff e `retry_after`, spezzatura a 4096 caratteri, long polling `getUpdates` da un solo task, comandi accettati solo dalla chat autorizzata.
- Sezione `notifications.telegram` in `encelado.json` e in Impostazioni → Notifiche; token da `TELEGRAM_BOT_TOKEN`, chat da `TELEGRAM_CHAT_ID`.
- Stato ogni ora, riepilogo giornaliero, eventi (avvio/arresto, basket aperto/chiuso, gamba in attesa, ordine risolto, unwind, orfana, kill-switch, equity stop, perdita giornaliera, margin guard, recupero, reset, preset, API in errore, scarto orologio).
- Comandi `/stato`, `/posizioni`, `/storico Nd`, `/pausa`, `/riprendi`, `/chiudi`, `/kill CONFERMO`, `/reset`; comandi `Pause`, `Resume`, `History` nel motore; ogni comando eseguito (finestra, console, Telegram) scrive una riga `comando` nel ledger.
- Test (s), (t), (u) e altri: 219 verdi.
## 2026-09-23 — 5.0, Fase 4: recupero dopo inattività, heartbeat, lock di istanza
- `data/state/heartbeat.json` ogni 30 s (all'avvio e all'arresto con nota); all'avvio e a ogni ciclo l'inattività oltre `recovery.thresholdMinutes` (10) fa partire il recupero.
- Recupero: entrate bloccate, ordini senza esito risolti, riconciliazione, riscaldamento con le barre perse e `barsHeld` aggiornato, ogni basket aperto rivalutato con le regole di uscita ordinarie (chiudi/tieni), orfane chiuse, esterne riportate, `reports/recupero_<run_id>.csv`, righe `recupero_avviato`/`recupero_concluso`, notifica, entrate riaperte dopo `recovery.warmupMinutes` (15). A mercato chiuso aspetta le quotazioni.
- Sezione `recovery` in `strategy.json`; il reset usa lo stesso riscaldamento.
- `data/state/instance.lock` tenuto in esclusiva: un secondo bot sulla stessa cartella dati non parte (problema noto dalla 4.0.0, chiuso).
- `RecoveryPlanner`, `HeartbeatFile`, `InstanceLock` nel Core; test (r) e altri sei: 211 verdi.
## 2026-09-23 — 5.0, Fase 3: kill-switch che chiude davvero, ripristino in cinque passi
- `FlattenProcedure` nel Core: annullamento degli ordini senza esito (con attesa della risoluzione), chiusura delle posizioni, verifica di piattezza sul conto; stato `Halted` o `Halted-Residuo`.
- Il kill-switch (pulsante, `kill`, file `STOP`) chiude basket, gambe in attesa e orfane; le posizioni esterne solo su richiesta esplicita o con `risk.closeForeignOnKill`; niente è dichiarato chiuso senza la rilettura del conto; i residui finiscono nel banner, nello stato salvato e nel ledger (`kill_switch_concluso`).
- Comando `CloseResidue` (`residuo` da console, «chiudi ora» dalla finestra) per riprovare sui residui.
- Reset in cinque passi (stato, file `STOP`, motivazione, riconciliazione + riscaldamento + picco, ripartenza con 15 minuti di entrate bloccate); rifiutato con `reset_rifiutato` finché una posizione del bot resta sul conto.
- `INotifier` e `NullNotifier`: il motore notifica kill-switch e reset; il canale Telegram arriva con la Fase 5.
- Test (v), (w), (x): 204 verdi.
## 2026-09-23 — 5.0, Fase 2: il margine come vincolo di primo livello
- Sezione `risk` in `strategy.json` (`maxMarginUsePct` 40, `maxMarginPerBasketPct` 12, `marginBufferPct` 25, `closeForeignOnKill` false, `marginCallBlockRatio` 1,5, `marginCallCloseRatio` 1,2), letta, validata e nell'hash della configurazione.
- Sizing = min(rischio, margine): `VolParitySizing` riceve il margine massimo e le leve delle gambe, dice quale vincolo ha deciso (`sizing_bound`) e quanto margine impegna (`marginUsd`), entrambi nel ledger; sotto l'esposizione minima l'ingresso è rifiutato con `min_exposure`.
- Il decisore calcola il margine disponibile per un basket (per basket, totale, disponibile / buffer) e blocca con `margin` o `margin_guard`.
- L'esecutore rilegge il conto prima della gamba B e, se il disponibile non copre `marginB × 1,25`, non la manda e richiude A.
- I segnali della stessa barra vengono eseguiti per |z| decrescente, rileggendo il conto e ridecidendo prima di ciascuno.
- Margin guard alla riconciliazione: sotto 1,5 entrate bloccate, sotto 1,2 chiusura del basket con il P&L peggiore.
- Il backtest passa al decisore disponibile, margine usato e leve del simulatore: applica gli stessi limiti.
- Test (y), (z) e altri quattro: 196 verdi.
## 2026-09-23 — 5.0, Fasi 0-1: post-mortem degli ordini pendenti, registro degli ordini, orfane adottate
- **Diagnosi verificata** sul codice e sul conto demo via API: il lookup per `referenceId` fallisce perché il server registra un riferimento nullo per gli ordini v2; 21 gambe singole del bot fra il 16 e il 21/9, chiuse a mano il 21/9; i primi due ordini hanno impegnato tutta l'equity come margine e da lì il server ha ridotto ogni ordine a 2 000 USD di margine. `docs/PIANO_5.0.md`, `docs/POSTMORTEM_ordini_pendenti.md`, domande D-26…D-37.
- **Registro persistente degli ordini** (`OrderTracker`, `data/state/pending_orders.json`, `orders.jsonl`): scritto prima di ogni invio, risolto per `orderId`, per riferimento e per posizione comparsa; ricaricato all'avvio e risolto prima di ogni decisione. Nessun esito inventato: `Unknown` resta pendente (ADR-0009).
- **Stati `PendingA`/`PendingB`**: una gamba senza esito non è più un rifiuto; alla risoluzione parte la gamba B (ridimensionata sulle unità eseguite di A) oppure la gamba A viene richiusa se il segnale è decaduto.
- **Classificazione delle posizioni** (`basket` / `orfana-bot` / `esterna`) a ogni riconciliazione; le orfane del bot vengono adottate e chiuse; contatori «in attesa · orfane · esterne» e P&L aperto **del conto** in dashboard; avviso «posizioni non riconciliate».
- **Movimenti di cassa** riconosciuti e scritti nel ledger; picco di equity e drawdown al netto (`EquityTracker`).
- **Bonifica** (`--headless --bonifica`, comando `bonifica`): elenco delle orfane con conferma per posizione, rapporto in `reports/bonifica_YYYYMMDD.csv`.
- `IBroker.LookupOrderByIdAsync` e `CancelOrderAsync`; `EtoroBroker.OpenAsync` legge l'esito per `orderId` e riconosce l'esecuzione dalla posizione; parser dell'esito v2 e v1.
- Il bandit **propone e non applica** più il preset (D-30).
- `BasketEngine` spezzato in sei file parziali.
- Test nuovi (m)-(q) e altri 13: 190 test verdi.
## 2026-09-16 (pomeriggio) — 4.0.0: solo Correlation Baskets su eToro, bot autonomo, interfaccia nuova
- **Rimossi** i motori precedenti: Binance, Alpaca, cTrader/proba, SQLite, GBDT, RL, TA-Lib, indicatori, backtest a coppie, pagine e test relativi (ADR-0004). Nessun pacchetto NuGet nell'applicazione.
- **Modalità** ridotte a `Paper`, `Demo` (default), `Live`: nessuna approvazione manuale dei singoli ordini (decisione dell'utente, ADR-0005). I nomi precedenti vengono letti con un avviso.
- **Interfaccia** rifatta: barra in alto con tre schede, stato, ambiente, ora e AVVIA; dashboard con equity, P&L di oggi, P&L aperto, drawdown, basket aperti, tabella dei basket, contesto e attività. Tema nuovo. Test di rendering in PNG.
- **Fuso orario** della finestra selezionabile (`ui.timeZone`); il log porta l'offset, il ledger resta UTC.
- **Corretto** il parser dei costi di eToro (campo `value`): markup e overnight non erano letti.
- **Apprendimento** collegato al motore: modello in ombra, challenger, bandit, previsione di volatilità, ciclo settimanale, `knowledge/`. Standardizzatore dell'MLP adattato all'insieme di addestramento.
- **Backtest**: test di falsificazione 5 (segnale invertito), scenario di costi `api`, `docs/STRATEGY.md` con il verdetto negativo e i numeri.
- Feed: dopo due errori consecutivi una fonte logga solo a debug e ritenta con attese crescenti.
- Documenti nuovi: `STRATEGY.md`, `ML_AND_LEARNING.md`, `RUNBOOK.md`, `GLOSSARY.md`, `KNOWN_ISSUES.md`, ADR-0004, ADR-0005. Catena di rilascio aggiornata ai tre comandi dello strumento.
- Versione 4.0.0.
## 2026-09-16 (mattina) — Correlation Baskets su eToro, Fasi 0-7
- Ricognizione del repository; verifica dell'API eToro (rotte, quote, schemi, limiti), degli strumenti, della valuta del conto, dei feed, del formato dei tick.
- Broker eToro (`Encelado.Etoro`), `PaperBroker`, chiavi DPAPI, `--headless`; cross sintetici, indicatori, decisore, cost gate, sizing, esecutore con protocollo leg-risk, backtest event-driven e griglia con PSR/DSR/PBO/walk-forward; calendario, RSS, sentiment, ledger; livelli di apprendimento 0-3 nel Core.
- Documenti: `CLAUDE.md`, `docs/ARCHITECTURE.md`, `docs/QUESTIONS.md`, `docs/STATE.md`, `DATA_SOURCES.md`, `LEDGER_SCHEMA.md`, `RISK_RULES.md`, ADR-0001 (eToro), ADR-0002 (storage su file), ADR-0003 (motore cTrader mantenuto selezionabile; superata da ADR-0004).
+99
View File
@@ -0,0 +1,99 @@
# Encelado — guida per chi lavora sul repository (umano o AI)
**Leggi prima `docs/STATE.md`.** È la memoria di lavoro fra una sessione e l'altra: dice a che fase siamo, cosa è stato fatto per ultimo e cosa manca.
## Scopo
Bot di trading in C# (.NET 10) su **eToro** con la strategia "Correlation Baskets": cinque basket di due coppie forex correlate, ingresso quando il cross sintetico diverge (z-score), uscita quando converge o al take-profit di basket, stop di basket obbligatorio, cost gate sullo spread reale, ledger completo, feed gratuiti di calendario e notizie, livelli di apprendimento 0-3 costruiti da zero. È l'unica strategia del repository: i motori precedenti (Binance, cTrader/proba, ricerca) sono stati rimossi il 2026-09-16 (ADR-0004) e vivono solo nella storia git. Il bot opera da solo in ogni modalità (ADR-0005): `Demo` (default) e `Live`; dalla 5.1 la modalità è anche il conto e `Paper` non esiste più (ADR-0010). Dalla 5.0 gira **solo in un container** (ADR-0007, ADR-0008): un processo `Encelado.Server` che ospita il motore e serve l'interfaccia web; la finestra WPF non esiste più. Dalla 5.1 **tutto si imposta dall'interfaccia** e il container ha una sola variabile, la password (ADR-0010).
## Mappa dei documenti
| File | Contenuto |
|---|---|
| `docs/STATE.md` | stato corrente, fase, ultima sessione, prossimi passi, problemi aperti |
| `docs/ARCHITECTURE.md` | progetti, flusso dati, macchine a stati, interfacce, viste pubblicate e ciclo di vita, impostazioni e segreti, stato per conto, apprendimento |
| `docs/API.md` | il contratto dell'API web fra server e interfaccia: tick, sezioni, comandi, impostazioni, segreti, accesso; i nomi dei campi valgono lì |
| `docs/STRATEGY.md` | logica dei basket, cross sintetici, formule, preset, aspettative oneste, numeri |
| `docs/ML_AND_LEARNING.md` | livelli 0-3, feature, label, ciclo in background, pagina Apprendimento, attivazione, esclusioni, comando `learn` |
| `docs/DATA_SOURCES.md` | ogni fonte (URL, formato, limiti), storico eToro come P&L di record, schema dei file in `/config` e `/data` |
| `docs/LEDGER_SCHEMA.md` | schema di `decisions.jsonl`, `orders.jsonl`, `baskets.csv`, correzioni, stato per conto, `pending_orders.json`, `data/models`, `trials.csv`, `calibration.csv`, `preregistrazione.csv`, `proposals.csv` |
| `docs/RISK_RULES.md` | regole di sicurezza con i default e chi può cambiarle |
| `docs/RUNBOOK.md` | avvio, aggiornamento dalla 5.0, arresto, kill-switch, reset, cambio di conto, segreti, riconciliazione, errori API, checklist |
| `docs/DOCKER.md`, `deploy/unraid/README.md` | immagine, volumi, la sola variabile, rete, healthcheck, aggiornamento; template Unraid e guida all'aggiornamento 5.0 → 5.1 |
| `docs/UI_GUIDELINES.md` | l'interfaccia web in stile Mimante: token, componenti, pagine, flusso dei dati, prestazioni, screenshot |
| `docs/QUESTIONS.md` | domande poste per fase, risposte o default applicati, con data (5.1: D-38…D-58, in attesa di conferma) |
| `docs/PIANO_5.0.md`, `docs/PROMPT_5.0.md`, `docs/POSTMORTEM_ordini_pendenti.md` | il piano della 5.0 (fasi, stime, decisioni vincolanti), la specifica originale e il post-mortem delle gambe orfane del 16-21/9/2026 |
| `docs/GLOSSARY.md`, `docs/KNOWN_ISSUES.md`, `CHANGELOG.md`, `docs/adr/` | glossario, problemi noti, cronologia, decisioni architetturali (ADR-0001…ADR-0014) |
| `build/README.md` | catena di verifica, pacchetto (immagine Docker) e rilascio; `.gitea/workflows/` per le Actions |
## Progetti
```
src/Encelado.Core logica pura, zero I/O, AOT/trim-compatibile
src/Encelado.Etoro client HTTP di eToro Public API
src/Encelado.Engine motore, ledger, feed, configurazione, segreti, impostazioni, storico, Telegram (ex Encelado.Bot senza UI)
src/Encelado.Server l'eseguibile: Kestrel, API JSON scritta a mano, SSE, UI incorporata (Web/wwwroot: moduli ES vanilla)
tools/Encelado.Backtest ticks, baskets, falsify, learn
tests/Encelado.Tests xunit
deploy/docker, deploy/unraid entrypoint del container, template Unraid
```
## Convenzioni
- **C#**, `Nullable` e `TreatWarningsAsErrors` attivi. Identificatori e commenti tecnici in inglese; documentazione, report, testi dell'interfaccia e colonna `motivazione` in italiano.
- **Nessun pacchetto NuGet.** Solo BCL e i framework reference dell'SDK (`Microsoft.AspNetCore.App` nel Server) nei progetti dell'applicazione; xunit nei test. Nessuna libreria JavaScript o CSS: l'interfaccia è HTML, CSS e JS vanilla incorporati.
- **Tabelle**: CSV con separatore `;`, header, ultima colonna `motivazione`; JSONL append-only per ledger e notizie; JSON per modelli e stato. Scritture atomiche (`.tmp` con nome unico + `File.Move`, `AtomicFile`), rotazione mensile. **Nessuna riga del ledger viene mai modificata**: le correzioni sono righe nuove con `evento = correzione`.
- **Tempo**: UTC ovunque; conversione solo in UI. `CultureInfo.InvariantCulture` per ogni parsing e formattazione su file.
- **Concorrenza**: un solo thread di decisione; I/O asincrono; `Channel<T>` fra ingestion, strategia, esecuzione e UI. Il motore pubblica viste immutabili (`EngineView`) e il web legge solo quelle; tutto ciò che cambia il motore è un comando eseguito sul suo thread; avvio, arresto e riavvii passano da un solo lucchetto del supervisore (ADR-0012).
- **Riproducibilità**: seed fisso 42 per ogni componente stocastica; ogni run scrive `run_id`, hash della configurazione e versione del codice nel ledger.
- **Cartelle a runtime**: nel container `/config` (encelado.json, strategy.json, instruments.json, `secrets.enc`, `import-5.1.json`, file `STOP`) e `/data` (`data/`, `knowledge/`, `reports/`, `results/`, `logs/`); fuori dal container (solo sviluppo) la sandbox `deploy/local/` (`ENCELADO_CONFIG_DIR` + `ENCELADO_DATA_DIR`, usata da F5 e dagli script) o, senza variabili, `Documenti\Encelado\`.
- **Configurazione e segreti (5.1, ADR-0010)**: ogni impostazione si cambia da Impostazioni nell'interfaccia e il bot la applica subito (nel processo, nel motore sul suo thread, o con un riavvio automatico del motore che non chiude niente). L'unica variabile del container è `ENCELADO_PASSWORD` (alias deprecato `ENCELADO_WEB_TOKEN`): apre l'interfaccia e cifra i segreti. Chiavi eToro dei due conti e token Telegram solo in `/config/secrets.enc` (AES-256-GCM, chiave PBKDF2 dalla password), inseriti e verificati da Impostazioni; mai nell'ambiente, nel log o in `encelado.json`. Le variabili della 5.0 vengono importate una volta al primo avvio e poi ignorate. Il caricatore non legge l'ambiente.
- **Modalità (5.1)**: `Demo` (conto demo) o `Live` (conto reale); `Paper` è stata eliminata. Il preset è fisso in `strategy.json` (Impostazioni ▸ Strategia) e vale per i basket nuovi.
- **Esecuzione (5.0)**: ogni ordine entra nel registro `data/state/pending_orders.json` prima dell'HTTP e l'esito si legge per `orderId` (il server non registra il `referenceId`); una gamba senza esito porta il basket in `PendingA`/`PendingB`, mai in un rifiuto; ogni posizione del conto è `basket`, `orfana-bot` (adottata e chiusa) o `esterna` (mai toccata, salvo scelta esplicita nel kill-switch); la size è il minimo fra rischio e margine (`strategy.json` → `risk`); il kill-switch verifica la piattezza sul conto e dichiara `Halted-Residuo` se resta qualcosa; heartbeat e recupero dopo inattività (`recovery`); un solo scrittore per cartella dati (`instance.lock`).
- **Soldi e stato (5.1)**: il realizzato di ogni posizione è quello dello storico eToro (`netProfit − fees`), mai i `proceeds` della chiusura (ADR-0011); una posizione finisce in `baskets.csv` una volta sola; la perdita giornaliera, raggiunta, blocca le entrate fino alle 00:00 UTC (D-52); lo stato del motore è **per conto** (`baskets_state.demo.json`, `baskets_state.live.json`, D-53) e il cambio Demo ↔ Live lo decide il motore, rifiutandolo finché il conto non è piatto.
- **Interfaccia (5.1, ADR-0013)**: stile Mimante. Menu a sinistra con nove pagine (Dashboard, Basket, Posizioni, Mercato, Storico, Apprendimento, Log, Sistema, Impostazioni), barra in alto (logo, pill del motore con il conto, pill eToro, numeri, orologi delle valute con le bandiere, allarme, KILL, tema, accensione), striscia degli allarmi sotto; niente selettore della valuta in barra. Nella dashboard tutto in una schermata; i dettagli nelle pagine e nei tooltip. La UI non decide niente: legge il tick v2 via SSE e le sezioni a richiesta con `ETag`, manda comandi via `POST /api/commands/<nome>` e impostazioni via `POST /api/settings`, sempre con `Content-Type: application/json`. Le parole del ledger passano da `js/labels.js` (italiano a schermo, codice nel tooltip). Gli orari a schermo sono nel fuso del browser; il log porta l'offset, il ledger è UTC. Regole complete in `docs/UI_GUIDELINES.md`, contratto dei dati in `docs/API.md`.
- **Verifica visiva**: `scripts\screenshots.ps1` (server `--sample` + Edge headless, `docs/UI_GUIDELINES.md`); i test `EmbeddedUiTests` e `WebHostTests` coprono HTML, moduli e `import`, file serviti, password e stream. I moduli toccati si controllano anche con `node --check` su una copia `.mjs`.
## Comandi
```powershell
dotnet build Encelado.slnx # compilazione
dotnet test tests/Encelado.Tests --no-restore # test (xunit)
dotnet msbuild build/Release.proj -t:Verifica # compilazione + test nella cartella di verifica
dotnet run --project src/Encelado.Server -- [--no-autostart] [--sample] [--port 8080] [--minutes 240] [--bonifica] [--listen-all] # server locale; comandi da tastiera: status, close, kill, residuo, reset, bonifica, stop
scripts\run-dev.ps1 [-Sample] [-Autostart] # server locale nella sandbox deploy/local, password "sviluppo", solo localhost (= F5 in VS Code); .sh per Git Bash
scripts\run-docker.ps1 [-Down] # il container dalla compose, stessa sandbox, password "sviluppo"
scripts\screenshots.ps1 # docs/img dal server campione
dotnet run --project tools/Encelado.Backtest -- ticks --data "A:\Download\Trading" --out "%USERPROFILE%\Documents\Encelado\data\market"
dotnet run --project tools/Encelado.Backtest -- baskets --data "%USERPROFILE%\Documents\Encelado\data\market" --out results
dotnet run --project tools/Encelado.Backtest -- falsify --data "%USERPROFILE%\Documents\Encelado\data\market" --out reports [--costs api]
dotnet run --project tools/Encelado.Backtest -- learn --data "%USERPROFILE%\Documents\Encelado\data" [--knowledge …] [--strategy config/strategy.json] # prende il lock della cartella dati o si rifiuta
dotnet msbuild build/Release.proj -t:Docker # immagine 192.168.30.23:3000/alby96/encelado:<v> (test dentro la build)
dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=5.1.0 # zip + immagine + tag + push dell'immagine + release su Gitea (dopo il commit e il push del ramo)
docker compose up --build # il container in locale (deploy/local/, password in .env o "sviluppo")
```
`--sample` lavora in cartelle temporanee, non tocca configurazione, segreti, dati né Telegram, e rifiuta ogni comando o salvataggio. `--listen-all` apre la rete fuori dal container (con la password); nel container la rete è aperta di suo.
## Regole
1. **Chiedi se hai un dubbio.** Le domande vanno in `docs/QUESTIONS.md`, numerate, con il default che applicheresti; in assenza di risposta applica il default più prudente e annotalo.
2. **Mai un ordine reale senza flag e conferma.** `run.executionMode` predefinito `Demo`; `Live` (il conto reale) richiede `run.allowLive = true` **e** la frase `CONFERMO LIVE` scritta nell'interfaccia a ogni avvio (dialogo di AVVIA) e prima di ogni cambio che riavvia il motore in Live. Il Live non parte mai da solo, né all'avvio del container né dopo un riavvio automatico. Nessuna approvazione per singolo ordine (D-20): il bot opera da solo.
3. **Mai una riga del ledger modificata.**
4. **Mai un risultato abbellito.** Se la strategia non regge i costi di eToro, il report lo dice con i numeri. "Nessuna configurazione profittevole" è un esito ammesso.
5. **Non toccare la catena di rilascio** (`build/`) se non richiesto; è condivisa con Mimante/AutoBidder.
6. **Un commit a fine sessione**, dopo che la verifica passa, con un messaggio che dice cosa cambia e perché. Il push lo decide l'utente.
7. Aggiorna `docs/STATE.md` e `CHANGELOG.md` a fine sessione; un ADR per ogni scelta non ovvia; `docs/API.md` nello stesso commit di ogni campo cambiato.
8. Le skill di progetto in `.claude/skills/` (`encelado-start`, `encelado-verify`, `encelado-diagnose`, `encelado-docs`, `encelado-release`, `encelado-ui`) dicono come si comincia, si verifica, si diagnostica, si chiude e si rilascia: usale.
## Cose da non fare
- Non scrivere chiavi, token o password in chat, nel log, nel repo, in `Documenti` o nel template Unraid.
- Non reintrodurre variabili d'ambiente per le impostazioni: tutto passa da Impostazioni e da `secrets.enc` (ADR-0010).
- Non usare spread fissi nel cost gate: sempre lo spread reale letto dall'API in quel momento più il markup dell'endpoint dei costi.
- Non usare i `proceeds` di una chiusura come P&L: il realizzato viene solo dallo storico eToro (ADR-0011).
- Non ricostruire feature a posteriori: il dataset di addestramento è il ledger scritto al momento della decisione.
- Non cambiare parametri live in automatico: le proposte passano da `knowledge/proposals.csv` e dal forward test.
- Non chiamare metodi del motore da un altro thread né leggere il suo stato dal web: comandi sul thread di decisione e viste pubblicate (ADR-0012).
- Non reintrodurre un'interfaccia desktop né librerie JavaScript: l'interfaccia è servita dal bot ed è vanilla (ADR-0007, ADR-0013).
- Non usare heredoc lunghi o con backslash nel Bash tool: usare `Write`/`Edit` (vedi memoria `strumenti-heredoc-backslash`).
+6 -6
View File
@@ -13,12 +13,12 @@
<GenerateDocumentationFile>false</GenerateDocumentationFile>
<Product>Encelado</Product>
<Company>Encelado</Company>
<!-- Numero delle compilazioni di sviluppo: è quello che compare nella finestra
mentre si lavora. La versione RILASCIATA viene dal tag git — vedi
build/Release.proj — e questo serve solo da seme quando non esiste ancora
nessun tag. Tenerlo allineato all'ultimo rilascio evita di leggere in
finestra un numero che non corrisponde a niente. -->
<Version>3.5.0</Version>
<!-- Numero delle compilazioni di sviluppo: è quello che compare in
Impostazioni ▸ Informazioni mentre si lavora. La versione RILASCIATA viene
dal tag git — vedi build/Release.proj — e questo serve solo da seme quando
non esiste ancora nessun tag. Tenerlo allineato all'ultimo rilascio evita
di leggere a schermo un numero che non corrisponde a niente. -->
<Version>5.1.0</Version>
</PropertyGroup>
<!--
+93
View File
@@ -0,0 +1,93 @@
# syntax=docker/dockerfile:1.7
#
# Encelado — immagine del bot (motore + interfaccia web su Kestrel).
#
# Tre stadi: build (restore + compilazione), test (la suite xunit gira dentro la
# build: un'immagine con i test rossi non esiste), publish (framework-dependent,
# non trimmed: il server ospita ASP.NET Core minimal e non è AOT). Il runtime è
# l'immagine ufficiale aspnet, con gosu per scendere ai PUID/PGID di Unraid.
#
# docker build -t 192.168.30.23:3000/alby96/encelado:5.1.0 --build-arg GIT_COMMIT=$(git rev-parse --short=12 HEAD) .
# docker run -p 8080:8080 -v ./config:/config -v ./data:/data -e ENCELADO_PASSWORD=… 192.168.30.23:3000/alby96/encelado:5.1.0
#
# L'unica variabile da dare al container è ENCELADO_PASSWORD (la password
# dell'interfaccia): tutto il resto si imposta dall'interfaccia. Le ENV qui sotto sono
# interne all'immagine (PUID/PGID/TZ restano i default di Unraid e UTC).
#
# Vedi docs/DOCKER.md per volumi, variabili, healthcheck e aggiornamento.
ARG DOTNET_VERSION=10.0
# ---------------------------------------------------------------- build
FROM mcr.microsoft.com/dotnet/sdk:${DOTNET_VERSION} AS build
ARG GIT_COMMIT=n/d
WORKDIR /src
# Prima i file di progetto, così il restore resta in cache finché non cambiano.
COPY Directory.Build.props Encelado.slnx ./
COPY src/Encelado.Core/Encelado.Core.csproj src/Encelado.Core/
COPY src/Encelado.Etoro/Encelado.Etoro.csproj src/Encelado.Etoro/
COPY src/Encelado.Engine/Encelado.Engine.csproj src/Encelado.Engine/
COPY src/Encelado.Server/Encelado.Server.csproj src/Encelado.Server/
COPY tools/Encelado.Backtest/Encelado.Backtest.csproj tools/Encelado.Backtest/
COPY tests/Encelado.Tests/Encelado.Tests.csproj tests/Encelado.Tests/
RUN dotnet restore Encelado.slnx
COPY . .
RUN dotnet build Encelado.slnx -c Release --no-restore -p:GitCommit=${GIT_COMMIT}
# ---------------------------------------------------------------- test
FROM build AS test
RUN dotnet test tests/Encelado.Tests -c Release --no-build --nologo -v q
# ---------------------------------------------------------------- publish
FROM build AS publish
ARG GIT_COMMIT=n/d
# Dipende dallo stadio test solo per ordine: la publish parte se i test sono verdi.
COPY --from=test /src/tests/Encelado.Tests/bin/Release/net10.0/Encelado.Tests.dll /tmp/tests-ok
RUN dotnet publish src/Encelado.Server/Encelado.Server.csproj -c Release --no-build --no-restore -p:GitCommit=${GIT_COMMIT} -o /app
# ---------------------------------------------------------------- runtime
FROM mcr.microsoft.com/dotnet/aspnet:${DOTNET_VERSION} AS runtime
ARG VERSION=dev
ARG GIT_COMMIT=n/d
LABEL org.opencontainers.image.title="Encelado" \
org.opencontainers.image.description="Correlation Baskets su eToro: motore, ledger e interfaccia web" \
org.opencontainers.image.version="${VERSION}" \
org.opencontainers.image.revision="${GIT_COMMIT}" \
org.opencontainers.image.authors="Alberto Balbo" \
org.opencontainers.image.source="http://192.168.30.23:3000/Alby96/Encelado"
# gosu per cambiare utente dopo aver sistemato i permessi; tzdata per TZ; curl
# non serve: il healthcheck è il server stesso con --health.
RUN apt-get update \
&& apt-get install -y --no-install-recommends gosu tzdata ca-certificates \
&& rm -rf /var/lib/apt/lists/*
ENV ENCELADO_IN_CONTAINER=1 \
ENCELADO_WEB_PORT=8080 \
DOTNET_gcServer=1 \
DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1 \
ASPNETCORE_URLS= \
ASPNETCORE_HTTP_PORTS= \
TZ=UTC \
PUID=99 \
PGID=100
WORKDIR /app
COPY --from=publish /app ./
COPY deploy/docker/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh && mkdir -p /config /data
VOLUME ["/config", "/data"]
EXPOSE 8080
# Il server risponde da solo alla sonda: GET /api/health sulla porta configurata.
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
CMD ["dotnet", "/app/Encelado.Server.dll", "--health"]
# SIGTERM arriva al processo dotnet (exec nell'entrypoint): stop pulito, ledger
# chiuso, posizioni lasciate sul conto con gli stop nativi (closeOnShutdown).
STOPSIGNAL SIGTERM
ENTRYPOINT ["/entrypoint.sh"]
CMD ["dotnet", "/app/Encelado.Server.dll"]
+3 -2
View File
@@ -1,8 +1,9 @@
<Solution>
<Folder Name="/src/">
<Project Path="src/Encelado.Alpaca/Encelado.Alpaca.csproj" />
<Project Path="src/Encelado.Bot/Encelado.Bot.csproj" />
<Project Path="src/Encelado.Engine/Encelado.Engine.csproj" />
<Project Path="src/Encelado.Server/Encelado.Server.csproj" />
<Project Path="src/Encelado.Core/Encelado.Core.csproj" />
<Project Path="src/Encelado.Etoro/Encelado.Etoro.csproj" />
</Folder>
<Folder Name="/tests/">
<Project Path="tests/Encelado.Tests/Encelado.Tests.csproj" />
+1 -1
View File
@@ -1,2 +1,2 @@
Altre cose da fare:
Ottimo! Ora effettua le seguenti modifiche:
-
+84
View File
@@ -0,0 +1,84 @@
# Encelado
Bot di trading **Correlation Baskets** su eToro (Public API): cinque basket di due coppie forex correlate, ingresso quando il cross sintetico diverge (z-score), uscita quando converge o al take-profit di basket, stop di basket obbligatorio, cost gate sullo spread reale, ledger completo, calendario e notizie gratuiti, apprendimento in ombra. Gira **solo in un container** e si guarda e si configura dal browser. Versione 5.1.0.
> Il backtest è negativo: la strategia non regge i costi di eToro (`docs/STRATEGY.md`). Il bot è uno strumento di forward test in Demo, non un sistema da mettere sul reale.
![Dashboard](docs/img/dashboard.png)
## Avvio rapido (Docker)
```powershell
docker pull 192.168.30.23:3000/alby96/encelado:latest
docker run -d --name encelado --restart unless-stopped --stop-timeout 45 -p 8080:8080 `
-v /mnt/user/appdata/encelado/config:/config -v /mnt/user/appdata/encelado/data:/data `
-e ENCELADO_PASSWORD=<una-frase-lunga> `
192.168.30.23:3000/alby96/encelado:latest
```
L'unica cosa da dare al container è la **password dell'interfaccia** (`ENCELADO_PASSWORD`). Poi:
1. apri `http://<ip>:8080/` e scrivi la password;
2. **Impostazioni ▸ Conto**: incolla le chiavi eToro del conto demo (`x-api-key`, `x-user-key`) e premi **Verifica e salva** — vengono provate su eToro e salvate cifrate con la password in `/config/secrets.enc`; lì si sceglie anche il conto (Demo o Live) e si inseriscono le chiavi del reale;
3. se vuoi Telegram, **Impostazioni ▸ Notifiche Telegram** (token, chat, messaggio di prova);
4. **AVVIA** (⏻ in alto a destra).
Ogni impostazione si cambia dalla pagina e il bot la applica subito, riavviando il motore da sé (senza chiudere i basket) solo quando serve. Il conto reale (`Live`) chiede «Consenti il conto reale» e la frase `CONFERMO LIVE` scritta a ogni avvio, e non parte mai da solo. Senza password il server ascolta solo su localhost del container. Su Unraid: template in `deploy/unraid/` (porta, volumi e password), con la guida all'installazione e all'aggiornamento da un container 5.0 (che ha più variabili: vengono importate una volta e poi si tolgono). Tutto il resto in `docs/DOCKER.md` e `docs/RUNBOOK.md`.
## Le pagine
La dashboard riassume tutto in una schermata; ogni altra pagina approfondisce una parte (regole e componenti in `docs/UI_GUIDELINES.md`, dati in `docs/API.md`).
| | |
|---|---|
| ![Basket](docs/img/basket.png) | ![Posizioni](docs/img/posizioni.png) |
| **Basket**: i cinque basket con ogni numero, il grafico dello z e il pannello di dettaglio (stato e soglie, posizione, segnale, contesto, ML, ultime decisioni). | **Posizioni**: ogni posizione del conto classificata `basket` / `orfana-bot` / `esterna`, bonifica delle orfane, ordini in attesa di esito. |
| ![Mercato](docs/img/mercato.png) | ![Storico](docs/img/storico.png) |
| **Mercato**: quotazioni e spread, calendario con filtri, sentiment per valuta, notizie, cambi, volatilità. | **Storico**: ordini, posizioni, profitti per periodo con la curva del realizzato, esportazione CSV. |
| ![Apprendimento](docs/img/apprendimento.png) | ![Log](docs/img/log.png) |
| **Apprendimento**: dataset, criteri di attivazione, pesi imparati, bandit dei preset, ultimo ciclo, calibrazione, proposte. | **Log**: una riga per messaggio con il livello colorato, filtro, ricerca e «Segui». |
| ![Sistema](docs/img/sistema.png) | ![Impostazioni](docs/img/impostazioni.png) |
| **Sistema**: motore, collegamento eToro e quote, feed, Telegram, segreti, processo, disco. | **Impostazioni**: tutto si imposta da qui e il bot lo applica senza riavvio quando può; chiavi e token cifrati. |
| ![Tema chiaro](docs/img/dashboard-chiaro.png) | ![Telefono](docs/img/mobile.png) |
| Tema chiaro con gli stessi token. | Sotto i 480 px il menu si apre dal bottone ☰. |
## Provarlo in locale
Tre modi, tutti sulla stessa sandbox `deploy/local/` (ignorata da git: `config/` è il `/config` del container, `data/` il `/data`) e con la stessa password `sviluppo`, così configurazione e segreti salvati valgono ovunque:
| Modo | Come | Cosa ottieni |
|---|---|---|
| **F5 in VS Code** | configurazione `Encelado (server)` | server locale su `http://localhost:8080/` (solo localhost), browser aperto da solo, motore fermo finché non premi **AVVIA**; `Encelado (campione)` mostra le pagine con dati d'esempio, senza chiavi, in cartelle temporanee |
| **Script** | `scripts\run-dev.ps1` (`-Sample`, `-Autostart`, `-Port`) o `sh scripts/run-dev.sh` | lo stesso processo da terminale, con i comandi da tastiera (`status`, `kill`, `stop`…) |
| **Container** | `scripts\run-docker.ps1` (o `sh scripts/run-docker.sh`, o `docker compose up -d --build`) | l'immagine vera su `http://localhost:8080/`, password `sviluppo` (o `ENCELADO_PASSWORD` in `.env`); `-Down` per fermare con SIGTERM |
Le chiavi eToro si inseriscono da **Impostazioni ▸ Conto** (una scheda per il conto demo e una per il reale): vengono verificate e salvate cifrate in `deploy/local/config/secrets.enc`, leggibili da tutti e tre i modi perché la password è la stessa. Senza chiavi il motore non parte e la pagina lo dice; lo storico mostra solo il ledger. Fuori dal container il server resta su localhost anche con la password (per la rete: `--listen-all`).
```powershell
dotnet build Encelado.slnx # compilazione
dotnet test tests/Encelado.Tests --no-restore # test (xunit)
dotnet msbuild build/Release.proj -t:Verifica # compilazione + test nella cartella di verifica
dotnet msbuild build/Release.proj -t:Docker # l'immagine, con i test dentro la build
scripts\screenshots.ps1 # rigenera docs/img dal server campione
```
Attività di VS Code: `verifica`, `backtest`, `avvia in locale (script)`, `avvia in docker`, `ferma docker`, `screenshot`, `immagine docker`, `pacchetto`, `rilascia su Gitea`. Su Gitea, `.gitea/workflows/ci.yml` verifica ogni push e `release.yml` pubblica l'immagine a ogni tag (serve un runner: `docs/DOCKER.md`).
```
src/Encelado.Core logica pura: basket, cross sintetici, decisore, cost gate, sizing, esecutore, registro ordini, kill-switch, apprendimento, notifiche
src/Encelado.Etoro client HTTP di eToro Public API
src/Encelado.Engine motore, ledger, feed, configurazione, impostazioni, storico, Telegram
src/Encelado.Server l'eseguibile: Kestrel, API JSON, SSE, interfaccia incorporata (moduli ES vanilla, nessuna libreria)
tools/Encelado.Backtest ticks, baskets, falsify, learn
tests/Encelado.Tests xunit
deploy/ docker (entrypoint), unraid (template), local (ignorato: sandbox di F5 e del compose)
scripts/ run-dev, run-docker, screenshots (.ps1 e .sh)
build/ catena di verifica, pacchetto e rilascio (MSBuild)
docs/ STATE, ARCHITECTURE, API, STRATEGY, RUNBOOK, DOCKER, UI_GUIDELINES, ADR…
```
Leggi `CLAUDE.md` per le convenzioni e `docs/STATE.md` per lo stato del lavoro.
## Autore e licenza
Alberto Balbo. Uso personale; nessuna licenza di ridistribuzione. Nessuna garanzia: un bot che opera su un conto reale può perdere denaro.
File renamed without changes.

Before

Width:  |  Height:  |  Size: 364 KiB

After

Width:  |  Height:  |  Size: 364 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 22 KiB

-153
View File
@@ -1,153 +0,0 @@
; ─────────────────────────────────────────────────────────────────────────────
; Encelado — script di installazione (Inno Setup 6)
;
; Non si compila a mano: lo lancia build/Release.proj, che prima pubblica
; l'applicazione e poi passa qui versione e percorsi con /D. Compilarlo da solo
; produrrebbe un pacchetto con la versione sbagliata, perché il numero vive nel
; tag git e non in questo file.
;
; dotnet msbuild build/Release.proj -t:Pacchetto
;
; ── Due differenze rispetto ad AutoBidder.iss ───────────────────────────────
;
; La prima: Encelado non è un eseguibile unico. È una cartella — l'applicazione
; legge encelado.json accanto a sé — quindi si copia SourceDir, non SourceExe.
;
; La seconda: l'installazione è per utente e non è possibile forzarla altrove.
; Non è per evitare l'UAC. Encelado scrive log, diario operazioni e CSV di
; analisi accanto al proprio eseguibile: dentro C:\Program Files quelle
; scritture fallirebbero, e siccome il logger degrada in silenzio piuttosto che
; fermare il bot, l'utente se ne accorgerebbe solo cercando i log per capire
; cosa è successo — cioè nel momento peggiore.
; ─────────────────────────────────────────────────────────────────────────────
#ifndef AppVersion
#define AppVersion "0.0.0"
#endif
#ifndef SourceDir
#define SourceDir "..\bin\publish\win-x64"
#endif
#ifndef OutputDir
#define OutputDir "..\bin\installer"
#endif
#define AppName "Encelado"
#define AppPublisher "Alberto Balbo"
#define AppExeName "Encelado.exe"
#define AppDescription "Bot di trading automatico su Alpaca"
[Setup]
; L'AppId identifica il prodotto fra una versione e l'altra: cambiarlo farebbe
; comparire due voci in "App installate" invece di un aggiornamento.
AppId={{7C4F1E62-2B8A-4D19-9C55-3E0A6B1D8F44}
AppName={#AppName}
AppVersion={#AppVersion}
AppVerName={#AppName} {#AppVersion}
AppPublisher={#AppPublisher}
VersionInfoVersion={#AppVersion}
VersionInfoDescription={#AppDescription}
; Vedi la nota in testa al file: l'applicazione deve poter scrivere nella
; propria cartella, quindi l'installazione resta nel profilo dell'utente e non
; è consentito spostarla altrove.
PrivilegesRequired=lowest
PrivilegesRequiredOverridesAllowed=
DefaultDirName={autopf}\{#AppName}
DefaultGroupName={#AppName}
DisableProgramGroupPage=yes
DisableDirPage=auto
OutputDir={#OutputDir}
OutputBaseFilename=Encelado_{#AppVersion}
SetupIconFile=..\src\Encelado.Bot\Assets\encelado.ico
UninstallDisplayIcon={app}\{#AppExeName}
UninstallDisplayName={#AppName} {#AppVersion}
Compression=lzma2/max
SolidCompression=yes
WizardStyle=modern
ArchitecturesAllowed=x64compatible
ArchitecturesInstallIn64BitMode=x64compatible
; Se Encelado è in esecuzione, il Restart Manager lo chiude invece di lasciare
; l'installazione a metà con i file bloccati.
CloseApplications=yes
RestartApplications=no
[Languages]
Name: "italiano"; MessagesFile: "compiler:Languages\Italian.isl"
[Tasks]
Name: "desktopicon"; Description: "Crea un collegamento sul desktop"; GroupDescription: "Collegamenti:"
[Files]
; Tutto il publish tranne la configurazione, che ha una regola sua, e i simboli
; di debug, che non servono a chi installa.
Source: "{#SourceDir}\*"; DestDir: "{app}"; \
Excludes: "encelado.json,*.pdb,*.xml,logs\*"; \
Flags: ignoreversion recursesubdirs createallsubdirs
; La configurazione è il prodotto — ogni numero dentro encelado.json è tarato su
; due dataset indipendenti — ma è anche l'unico posto dove l'utente mette mano,
; dalla scheda Impostazioni o a mano. "onlyifdoesntexist" fa sì che un
; aggiornamento non cancelli quelle modifiche; "uninsneveruninstall" che una
; disinstallazione non le butti via. Le chiavi nuove introdotte da una versione
; successiva non rompono nulla: il loader usa i valori di default per quelle che
; non trova.
Source: "{#SourceDir}\encelado.json"; DestDir: "{app}"; \
Flags: onlyifdoesntexist uninsneveruninstall
; Copia sempre aggiornata dei valori di fabbrica, per poter vedere cosa è
; cambiato rispetto al proprio encelado.json dopo un aggiornamento.
Source: "{#SourceDir}\encelado.json"; DestDir: "{app}"; \
DestName: "encelado.default.json"; Flags: ignoreversion
[Icons]
Name: "{group}\{#AppName}"; Filename: "{app}\{#AppExeName}"; Comment: "{#AppDescription}"
Name: "{group}\Disinstalla {#AppName}"; Filename: "{uninstallexe}"
Name: "{autodesktop}\{#AppName}"; Filename: "{app}\{#AppExeName}"; \
Comment: "{#AppDescription}"; Tasks: desktopicon
[Run]
Filename: "{app}\{#AppExeName}"; Description: "Avvia {#AppName}"; \
Flags: nowait postinstall skipifsilent
[UninstallDelete]
; Prodotti a runtime, quindi non tracciati dall'installatore: senza questo
; resterebbero una cartella e dei file orfani.
Type: filesandordirs; Name: "{app}\logs"
Type: dirifempty; Name: "{app}"
[Code]
{ Le credenziali Alpaca vivono in %LocalAppData%\Encelado, fuori dalla cartella
di installazione, quindi una disinstallazione normale non le toccherebbe.
Lasciarle lì in silenzio però significa lasciare sul disco una chiave API
cifrata di cui l'utente si è dimenticato. Glielo chiediamo, con il "no" come
risposta predefinita: chi disinstalla per reinstallare una versione nuova non
deve ritrovarsi a reinserire le chiavi solo perché ha premuto Invio di fretta. }
procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
var
DataDir: String;
begin
if CurUninstallStep <> usPostUninstall then
Exit;
{ In modalità silenziosa non c'è nessuno a cui chiedere, e la risposta che non
si può disfare è quella che cancella. Nel dubbio le credenziali restano. }
if UninstallSilent then
Exit;
DataDir := ExpandConstant('{localappdata}\Encelado');
if not DirExists(DataDir) then
Exit;
if MsgBox(
'Vuoi eliminare anche le credenziali Alpaca salvate?' + #13#10#13#10 +
DataDir + #13#10#13#10 +
'Scegli No se hai intenzione di reinstallare Encelado: le credenziali '
+ 'verranno riconosciute dalla nuova installazione.',
mbConfirmation, MB_YESNO or MB_DEFBUTTON2) = IDYES then
DelTree(DataDir, True, True, True);
end;
+64 -49
View File
@@ -1,23 +1,23 @@
# Catena di verifica, pacchetto e rilascio
Tutto quello che serve a controllare, impacchettare e pubblicare Encelado sta in questa
cartella. La radice del progetto non contiene script.
cartella. La radice del progetto contiene solo la `Dockerfile` e la `docker-compose.yml`.
È la stessa catena di [Mimante/AutoBidder](http://192.168.30.23:3000/Alby96/Mimante),
adattata a una soluzione con più progetti. Le differenze sono tre, tutte segnate sul
posto in `Release.proj`:
adattata a una soluzione con più progetti e a un pacchetto che è un'immagine Docker
(dalla 5.0, ADR-0008). Le differenze sono segnate sul posto in `Release.proj`:
| | AutoBidder | Encelado |
|---|---|---|
| Dove sta la versione | `AutoBidder.csproj` | `Directory.Build.props`, ereditato da tutti i progetti |
| Cosa produce `dotnet publish` | un eseguibile unico | una cartella: l'app legge `encelado.json` accanto a sé |
| Copia portabile allegata | il solo `.exe` | uno zip della cartella |
| Cosa rigioca `Backtest` | i dossier delle aste | serie storiche di prezzi |
| Cosa produce `dotnet publish` | un eseguibile unico | una cartella framework-dependent: la stessa che il `Dockerfile` mette in `/app` |
| Il pacchetto | installatore Inno Setup | immagine Docker `192.168.30.23:3000/alby96/encelado:<versione>` (+ `:latest`) |
| Allegati della release | `.exe` e installatore | zip portabile e template Unraid |
| Cosa rigioca `Backtest` | i dossier delle aste | barre M15 bid/ask dei basket (+ `learn` sul ledger) |
| File | Cos'è |
|---|---|
| `Release.proj` | La catena. Un solo file MSBuild, nessuno script. |
| `Encelado.iss` | Lo script di Inno Setup. Non si compila a mano: lo lancia `Release.proj`. |
| `gitea.example.json` | Modello per `gitea.json` (che è escluso dal controllo di versione). |
## Da VS Code
@@ -27,34 +27,53 @@ posto in `Release.proj`:
| Attività | Cosa fa |
|---|---|
| `verifica` | Compila e lancia i test. |
| `backtest` | Rigioca una serie storica di prezzi. |
| `crea installatore` | Chiede la versione, verifica, pubblica, esegue Inno Setup. |
| `crea installatore (senza rieseguire i test)` | Solo pubblicazione e installatore. |
| `rilascia su Gitea` | Tutto quanto sopra, più tag e release con i file allegati. |
| `backtest` | Ricerca sui basket: `ticks`, `baskets`, `falsify`, `learn`. |
| `immagine docker` | Costruisce l'immagine (i test girano dentro la build). Non pubblica. |
| `pacchetto` | Verifica, cartella portabile, immagine, tag a pacchetto pronto. Non tocca Gitea. |
| `rilascia su Gitea` | Tutto quanto sopra, più push dell'immagine sul registro di Gitea e release con gli allegati. |
| `docker compose up` | Il container in locale con le cartelle di `deploy/local/`. |
## Da riga di comando
```powershell
dotnet msbuild build/Release.proj -t:Verifica
dotnet msbuild build/Release.proj -t:Docker
dotnet msbuild build/Release.proj -t:Pacchetto
dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=3.3.0 -p:Note="Cosa cambia"
dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=5.0.0 -p:Note="Cosa cambia"
# Il backtest vuole un file di dati
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="C:\dati\btcusd.csv"
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="..." -p:Comando=frequency
# La ricerca sui basket: barre M15 in data/market (da `ticks`), tabelle in results/ e reports/
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="%USERPROFILE%\Documents\Encelado\data\market"
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="..." -p:Comando=falsify -p:Extra="--costs api"
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="A:\Download\Trading" -p:Comando=ticks
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="%USERPROFILE%\Documents\Encelado\data" -p:Comando=learn
```
| Proprietà | Predefinito | A cosa serve |
|---|---|---|
| `Versione` | vuoto | Vuoto = incrementa la minor (3.2.0 → 3.3.0). Altrimenti la scrive, se ha la forma `X.Y.Z`. |
| `Note` | vuoto | Note di rilascio. |
| `SaltaVerifica` | `false` | Non rieseguire i test. |
| `Versione` | vuoto | Vuoto = incrementa la minor (5.0.0 → 5.1.0). Altrimenti la scrive, se ha la forma `X.Y.Z`. |
| `Note` | vuoto | Note di rilascio (meglio via `ENCELADO_NOTE`, vedi sotto). |
| `Immagine` | `192.168.30.23:3000/alby96/encelado` | Nome completo dell'immagine. |
| `SaltaVerifica` | `false` | Non rieseguire i test (girano comunque dentro `docker build`). |
| `SaltaDocker` | `false` | Solo lo zip portabile, niente immagine né push. |
| `Sovrascrivi` | `false` | Sostituisci una release Gitea con lo stesso tag. |
| `Bozza` | `false` | Crea la release come bozza. |
| `ConsentiModifiche` | `false` | Tagga anche con l'albero sporco. Serve saperlo. |
| `Dati` | — | Il CSV da rigiocare. Obbligatorio per `Backtest`. |
| `Comando` | `split` | `split`, `walk`, `frequency`, `costs`, `sweep`, `explore`. |
| `Barre` | `1d` | Ampiezza delle barre nel backtest. |
| `Dati` | — | La cartella dei dati. Obbligatoria per `Backtest`. |
| `Comando` | `baskets` | `ticks`, `baskets`, `falsify`, `learn`. |
| `Extra` | vuoto | Altre opzioni passate allo strumento così come sono, es. `--costs api --quick`. |
## Cosa succede in `Rilascia`
1. `ConfigGitea`: legge url, owner, repo e token (ambiente o `gitea.json`); senza, si ferma prima di compilare.
2. `Verifica`: `dotnet test` nella cartella di verifica (`%TEMP%\Encelado.Verifica`).
3. `Pubblica`: `dotnet publish` framework-dependent di `Encelado.Server` in `bin/publish/portable`, con la versione da riga di comando; controlli su `Encelado.Server.dll`, `config/encelado.json` e sull'assenza di sorgenti.
4. `Docker`: `docker build --pull` con `VERSION` e `GIT_COMMIT` come build-arg; l'immagine ha i tag `:<versione>` e `:latest`. La `Dockerfile` esegue i test nel suo stadio `test`.
5. `Pacchetto`: zip portabile `bin/installer/Encelado_<v>_portabile.zip`, copia del template `deploy/unraid/encelado.xml` con la versione nel nome, **tag** `v<versione>` (solo ora, a pacchetto pronto, e solo con l'albero pulito).
6. `Rilascia`: `git push --tags` e verifica che il tag sia sul remoto; `docker login` sul registro di Gitea con il token (via stdin), `docker push` dei due tag, `docker logout`; release su Gitea con lo zip e il template allegati.
## Gitea Actions
`.gitea/workflows/ci.yml` (build + test + `docker build` a ogni push) e `release.yml` (immagine sul registro e release a ogni tag `v*`) fanno sul server quello che `Verifica` e `Rilascia` fanno dal PC. Richiedono un runner registrato e il segreto `REGISTRY_TOKEN`: vedi `docs/DOCKER.md`, «Gitea Actions». La catena resta il percorso di riferimento finché il runner non c'è.
## Chi chiede la versione
@@ -63,15 +82,15 @@ l'attività di VS Code (`inputs` in `.vscode/tasks.json`) e passa la risposta in
`-p:Versione=`. Lasciando il campo vuoto si prende la minor successiva, che è il caso
normale di fine sessione.
**La versione arriva dal tag e non viene scritta da nessuna parte.** `dotnet publish` la
riceve come proprietà da riga di comando, che è globale e vince su quella dichiarata in
`Directory.Build.props`. Tag, eseguibile, installatore e release portano quindi lo stesso
numero per costruzione.
**La versione arriva dal tag e non viene scritta da nessuna parte.** `dotnet publish` e
`docker build` la ricevono come proprietà da riga di comando, che è globale e vince su
quella dichiarata in `Directory.Build.props`. Tag, assembly, immagine e release portano
quindi lo stesso numero per costruzione. Il commit e la data di build finiscono in
`AssemblyMetadata` (Impostazioni ▸ Informazioni, `/api/info`).
Il tag si crea **in fondo**, quando l'installatore esiste davvero. Il contrario sembra più
naturale — decidi il numero, poi costruisci — ma lascia dietro un tag quando la verifica
fallisce, e il tentativo dopo riparte da lì: il numero sale senza che sia mai esistito un
pacchetto con quella versione.
Il tag si crea **in fondo**, quando lo zip e l'immagine esistono davvero. Il contrario
sembra più naturale — decidi il numero, poi costruisci — ma lascia dietro un tag quando la
verifica fallisce, e il tentativo dopo riparte da lì.
## Gitea
@@ -81,34 +100,30 @@ macchina condivisa può rilasciare senza scrivere un token su disco:
- `GITEA_URL`, `GITEA_OWNER`, `GITEA_REPO`, `GITEA_TOKEN`
- oppure `build/gitea.json`, copiato da `gitea.example.json`
Il token si crea in Gitea da *Impostazioni ▸ Applicazioni ▸ Genera nuovo token*, con il
permesso `repository: read and write`.
Il token si crea in Gitea da *Impostazioni ▸ Applicazioni ▸ Genera nuovo token*, con i
permessi `repository: read and write` **e** `package: read and write` (serve per il
registro dei container). Il registro è lo stesso host di Gitea senza schema
(`192.168.30.23:3000`): in HTTP va dichiarato `insecure-registry` a Docker Desktop
(*Settings ▸ Docker Engine*).
Il token non passa mai dalla riga di comando: sta in un file di configurazione di curl,
cancellato subito dopo il rilascio. Gli `Exec` hanno `EchoOff` perché un registro di
compilazione è la classica cosa che si incolla in una chat.
Nella release vengono caricati **sia l'installatore sia la copia portabile**: chi non
vuole installare niente deve continuare a poter scaricare l'applicazione e basta.
Il token non passa mai dalla riga di comando: sta in un file di configurazione di curl e
in un file letto da `docker login --password-stdin`, entrambi cancellati subito dopo. Gli
`Exec` hanno `EchoOff` perché un registro di compilazione è la classica cosa che si
incolla in una chat.
## Una trappola già pagata
`dotnet test` e `dotnet publish` lanciati **da dentro** MSBuild ereditano l'ambiente del
processo padre. La compilazione WPF crea un progetto temporaneo (`_wpftmp.csproj`) e con
`MSBUILD_EXE_PATH` puntata al build in corso non genera più le classi parziali dello XAML:
si ottengono decine di errori su membri che esistono benissimo.
processo padre: `MSBUILD_EXE_PATH` e `MSBuildLoadMicrosoftTargetsReadOnly` puntate al
build in corso confondono il figlio. Gli `Exec` azzerano **solo quelle due**: la ricetta
che gira in rete azzera anche `MSBuildExtensionsPath` e `MSBuildSDKsPath`, e così il
figlio perde la posizione dell'SDK.
Per questo gli `Exec` azzerano `MSBUILD_EXE_PATH` e `MSBuildLoadMicrosoftTargetsReadOnly`.
**Solo quelle due**: la ricetta che gira in rete azzera anche `MSBuildExtensionsPath` e
`MSBuildSDKsPath`, e così il figlio perde la posizione dell'SDK — *«l'SDK Microsoft.NET.Sdk
specificato non è stato trovato»*. Serve isolare il motore, non nascondergli dove abita.
I test girano in una cartella a parte (`%TEMP%\Encelado.Verifica`) perché l'applicazione
può essere aperta mentre si lavora e tiene bloccato `Encelado.exe`: senza, la compilazione
si ferma su MSB3027.
I test girano in una cartella a parte (`--artifacts-path`) perché un server lasciato
acceso da VS Code tiene bloccata `Encelado.Server.dll` nella `bin/` di lavoro.
## Prerequisiti
- .NET SDK 10
- [Inno Setup 6](https://jrsoftware.org/isinfo.php) — `winget install -e --id JRSoftware.InnoSetup`
- Docker Desktop (o un demone Docker raggiungibile) per `Docker`, `Pacchetto`, `Rilascia`; `-p:SaltaDocker=true` per farne a meno
- `curl` e `git`, entrambi di serie in Windows 11
+156 -144
View File
@@ -7,15 +7,18 @@
di VS Code (Terminale ▸ Esegui attività…) oppure a mano:
dotnet msbuild build/Release.proj -t:Verifica
dotnet msbuild build/Release.proj -t:Backtest
dotnet msbuild build/Release.proj -t:Backtest -p:Dati=...
dotnet msbuild build/Release.proj -t:Docker
dotnet msbuild build/Release.proj -t:Pacchetto
dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=3.3.0
dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=5.0.0
È la stessa catena di Mimante/AutoBidder, adattata a una soluzione con più
progetti. Le differenze rispetto a quel file sono tre, tutte segnate sul
progetti. Le differenze rispetto a quel file sono quattro, tutte segnate sul
posto: la versione vive in Directory.Build.props e non nel .csproj, la
pubblicazione produce una cartella e non un singolo eseguibile, e il target
Backtest rigioca serie storiche di prezzi invece dei dossier delle aste.
pubblicazione produce una cartella e non un singolo eseguibile, il pacchetto
è un'immagine Docker e non un installatore Windows (dalla 5.0, ADR-0007 e
ADR-0008: il bot gira solo nel container), e il target Backtest rigioca
coppie di serie storiche di prezzi invece dei dossier delle aste.
── Perché MSBuild e non uno script ──────────────────────────────────────
La catena vive accanto al codice che rilascia ed è versionata con lui: fra
@@ -26,56 +29,52 @@
── Da dove viene la versione ────────────────────────────────────────────
Dal tag git, e da nient'altro. Directory.Build.props non viene mai riscritto:
il numero arriva a `dotnet publish` come proprietà da riga di comando, quindi
tag, eseguibile, installatore e release portano lo stesso numero per
costruzione, non per disciplina.
il numero arriva a `dotnet publish` e a `docker build` come proprietà da riga
di comando, quindi tag, assembly, immagine e release portano lo stesso numero
per costruzione, non per disciplina.
Il modo previsto è taggare e poi rilasciare:
git tag v3.3.0
git tag v5.0.0
dotnet msbuild build/Release.proj -t:Rilascia
Se HEAD non ha un tag di versione la catena lo crea da sé — con il numero
passato in `-p:Versione=`, oppure la minor successiva all'ultimo tag — e lo
fa in fondo, quando l'installatore esiste davvero. Un giro andato male non
fa in fondo, quando l'immagine esiste davvero. Un giro andato male non
lascia dietro un tag per una versione che non è mai stata costruita.
Il numero in Directory.Build.props resta quello delle compilazioni di
sviluppo. Continua ad avere senso alzarlo a ogni modifica — è quello che
compare nel titolo della finestra durante il lavoro — ma non decide più cosa
viene rilasciato: serve solo come seme al primissimo rilascio, quando non
esiste ancora nessun tag da cui ripartire.
sviluppo (Impostazioni ▸ Informazioni mentre si lavora) e serve solo come
seme al primissimo rilascio, quando non esiste ancora nessun tag.
-->
<Project DefaultTargets="Pacchetto" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Radice>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..'))</Radice>
<Csproj>$(Radice)\src\Encelado.Bot\Encelado.Bot.csproj</Csproj>
<Csproj>$(Radice)\src\Encelado.Server\Encelado.Server.csproj</Csproj>
<TestProj>$(Radice)\tests\Encelado.Tests\Encelado.Tests.csproj</TestProj>
<BacktestProj>$(Radice)\tools\Encelado.Backtest\Encelado.Backtest.csproj</BacktestProj>
<Iss>$(MSBuildThisFileDirectory)Encelado.iss</Iss>
<Dockerfile>$(Radice)\Dockerfile</Dockerfile>
<TemplateUnraid>$(Radice)\deploy\unraid\encelado.xml</TemplateUnraid>
<!-- La versione non sta nel .csproj come in AutoBidder: sta in
Directory.Build.props, da cui la ereditano tutti e quattro i progetti.
Directory.Build.props, da cui la ereditano tutti i progetti.
È il file che VersioneDaTag legge quando non esiste ancora nessun tag. -->
<Props>$(Radice)\Directory.Build.props</Props>
<CartellaPubblicazione>$(Radice)\bin\publish\win-x64</CartellaPubblicazione>
<CartellaPubblicazione>$(Radice)\bin\publish\portable</CartellaPubblicazione>
<CartellaPacchetti>$(Radice)\bin\installer</CartellaPacchetti>
<!-- ── L'immagine ─────────────────────────────────────────────────────
Il registro è quello di Gitea (D-29): stesso host di build/gitea.json,
owner in minuscolo perché i nomi delle immagini OCI lo richiedono. Si
può cambiare con -p:Immagine=host/utente/nome. -->
<Immagine Condition="'$(Immagine)' == ''">192.168.30.23:3000/alby96/encelado</Immagine>
<!-- ── Perché una cartella a parte per verifica e backtest ─────────────
Due ragioni, e servono entrambe.
La prima: l'applicazione può essere aperta mentre si lavora, e tiene
bloccato Encelado.exe — la compilazione si fermerebbe su MSB3027.
La seconda: l'opzione artifacts-path sposta anche gli INTERMEDI, non
solo il risultato. La sola -o li lascia nella obj/ condivisa, e la
compilazione WPF — che genera un progetto temporaneo `_wpftmp.csproj` a
ogni giro — ogni tanto ci trovava stato altrui e smetteva di produrre
le classi parziali dello XAML. Il sintomo era una raffica di
"AuctionMonitorControl non contiene una definizione di ...", a giri
alterni, senza che il codice fosse cambiato. -->
L'opzione artifacts-path sposta anche gli INTERMEDI, non solo il
risultato: la verifica non tocca le obj/ del lavoro in corso e non
viene disturbata da un server lasciato acceso da VS Code. -->
<CartellaProve>$([System.IO.Path]::GetTempPath())Encelado.Verifica</CartellaProve>
<!-- Serve solo quando HEAD non è ancora taggato: è il numero del tag da
@@ -97,21 +96,15 @@
-->
<Note Condition="'$(Note)' == ''">$(ENCELADO_NOTE)</Note>
<!-- ── Perché serve azzerare queste variabili ──────────────────────────
`dotnet test` e `dotnet publish` lanciati da dentro MSBuild ereditano
l'ambiente del processo padre. La compilazione WPF crea un progetto
temporaneo (_wpftmp.csproj) e con quelle variabili puntate al build in
corso non genera più le classi parziali dello XAML: si ottengono decine
di "AuctionMonitorControl non contiene una definizione di ..." che non
hanno niente a che vedere col codice.
Si azzerano SOLO queste due. Togliere anche MSBuildExtensionsPath o
MSBuildSDKsPath — la ricetta che gira in rete — fa perdere al figlio la
posizione dell'SDK: "l'SDK Microsoft.NET.Sdk specificato non è stato
trovato". Serve isolare il motore, non nascondergli dove abita. -->
<!-- `dotnet test` e `dotnet publish` lanciati da dentro MSBuild ereditano
l'ambiente del processo padre; queste due variabili puntate al build
in corso confondono il figlio. Si azzerano SOLO queste due: togliere
anche MSBuildExtensionsPath o MSBuildSDKsPath fa perdere al figlio la
posizione dell'SDK. -->
<AmbientePulito>MSBUILD_EXE_PATH=;MSBuildLoadMicrosoftTargetsReadOnly=</AmbientePulito>
<SaltaVerifica Condition="'$(SaltaVerifica)' == ''">false</SaltaVerifica>
<SaltaDocker Condition="'$(SaltaDocker)' == ''">false</SaltaDocker>
<Sovrascrivi Condition="'$(Sovrascrivi)' == ''">false</Sovrascrivi>
<Bozza Condition="'$(Bozza)' == ''">false</Bozza>
@@ -242,33 +235,6 @@
</Task>
</UsingTask>
<UsingTask TaskName="TrovaInnoSetup" TaskFactory="RoslynCodeTaskFactory"
AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
<ParameterGroup>
<Percorso ParameterType="System.String" Output="true" />
</ParameterGroup>
<Task>
<Using Namespace="System" />
<Using Namespace="System.IO" />
<Code Type="Fragment" Language="cs">
<![CDATA[
var candidati = new[]
{
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"Programs\Inno Setup 6\ISCC.exe"),
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), @"Inno Setup 6\ISCC.exe"),
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Inno Setup 6\ISCC.exe"),
};
foreach (var c in candidati)
if (File.Exists(c)) { Percorso = c; break; }
if (string.IsNullOrEmpty(Percorso))
Log.LogError("Inno Setup 6 non trovato. Installalo con: winget install -e --id JRSoftware.InnoSetup");
]]>
</Code>
</Task>
</UsingTask>
<!--
Gitea si raggiunge con curl, di serie in Windows 10 e 11.
@@ -279,8 +245,9 @@
al prossimo aggiornamento di .NET no. curl non ha questo problema.
Il token NON passa mai dalla riga di comando: sta in un file di configurazione
di curl, che viene cancellato subito dopo. Gli Exec hanno EchoOff perché un
registro di compilazione è la classica cosa che si incolla in una chat.
di curl (e in un file letto da `docker login ‐‐password-stdin`), cancellati
subito dopo. Gli Exec hanno EchoOff perché un registro di compilazione è la
classica cosa che si incolla in una chat.
-->
<UsingTask TaskName="LeggiConfigGitea" TaskFactory="RoslynCodeTaskFactory"
@@ -291,6 +258,7 @@
<Owner ParameterType="System.String" Output="true" />
<Repo ParameterType="System.String" Output="true" />
<Token ParameterType="System.String" Output="true" />
<Registro ParameterType="System.String" Output="true" />
</ParameterGroup>
<Task>
<Using Namespace="System" />
@@ -324,13 +292,16 @@
" copia build/gitea.example.json in build/gitea.json e riempilo,\n" +
" oppure imposta GITEA_URL, GITEA_OWNER, GITEA_REPO, GITEA_TOKEN.\n" +
"Non e' stato costruito niente: si controlla prima di compilare, non dopo.\n" +
"Per il solo installatore, senza Gitea, usa il target Pacchetto.");
"Per il solo pacchetto, senza Gitea, usa il target Pacchetto.");
// Senza questo il target prosegue lo stesso: git tag, poi curl con
// l'indirizzo vuoto, e infine un "codice 3" che non dice niente a
// nessuno. Un errore va fermato dove si capisce ancora cos'era.
return false;
}
// Il registro dei container di Gitea e' lo stesso host, senza schema.
Registro = Regex.Replace(Url, "^https?://", "");
]]>
</Code>
</Task>
@@ -342,6 +313,7 @@
<Destinazione ParameterType="System.String" Required="true" />
<Tag ParameterType="System.String" Required="true" />
<Versione ParameterType="System.String" Required="true" />
<Immagine ParameterType="System.String" />
<Note ParameterType="System.String" />
<Bozza ParameterType="System.Boolean" />
</ParameterGroup>
@@ -357,6 +329,8 @@
.Replace("\r", "").Replace("\n", "\\n").Replace("\t", " ");
var note = string.IsNullOrWhiteSpace(Note) ? "Versione " + Versione + "." : Note;
if (!string.IsNullOrWhiteSpace(Immagine))
note += "\n\nImmagine: `" + Immagine + ":" + Versione + "` (anche `:latest`). Template Unraid allegato.";
File.WriteAllText(Destinazione,
"{\"tag_name\":\"" + esc(Tag) + "\"," +
@@ -405,8 +379,6 @@
<Target Name="Verifica" Condition="'$(SaltaVerifica)' != 'true'">
<Message Importance="High" Text="== Verifica (compilazione + test) ==" />
<!-- In una cartella a parte: l'applicazione puo' essere aperta e tenere
bloccato Encelado.exe. -->
<Exec Command="dotnet test &quot;$(TestProj)&quot; --nologo -v q --artifacts-path &quot;$(CartellaProve)&quot;"
WorkingDirectory="$(Radice)"
EnvironmentVariables="$(AmbientePulito)" />
@@ -414,59 +386,60 @@
<Message Importance="High" Text=" tutto a posto" />
</Target>
<!-- ═════════════════════ Rigiocata sui prezzi ═════════════════════ -->
<!-- ═════════════════════ Ricerca sui basket ═════════════════════ -->
<!--
Il corrispettivo del backtest sui dossier di AutoBidder. Qui non si rigiocano
aste ma serie storiche di prezzi, con lo strumento in tools/Encelado.Backtest.
Lo strumento in tools/Encelado.Backtest: `ticks` converte i tick MT5 in barre
M15 bid/ask, `baskets` rigioca la strategia (baseline, griglia, PSR/DSR, PBO,
walk-forward), `falsify` esegue i test di falsificazione, `learn` rigioca il
ciclo di apprendimento in ombra su un ledger. Ogni tabella è un CSV con ; e
colonna motivazione. Vedi docs/STRATEGY.md per i risultati.
I parametri li legge da config/encelado.json, non li ridichiara: il banco e
il bot non possono divergere senza che qualcuno se ne accorga.
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="%USERPROFILE%\Documents\Encelado\data\market"
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="..." -p:Comando=falsify -p:Extra="‐‐costs api"
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="A:\Download\Trading" -p:Comando=ticks
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="%USERPROFILE%\Documents\Encelado\data" -p:Comando=learn
-->
<Target Name="Backtest">
<PropertyGroup>
<Comando Condition="'$(Comando)' == ''">split</Comando>
<Barre Condition="'$(Barre)' == ''">1d</Barre>
<Comando Condition="'$(Comando)' == ''">baskets</Comando>
<BacktestExe>$(Radice)\tools\Encelado.Backtest\bin\Release\net10.0\backtest.exe</BacktestExe>
</PropertyGroup>
<Error Condition="'$(Dati)' == ''"
Text="Serve un file di dati: -p:Dati=&quot;C:\percorso\btcusd.csv&quot;.%0AComandi disponibili in -p:Comando= : split, sweep, walk, frequency, costs, explore." />
Text="Serve la cartella dei dati: -p:Dati=&quot;%USERPROFILE%\Documents\Encelado\data\market&quot; (barre candles_SYMBOL_M15.csv) per baskets e falsify, la cartella dei tick MT5 per ticks, la cartella data del bot per learn.%0AComandi disponibili in -p:Comando= : ticks, baskets, falsify, learn (altre opzioni in -p:Extra=, es. --costs api --quick)." />
<Error Condition="!Exists('$(Dati)')" Text="File di dati non trovato: $(Dati)" />
<Error Condition="!Exists('$(Dati)')" Text="Cartella dati non trovata: $(Dati)" />
<Message Importance="High" Text="== Rigiocata sui prezzi ==" />
<Message Importance="High" Text="== Ricerca sui basket ==" />
<Message Importance="High" Text=" dati : $(Dati)" />
<Message Importance="High" Text=" comando : $(Comando) su barre da $(Barre)" />
<Message Importance="High" Text=" comando : $(Comando) $(Extra)" />
<Exec WorkingDirectory="$(Radice)" EnvironmentVariables="$(AmbientePulito)"
Command="dotnet build &quot;$(BacktestProj)&quot; -c Release --nologo -v q" />
<Exec WorkingDirectory="$(Radice)"
Command="&quot;$(BacktestExe)&quot; $(Comando) --file &quot;$(Dati)&quot; --tf $(Barre) $(Extra)" />
Command="&quot;$(BacktestExe)&quot; $(Comando) --data &quot;$(Dati)&quot; $(Extra)" />
</Target>
<!-- ═════════════════════ Eseguibile ═════════════════════ -->
<!-- ═════════════════════ Pubblicazione ═════════════════════ -->
<!--
I quattro numeri di versione arrivano da qui, non da Directory.Build.props:
le proprietà da riga di comando sono globali e vincono su quelle scritte nei
progetti. Vengono passati tutti e quattro anche se il file ne dichiara uno
solo — la finestra legge Assembly.GetName().Version, e vederne divergere uno
significa un numero a schermo che mente.
solo — Informazioni legge Assembly.GetName().Version, e vederne divergere
uno significa un numero a schermo che mente.
── Perché una cartella e non un singolo eseguibile ────────────────────────
AutoBidder pubblica con PublishSingleFile e allega quel file alla release.
Qui non si può: Encelado legge `encelado.json` accanto al proprio eseguibile
e ci scrive log, diario e CSV di analisi. Un singolo file estratto in una
cartella temporanea a ogni avvio metterebbe la configurazione dell'utente e
i suoi log in un percorso che cambia da un avvio all'altro.
Una cartella non si allega a una release, quindi al suo posto viene allegato
uno zip: vedi il target Rilascia.
── Cosa si pubblica ──────────────────────────────────────────────────────
Una cartella framework-dependent, senza sistema operativo: è la stessa
cosa che il Dockerfile mette in /app, e chi vuole girare senza container
(sconsigliato: ADR-0007) la lancia con `dotnet Encelado.Server.dll` sopra
il runtime ASP.NET Core 10. Una cartella non si allega a una release,
quindi al suo posto viene allegato uno zip: vedi il target Pacchetto.
-->
<Target Name="Pubblica" DependsOnTargets="DeterminaVersione">
<Message Importance="High" Text="== Pubblicazione dell'eseguibile ($(V)) ==" />
<Message Importance="High" Text="== Pubblicazione della cartella portabile ($(V)) ==" />
<!-- Cartella pulita a ogni giro. Senza questo i resti di una pubblicazione
precedente — una DLL rinominata, un runtime cambiato — finiscono nel
@@ -476,29 +449,24 @@
<Exec WorkingDirectory="$(Radice)"
EnvironmentVariables="$(AmbientePulito)"
Command="dotnet publish &quot;$(Csproj)&quot; -c Release -r win-x64 --nologo -v q --self-contained true -p:PublishReadyToRun=true -p:PublishTrimmed=false -p:DebugType=none -p:Version=$(V) -p:AssemblyVersion=$(V).0 -p:FileVersion=$(V).0 -p:InformationalVersion=$(V) -o &quot;$(CartellaPubblicazione)&quot;" />
Command="dotnet publish &quot;$(Csproj)&quot; -c Release --nologo -v q --self-contained false -p:DebugType=none -p:Version=$(V) -p:AssemblyVersion=$(V).0 -p:FileVersion=$(V).0 -p:InformationalVersion=$(V) -o &quot;$(CartellaPubblicazione)&quot;" />
<Error Condition="!Exists('$(CartellaPubblicazione)\Encelado.exe')"
Text="Pubblicazione fallita: Encelado.exe non trovato." />
<Error Condition="!Exists('$(CartellaPubblicazione)\Encelado.Server.dll')"
Text="Pubblicazione fallita: Encelado.Server.dll non trovato." />
<!-- Senza configurazione l'applicazione non parte, e l'installatore la
copierebbe senza accorgersi che manca. -->
<Error Condition="!Exists('$(CartellaPubblicazione)\encelado.json')"
Text="Pubblicazione incompleta: encelado.json non è finito accanto all'eseguibile." />
<!-- Senza configurazione di fabbrica il primo avvio non può seminare
encelado.json e strategy.json nella cartella di configurazione. -->
<Error Condition="!Exists('$(CartellaPubblicazione)\config\encelado.json')"
Text="Pubblicazione incompleta: config\encelado.json non è finito accanto all'eseguibile." />
<!--
Nella release non devono finire i sorgenti: si pubblica il programma, non
il progetto. La cartella pubblicata diventa lo zip portabile, quindi basta
controllare qui.
Non è teorico: un <None CopyToOutputDirectory> aggiunto per comodità, o un
pacchetto che porta i propri .cs, li farebbe scivolare dentro senza che
nessuno se ne accorga fino a quando qualcuno non apre lo zip.
-->
<ItemGroup>
<SorgenteIntruso Include="$(CartellaPubblicazione)\**\*.cs" />
<SorgenteIntruso Include="$(CartellaPubblicazione)\**\*.csproj" />
<SorgenteIntruso Include="$(CartellaPubblicazione)\**\*.xaml" />
<SorgenteIntruso Include="$(CartellaPubblicazione)\**\*.pdb" />
</ItemGroup>
@@ -506,6 +474,43 @@
Text="Nella cartella pubblicata ci sono file che non sono programma: @(SorgenteIntruso->'%(Filename)%(Extension)', ', ').%0ANon devono finire nella release." />
</Target>
<!-- ═════════════════════ Immagine Docker ═════════════════════ -->
<!--
L'immagine è il pacchetto vero (ADR-0008). La Dockerfile alla radice compila,
esegue i test e pubblica dentro lo stadio di build: un'immagine con i test
rossi non esiste. Il commit arriva come build-arg perché .git resta fuori
dal contesto (.dockerignore).
dotnet msbuild build/Release.proj -t:Docker # :<versione> e :latest
dotnet msbuild build/Release.proj -t:Docker -p:SaltaDocker=true # (no-op, per la catena senza Docker)
-->
<Target Name="Docker" DependsOnTargets="DeterminaVersione" Condition="'$(SaltaDocker)' != 'true'">
<Message Importance="High" Text="== Immagine Docker $(Immagine):$(V) ==" />
<Error Condition="!Exists('$(Dockerfile)')" Text="Dockerfile non trovata: $(Dockerfile)" />
<Exec Command="docker version --format {{.Server.Version}}" ContinueOnError="true"
ConsoleToMSBuild="true" StandardOutputImportance="low" StandardErrorImportance="low">
<Output TaskParameter="ExitCode" PropertyName="DockerEsito" />
</Exec>
<Error Condition="'$(DockerEsito)' != '0'"
Text="Docker non risponde: avvia Docker Desktop (o il demone) e rilancia. Per saltare l'immagine: -p:SaltaDocker=true." />
<Exec Command="git rev-parse --short=12 HEAD" WorkingDirectory="$(Radice)" ContinueOnError="true"
ConsoleToMSBuild="true" StandardOutputImportance="low" StandardErrorImportance="low">
<Output TaskParameter="ConsoleOutput" PropertyName="Commit" />
</Exec>
<PropertyGroup>
<Commit Condition="'$(Commit)' == ''">n/d</Commit>
</PropertyGroup>
<Exec WorkingDirectory="$(Radice)"
Command="docker build --pull -t &quot;$(Immagine):$(V)&quot; -t &quot;$(Immagine):latest&quot; --build-arg VERSION=$(V) --build-arg GIT_COMMIT=$(Commit) -f &quot;$(Dockerfile)&quot; &quot;$(Radice)&quot;" />
<Message Importance="High" Text=" immagine $(Immagine):$(V) (commit $(Commit))" />
</Target>
<!-- ═════════════════════ Pacchetto ═════════════════════ -->
<!--
@@ -515,45 +520,37 @@
lascia dietro un tag quando qualcosa va storto, e il tentativo successivo
riparte da li'. Un giro andato male e il numero e' salito lo stesso, senza
che sia mai esistito un pacchetto con quella versione. Taggando in fondo,
ogni tag corrisponde a un installatore che esiste davvero.
ogni tag corrisponde a un'immagine e a uno zip che esistono davvero.
-->
<Target Name="Pacchetto" DependsOnTargets="Verifica;DeterminaVersione;Pubblica">
<Message Importance="High" Text="== Creazione dell'installatore ==" />
<TrovaInnoSetup>
<Output TaskParameter="Percorso" PropertyName="Iscc" />
</TrovaInnoSetup>
<Target Name="Pacchetto" DependsOnTargets="Verifica;DeterminaVersione;Pubblica;Docker">
<Message Importance="High" Text="== Creazione del pacchetto ==" />
<MakeDir Directories="$(CartellaPacchetti)" />
<Exec WorkingDirectory="$(MSBuildThisFileDirectory)"
Command="&quot;$(Iscc)&quot; /Qp &quot;/DAppVersion=$(V)&quot; &quot;/DSourceDir=$(CartellaPubblicazione)&quot; &quot;/DOutputDir=$(CartellaPacchetti)&quot; &quot;$(Iss)&quot;" />
<PropertyGroup>
<Setup>$(CartellaPacchetti)\Encelado_$(V).exe</Setup>
<Portabile>$(CartellaPacchetti)\Encelado_$(V)_portabile.zip</Portabile>
<TemplateAllegato>$(CartellaPacchetti)\encelado-unraid-$(V).xml</TemplateAllegato>
</PropertyGroup>
<Error Condition="!Exists('$(Setup)')" Text="Installatore non trovato: $(Setup)" />
<!--
La copia portabile per chi non vuole installare niente.
In AutoBidder è il solo .exe, perché lì la pubblicazione è un file unico.
Qui l'applicazione ha bisogno di encelado.json accanto a sé, quindi è uno
zip della cartella. Si crea qui e non nel rilascio: entrambi i pacchetti
devono esistere anche costruendo senza pubblicare su Gitea.
La copia portabile per chi non vuole il container (framework-dependent:
serve il runtime ASP.NET Core 10). Si crea qui e non nel rilascio: deve
esistere anche costruendo senza pubblicare su Gitea.
-->
<Delete Files="$(Portabile)" ContinueOnError="true" />
<ZipDirectory SourceDirectory="$(CartellaPubblicazione)" DestinationFile="$(Portabile)" />
<!-- Il template Unraid con la versione nel nome, così la release lo porta con sé. -->
<Copy SourceFiles="$(TemplateUnraid)" DestinationFiles="$(TemplateAllegato)" Condition="Exists('$(TemplateUnraid)')" />
<!-- Adesso: il pacchetto c'e', il tag puo' esistere. -->
<CallTarget Targets="CreaTag" />
<Message Importance="High" Text=" " />
<Message Importance="High" Text="Pacchetto pronto:" />
<Message Importance="High" Text=" $(Setup)" />
<Message Importance="High" Text=" $(Portabile)" />
<Message Importance="High" Text=" $(TemplateAllegato)" />
<Message Importance="High" Text=" $(Immagine):$(V)" Condition="'$(SaltaDocker)' != 'true'" />
</Target>
<!-- ═════════════════════ Versione e tag ═════════════════════ -->
@@ -598,14 +595,15 @@
<!-- ═════════════════════ Rilascio ═════════════════════ -->
<!-- Prima di tutto il resto: un token mancante non deve costare due minuti di
compilazione per poi fermarsi all'ultimo passo. -->
<!-- Prima di tutto il resto: un token mancante non deve costare i minuti
dell'immagine per poi fermarsi all'ultimo passo. -->
<Target Name="ConfigGitea">
<LeggiConfigGitea Percorso="$(MSBuildThisFileDirectory)gitea.json">
<Output TaskParameter="Url" PropertyName="GUrl" />
<Output TaskParameter="Owner" PropertyName="GOwner" />
<Output TaskParameter="Repo" PropertyName="GRepo" />
<Output TaskParameter="Token" PropertyName="GToken" />
<Output TaskParameter="Registro" PropertyName="GRegistro" />
</LeggiConfigGitea>
</Target>
@@ -616,9 +614,11 @@
<Api>$(GUrl)/api/v1/repos/$(GOwner)/$(GRepo)</Api>
<Tmp>$([System.IO.Path]::GetTempPath())Encelado.Rilascio</Tmp>
<CurlCfg>$(Tmp)\curl.cfg</CurlCfg>
<TokenFile>$(Tmp)\registry.token</TokenFile>
<CorpoJson>$(Tmp)\release.json</CorpoJson>
<RispostaJson>$(Tmp)\risposta.json</RispostaJson>
<Setup>$(CartellaPacchetti)\Encelado_$(V).exe</Setup>
<Portabile>$(CartellaPacchetti)\Encelado_$(V)_portabile.zip</Portabile>
<TemplateAllegato>$(CartellaPacchetti)\encelado-unraid-$(V).xml</TemplateAllegato>
</PropertyGroup>
<MakeDir Directories="$(Tmp)" />
@@ -626,6 +626,7 @@
<!-- Il token vive qui e solo qui, per il tempo del rilascio. -->
<WriteLinesToFile File="$(CurlCfg)" Overwrite="true"
Lines="header = &quot;Authorization: token $(GToken)&quot;" />
<WriteLinesToFile File="$(TokenFile)" Overwrite="true" Lines="$(GToken)" />
<!--
Il tag esiste gia' in locale: l'ha creato Pacchetto, o c'era prima. Qui va
@@ -655,6 +656,20 @@
<Message Importance="High" Text=" tag $(Tag) sul remoto" />
<!--
L'immagine sul registro dei container di Gitea (stesso host, stesso
token: il registro accetta utente + token come password). Il push viene
prima della release: se fallisce, non esiste una release che indica
un'immagine che nessuno può scaricare.
-->
<Exec Condition="'$(SaltaDocker)' != 'true'" EchoOff="true" StandardOutputImportance="low"
Command="docker login &quot;$(GRegistro)&quot; -u &quot;$(GOwner)&quot; --password-stdin &lt; &quot;$(TokenFile)&quot;" />
<Exec Condition="'$(SaltaDocker)' != 'true'" Command="docker push &quot;$(Immagine):$(V)&quot;" />
<Exec Condition="'$(SaltaDocker)' != 'true'" Command="docker push &quot;$(Immagine):latest&quot;" />
<Exec Condition="'$(SaltaDocker)' != 'true'" ContinueOnError="true" StandardOutputImportance="low"
Command="docker logout &quot;$(GRegistro)&quot;" />
<Message Condition="'$(SaltaDocker)' != 'true'" Importance="High" Text=" immagine $(Immagine):$(V) e :latest sul registro" />
<!-- Release gia' presente? -->
<Exec EchoOff="true" ContinueOnError="true" StandardOutputImportance="low"
Command="curl -s -K &quot;$(CurlCfg)&quot; -o &quot;$(RispostaJson)&quot; &quot;$(Api)/releases/tags/$(Tag)&quot;" />
@@ -673,7 +688,7 @@
<!-- Creazione -->
<PreparaCorpoRelease Destinazione="$(CorpoJson)" Tag="$(Tag)" Versione="$(V)"
Note="$(Note)" Bozza="$(Bozza)" />
Immagine="$(Immagine)" Note="$(Note)" Bozza="$(Bozza)" />
<Exec EchoOff="true" StandardOutputImportance="low"
Command="curl -s -K &quot;$(CurlCfg)&quot; -X POST -H &quot;Content-Type: application/json&quot; --data-binary &quot;@$(CorpoJson)&quot; -o &quot;$(RispostaJson)&quot; &quot;$(Api)/releases&quot;" />
@@ -689,17 +704,13 @@
<Message Importance="High" Text=" release creata" />
<!--
Allegati: l'installatore e la copia portabile, entrambi già costruiti da
Allegati: la copia portabile e il template Unraid, entrambi già pronti da
Pacchetto. Nient'altro — in particolare nessun sorgente: si pubblica il
programma, non il progetto.
Gli archivi "Source code" che Gitea mostra da sé sulla pagina della release
non arrivano da qui: li genera il server dal tag, e si tolgono solo dalla
sua configurazione (DISABLE_DOWNLOAD_SOURCE_ARCHIVES in app.ini).
programma, non il progetto. L'immagine non si allega: sta nel registro.
-->
<ItemGroup>
<Allegato Include="$(Setup)" />
<Allegato Include="$(CartellaPacchetti)\Encelado_$(V)_portabile.zip" />
<Allegato Include="$(Portabile)" />
<Allegato Include="$(TemplateAllegato)" />
</ItemGroup>
<Exec Condition="Exists('%(Allegato.FullPath)')" EchoOff="true" StandardOutputImportance="low"
@@ -709,11 +720,12 @@
Condition="Exists('%(Allegato.FullPath)')" />
<!-- Il token non deve sopravvivere al rilascio. -->
<Delete Files="$(CurlCfg);$(CorpoJson);$(RispostaJson)" ContinueOnError="true" />
<Delete Files="$(CurlCfg);$(TokenFile);$(CorpoJson);$(RispostaJson)" ContinueOnError="true" />
<Message Importance="High" Text=" " />
<Message Importance="High" Text="Rilascio completato:" />
<Message Importance="High" Text=" $(GUrl)/$(GOwner)/$(GRepo)/releases/tag/$(Tag)" />
<Message Importance="High" Text=" docker pull $(Immagine):$(V)" Condition="'$(SaltaDocker)' != 'true'" />
</Target>
</Project>
+49 -130
View File
@@ -1,150 +1,69 @@
{
"_comment": "Encelado — configurazione unica. Ogni numero qui sotto è stato verificato su due dataset indipendenti: 4.756 barre giornaliere Bitstamp (2012-2025, ripiegate da 6,8 milioni di barre da un minuto) e 3.260 barre Binance (2017-2026). Vedi il README.",
"_commento": "Configurazione di Encelado — Correlation Baskets su eToro (CFD forex). Si modifica da Impostazioni nell'interfaccia web, che applica subito tutto quello che può (quando serve riavvia il motore da sé, senza chiudere i basket). Le chiavi con il prefisso _ sono documentazione e vengono ignorate. I parametri della strategia (basket, preset, soglie, rischio) stanno in strategy.json accanto a questo file. Le chiavi eToro e il token Telegram non stanno qui: si inseriscono da Impostazioni e vivono cifrati in secrets.enc con la password dell'interfaccia.",
"alpaca": {
"paper": true,
"dataFeed": "iex",
"requestsPerMinute": 180,
"httpTimeoutSeconds": 15,
"maxRetries": 4
"etoro": {
"_note": "eToro Public API. Il conto segue run.executionMode: Demo = conto demo, Live = conto reale; chiavi e rotte dei due conti sono diverse e il conto attivo è sempre visibile nell'interfaccia.",
"baseUrl": "https://public-api.etoro.com",
"_requestTimeoutSeconds": "Oltre questo tempo una richiesta HTTP a eToro viene abbandonata (e, se era una lettura, ritentata).",
"requestTimeoutSeconds": 20,
"_fillTimeoutSeconds": "Quanto attendere l'esito di un ordine (eToro lo lavora in modo asincrono) prima di trattarlo come non confermato e riconciliare. È anche il timeout della seconda gamba (leg-risk).",
"fillTimeoutSeconds": 5
},
"engine": {
"assetClass": "crypto",
"_timeFrame": "Giornaliero. Le stesse regole su barre orarie perdono il 99% del capitale: con ~50 bps di costo per giro completo la frequenza uccide prima della direzione.",
"timeFrame": "1Day",
"_warmup": "La media è a 100 giorni. 220 barre danno margine.",
"warmupBars": 220,
"tradeOnlyRegularHours": false,
"flattenBeforeCloseMinutes": 0,
"_crypto": "Alpaca sulle crypto vuole quantità frazionarie e non supporta i bracket order: lo stop lo tiene l'engine e lo verifica a ogni quotazione.",
"allowFractionalShares": true,
"useBracketOrders": false,
"entryOrderType": "limit",
"limitOffsetBps": 8,
"dryRun": false,
"_reconcile": "Ogni quanto il bot ricontrolla conto, posizioni e ordini contro il broker, e chiede le barre già chiuse. È anche il momento in cui si accorge che una barra nuova è disponibile da valutare, quindi abbassarlo lo rende più reattivo all'apertura di una barra.",
"reconcileSeconds": 30,
"_status": "Riepilogo periodico nel log: contatori, latenze, stato delle connessioni.",
"run": {
"_executionMode": "Demo = conto demo di eToro: ordini veri, denaro virtuale, il bot apre e chiude da solo. Live = conto reale: richiede allowLive = true e la frase CONFERMO LIVE scritta nell'interfaccia a ogni avvio; in Live il motore non parte mai da solo. Il cambio di conto è rifiutato finché ci sono basket aperti o ordini in sospeso. Nessuna modalità chiede l'approvazione dei singoli ordini (decisione D-20).",
"executionMode": "Demo",
"allowLive": false,
"_autostart": "true = all'avvio del container il motore parte da solo (mai in Live, che aspetta AVVIA con la frase). false = il motore parte solo con AVVIA.",
"autostart": true,
"_pollSeconds": "Secondi fra due letture delle quotazioni (una richiesta per tutti gli strumenti). 3 s = 20 richieste al minuto su una quota di 120: resta spazio per candele e costi.",
"pollSeconds": 3,
"_statusSeconds": "Ogni quanti secondi il bot scrive una riga di stato nel log (e sulla console).",
"statusSeconds": 60,
"_explain": "Ogni quanto il bot rilegge cosa farebbe al prezzo attuale e lo scrive nel log, se è cambiato rispetto a prima. Su barre giornaliere il bot è legittimamente silenzioso per settimane, e da fuori il silenzio è indistinguibile da un blocco: questa riga lo trasforma in una frase.",
"explainSeconds": 5,
"maxQuoteAgeSeconds": 120,
"closeOnShutdown": false
"_closeOnShutdown": "true = fermare il bot chiude i basket aperti a mercato. false = restano sul conto con gli stop nativi sul server, senza nessuno che applichi il take-profit o lo stop di basket finché il bot non riparte. Un riavvio automatico dopo un cambio delle impostazioni non chiude mai niente.",
"closeOnShutdown": false,
"strategyFile": "strategy.json",
"_cartelle": "Relative alla cartella di questo file: data (mercato, calendario, notizie, ledger, modelli), knowledge (calibrazione, proposte, registri), reports. Nel container stanno in /data.",
"dataDirectory": "data",
"knowledgeDirectory": "knowledge",
"reportsDirectory": "reports"
},
"risk": {
"_sizing": "Questa strategia compete con il comprare e tenere, quindi quando è dentro deve esserci per intero: qualunque frazione inferiore perde la gara in partenza. stakePct 1.0 impegna tutto il saldo disponibile; il risk engine si ferma comunque al 98% per lasciare spazio alle commissioni.",
"stakePct": 1.0,
"stakeAmount": 0,
"_risk": "Non usato finché stakePct è impostato, ma deve restare valido: è il criterio di riserva se un giorno azzeri stakePct.",
"maxRiskPerTradePct": 0.05,
"_caps": "A 1.0 perché con un solo asset e stake pieno la posizione È il portafoglio. Abbassarli qui significa restare parzialmente liquidi e perdere rendimento senza guadagnare protezione: la protezione la dà l'uscita sotto la media.",
"maxPositionNotionalPct": 1.0,
"maxGrossExposurePct": 1.0,
"_openPositions": "0 = nessun limite. Nota però che con un solo simbolo il numero di posizioni contemporanee resta 1 comunque: il risk engine rifiuta un secondo ingresso sullo stesso strumento con 'already in position'. E con stakePct 1.0 la prima posizione impegna tutto il saldo, quindi una seconda non avrebbe con cosa aprirsi. Questo limite torna a contare quando aggiungi simboli.",
"maxOpenPositions": 0,
"_frequency": "0 = nessun limite. Il bot può aprire quante posizioni vuole e fare quante operazioni vuole: a fermarlo è la strategia, non un contatore. Attenzione: erano una rete contro un bug (un ciclo che riapre la stessa posizione mille volte costa mille commissioni). Con 0 quella rete non c'è più.",
"maxTradesPerDay": 0,
"maxTradesPerSymbolPerDay": 0,
"minSecondsBetweenEntries": 0,
"_dailyLoss": "Kill switch giornaliero. Al 25% perché su BTC un -20% in un giorno è successo più volte e non è una ragione per smettere: la strategia esce quando cede la media, non quando fa male. Troppo stretto qui significa liquidare sul minimo.",
"maxDailyLossPct": 0.25,
"maxDailyProfitPct": 0,
"maxRelativeSpread": 0.0015,
"minPrice": 0.01,
"maxPrice": 10000000,
"minOrderNotional": 25,
"maxOrderNotional": 0,
"_shorting": "Alpaca non consente lo short sulle crypto. La strategia è long/flat.",
"allowShorting": false,
"_stop": "Rete di sicurezza per un gap, non il controllo del rischio. Quello vero è l'uscita sotto la media: uno stop stretto venderebbe e poi aspetterebbe un nuovo incrocio per rientrare, che è esattamente come il modello precedente trasformava le oscillazioni in perdite realizzate.",
"defaultStopPct": 0.35,
"maxStopDistancePct": 0.60
"ui": {
"_timeZone": "Fuso degli orari scritti dal server (righe di attività, riga di stato): 'computer' = quello del sistema; 'UTC'; oppure un id IANA (es. 'Europe/Rome'). Gli orologi dell'interfaccia usano il fuso del browser; il file di log porta l'offset e il ledger è in UTC.",
"timeZone": "computer",
"_displayCurrency": "Valuta in cui l'interfaccia mostra gli importi (USD, EUR, GBP, CHF, JPY, AUD, CAD, NZD). I tassi vengono dalle quotazioni eToro già in polling; ledger e decisioni restano in USD.",
"displayCurrency": "USD",
"_theme": "dark oppure light.",
"theme": "dark",
"_navExpanded": "Se la barra di navigazione a sinistra parte aperta (etichette estese) o chiusa (solo icone).",
"navExpanded": true
},
"logging": {
"_level": "trace | debug | info | warn | error | none. 'debug' registra anche ogni segnale scartato e ogni rifiuto del risk engine: utile per capire perché il bot NON ha fatto qualcosa.",
"level": "debug",
"_directory": "Dove salvare tutti gli output. Relativa all'eseguibile, oppure un percorso assoluto tipo D:\\encelado-logs. Si cambia anche da Impostazioni → Log, che verifica di potervi scrivere prima di salvare.",
"directory": "logs",
"_level": "trace, debug, info, warn, error, none. 'info' basta: ogni rifiuto che impedisce un ordine viene scritto a questo livello o sopra, con il basket e il motivo esatto.",
"level": "info",
"console": false,
"_directory": "Cartella dei log, relativa a questo file se non è assoluta.",
"directory": "logs",
"file": "encelado.log",
"_rotation": "Ruota encelado.log in encelado.1.log e così via, tenendo gli ultimi 10.",
"_rotazione": "Superata maxFileSizeMb il file viene ruotato (encelado.1.log, encelado.2.log…) e ne restano maxFiles.",
"maxFileSizeMb": 32,
"maxFiles": 10,
"_analysis": "decisions.csv ha una riga per ogni barra valutata con tutti gli indicatori; executions.csv ha una riga per ogni segnale arrivato agli ordini, con il verdetto del risk engine. Si uniscono su decisionId. Sono il materiale per migliorare il modello.",
"tradeJournal": "trades.jsonl",
"decisionLog": "decisions.csv",
"executionLog": "executions.csv",
"_verbose": "Con logMarketData attivo e level=trace registra ogni singola quotazione e ogni print. File enormi: serve solo per diagnosticare il flusso dati.",
"logMarketData": false,
"_everyBar": "Scrive una riga per ogni barra da un minuto che arriva dallo stream, non solo per quelle che chiudono una barra della strategia. Su barre giornaliere 1439 minuti su 1440 vengono assorbiti in silenzio: senza questo il log non mostra nulla per ventiquattr'ore e il bot sembra fermo.",
"logEveryBar": true,
"_inApp": "Quante righe tiene la striscia ATTIVITÀ nella pagina Stato e quante ne tiene la scheda Log. La seconda è il tetto di memoria del log in-app. Il file su disco resta completo comunque.",
"_righe": "statusLines = righe della striscia di attività nella dashboard; bufferedLines = righe tenute in memoria dalla pagina Log (il file su disco resta completo).",
"statusLines": 200,
"bufferedLines": 5000
},
"ui": {
"url": "http://localhost:5088",
"autoStartBot": false,
"openBrowser": false
},
"_symbols": "Solo BTC/USD. ETH è stato tolto: la strategia è tarata e verificata su BTC, e con stakePct 1.0 un secondo asset dimezzerebbe l'esposizione al primo senza che nessun backtest lo giustifichi.",
"symbols": [
{
"symbol": "BTC/USD",
"strategy": "trend-filter",
"enabled": true,
"parameters": {
"_period": "Media a 100 giorni. È l'unico valore che batte il comprare e tenere su ENTRAMBI i dataset: 120 rende di più su Bitstamp ma perde su Binance, 200 perde su tutti e due. La riga dei 100 giorni vince su entrambi a qualunque banda.",
"period": 100,
"_band": "Isteresi, non un filtro: si entra il 2% sopra la media e si esce il 2% sotto, così un prezzo appoggiato alla media non genera un'operazione ogni due giorni. Dimezza gli scambi lasciando il rendimento dov'era.",
"band": 0.02,
"_stop": "Rete per un gap. La vera uscita è la media.",
"stopPct": 0.35,
"_cvd": "Gate di order flow, disattivato. Misurato su Binance con il volume taker: alzandolo il Calmar scende da 0,71 a 0,66 a 0,64. Serviva al modello precedente, che operava di rado e poteva permettersi di aspettare conferma; qui ogni barra passata ad aspettare è una barra che non compone. Il valore resta calcolato e registrato nei log.",
"cvdThreshold": 0,
"cvdPeriod": 10,
"cvdNormPeriod": 60,
"_diagnostics": "Solo per il pannello e i log, non entrano in nessuna decisione.",
"volPeriod": 30,
"barsPerYear": 365,
"atrPeriod": 14,
"allowShort": 0
}
"notifications": {
"_telegram": "Notifiche e comandi su Telegram. Il token del bot si inserisce da Impostazioni ▸ Notifiche Telegram e vive cifrato in secrets.enc, mai in questo file; chatId è la sola chat che riceve i messaggi e può dare comandi. hourlyStatus = stato allo scoccare di ogni ora UTC; eventAlerts = aperture, chiusure, ordini risolti, kill-switch, recupero, errori; dailySummaryUtcHour = ora UTC del riepilogo giornaliero (negativo = spento); commands = risposte ai comandi /stato, /posizioni, /storico, /pausa, /riprendi, /chiudi, /kill CONFERMO, /reset dalla sola chat autorizzata.",
"telegram": {
"enabled": false,
"chatId": "",
"hourlyStatus": true,
"eventAlerts": true,
"dailySummaryUtcHour": 21,
"commands": true
}
]
}
}
@@ -1,12 +0,0 @@
{
"_comment": "Copy this file to encelado.local.json (gitignored) next to encelado.json. It is merged on top of the main config, so it only needs the keys you want to override. Environment variables still win over both.",
"alpaca": {
"keyId": "PK...........",
"secretKey": "................................"
},
"engine": {
"dryRun": true
}
}
+104
View File
@@ -0,0 +1,104 @@
{
"_comment": "Encelado — strategia Correlation Baskets su eToro. Cinque basket di due coppie forex correlate: si entra quando il cross sintetico diverge (z-score), si esce quando converge o al take-profit di basket in pip; lo stop di basket è obbligatorio. Ogni chiave con '_' davanti è documentazione.",
"_preset": "Conservative | Moderate | Aggressive. Fissa zIn, riskPerBasketPct, maxBaskets, tpPips, maxAdds, zStop. Si sceglie in Impostazioni ▸ Strategia e il bot lo applica subito ai basket nuovi: quelli già aperti tengono take-profit, perdita massima, zStop e aggiunte con cui sono entrati. Le chiavi omonime qui sotto, se presenti, sovrascrivono il preset.",
"preset": "Moderate",
"_signalMode": "ZScoreSynthetic (default, |z| >= zIn sul cross sintetico) oppure PipDivergence (fedele all'interfaccia Titany: divergenza in pip dall'ancora, dIn).",
"signalMode": "ZScoreSynthetic",
"_exitMode": "First = la prima fra TP in pip e rientro dello z; FixedPips = solo TP in pip lordi; ZReturn = solo |z| <= zOut.",
"exitMode": "First",
"_averagingMode": "Off | AddOnce | Grid. Off di fabbrica; AddOnce ammette una sola aggiunta per basket, Grid fino a maxAdds. Moltiplicatore di lotto sempre 1,0 (niente martingala).",
"averagingMode": "Off",
"tpMode": "Pips",
"_sameCrossPolicy": "I basket 4 e 5 sono entrambi EURCAD: Exclusive = uno solo aperto per volta; Half = entrambi a metà size.",
"sameCrossPolicy": "Exclusive",
"preferDirectCross": false,
"_indicatori": "Correlazione di Pearson rolling dei rendimenti M15 su window (ρ_W) e windowShort (ρ_20); z-score del cross sintetico su window; half-life OLS ricalcolata ogni halfLifeRecalcHours.",
"window": 100,
"windowShort": 20,
"rhoMin": 0.60,
"rhoShortMin": 0.40,
"halfLifeMinBars": 4,
"halfLifeMaxBars": 96,
"halfLifeRecalcHours": 4,
"atrPeriod": 14,
"ewmaSpan": 100,
"trendPeriod": 14,
"zOut": 0.25,
"dIn": 15,
"anchorBars": 32,
"gridStepZ": 0.75,
"lotMultiplier": 1.0,
"_uscite": "Stop di basket: |z| >= zStop, oppure perdita netta >= maxLossPerBasketPct dell'equity, oppure |ρ_20| < rhoBreak per rhoBreakBars barre, oppure maxHoldingBars barre (96 = 24 h).",
"maxLossPerBasketPct": 1.5,
"rhoBreak": 0.20,
"rhoBreakBars": 8,
"maxHoldingBars": 96,
"tpAtrMultiple": 1.0,
"_costGate": "Costo = spread_A + spread_B (in pip-equivalenti di A) + markup e commissioni dell'API + overnight stimato per maxHoldingBars. Entrata solo se TP >= costMultiple × costo e ogni spread <= spreadMedianMultiple × la sua mediana delle ultime 24 h; spread oltre spreadAnomalyMultiple × mediana = chiusura forzata.",
"costMultiple": 3,
"spreadMedianMultiple": 2,
"spreadAnomalyMultiple": 3,
"slippagePipsPerLeg": 0.3,
"overnightPipsPerDay": 0.3,
"_calendario": "Nessuna entrata nei blackoutBeforeMin minuti prima e blackoutAfterMin dopo un evento ad alto impatto sulle valute del basket; niente entrate dal venerdì fridayCutoffUtcHour UTC alla riapertura né nei primi openDelayMinutes dopo l'apertura settimanale; sessions = fasce orarie UTC ammesse (vuoto = sempre).",
"blackoutBeforeMin": 45,
"blackoutAfterMin": 30,
"fridayCutoffUtcHour": 20,
"openDelayMinutes": 30,
"sessions": [],
"_sizing": "Lotto B = lotto A × (ATR_A × pipValue_A) / (ATR_B × pipValue_B); lotto A tale che la perdita allo stop valga riskPerBasketPct dell'equity; leva effettiva <= maxEffectiveLeverage sul nozionale complessivo; orderLeverage è la leva dichiarata a eToro per ogni gamba (1, 2, 5, 10, 20, 30).",
"maxEffectiveLeverage": 10,
"orderLeverage": 10,
"_volScale": "zIn effettivo = zIn × clamp(σ_prevista / σ_media_30g, volScaleMin, volScaleMax).",
"volScaleMin": 0.8,
"volScaleMax": 1.5,
"volAverageDays": 30,
"mlMinProbability": 0.55,
"_sicurezza": "equityStopPct: perdita dal picco di equity (al netto dei movimenti di cassa) oltre la quale il bot chiude tutto e si blocca (reset manuale con motivazione). dailyLossPct: perdita giornaliera oltre la quale niente nuove entrate fino alle 00:00 UTC, anche se poi l'equity recupera.",
"equityStopPct": 9,
"dailyLossPct": 3,
"legTimeoutSec": 5,
"clockSkewMaxSeconds": 5,
"_risk": "Margine (5.0, §10). La size di un basket è il minimo fra la size a rischio e quella a margine. maxMarginUsePct: margine totale impegnato dopo l'apertura, in % dell'equity. maxMarginPerBasketPct: margine delle due gambe di un basket, in % dell'equity. marginBufferPct: il disponibile deve superare il margine richiesto di questa percentuale prima di inviare A e, ricontrollato, prima di inviare B (altrimenti A viene richiusa). closeForeignOnKill: il kill-switch chiude anche le posizioni non aperte dal bot (Telegram /kill, file STOP); nel dialogo del kill-switch è solo la scelta di partenza della casella. marginCallBlockRatio / marginCallCloseRatio: sotto equity/margine usato = 1,5 niente entrate; sotto 1,2 si chiude il basket con il P&L peggiore.",
"risk": {
"maxMarginUsePct": 40,
"maxMarginPerBasketPct": 12,
"marginBufferPct": 25,
"closeForeignOnKill": false,
"marginCallBlockRatio": 1.5,
"marginCallCloseRatio": 1.2
},
"_recovery": "Recupero dopo inattività (5.0, §6). Il bot scrive data/state/heartbeat.json ogni heartbeatSeconds; se all'avvio o fra due cicli passano più di thresholdMinutes (riavvio, sospensione del PC, aggiornamento, container fermo) blocca le entrate, risolve gli ordini senza esito, riconcilia, riscalda le serie con le barre perse e rivaluta ogni basket aperto come a una chiusura di barra ordinaria (chiudi o tieni; le orfane si chiudono, le esterne si riportano); scrive reports/recupero_<run_id>.csv e riapre le entrate dopo warmupMinutes di quotazioni. A mercato chiuso aspetta la riapertura.",
"recovery": {
"thresholdMinutes": 10,
"warmupMinutes": 15,
"heartbeatSeconds": 30
},
"_learning": "Apprendimento (ADR-0006). Di fabbrica tutto spento: restano il ledger, le tabelle di calibrazione, la previsione di volatilità e la logistica in ombra (p_ML nel ledger, mai un cancello). enabled = true riaccende il ciclo settimanale (weeklyCycle) e il challenger MLP (challenger) solo dopo il criterio di riattivazione di docs/ML_AND_LEARNING.md: almeno 300 basket chiusi in Demo e P&L netto forward >= 0 sulla pre-registrazione. Il bandit propone soltanto, non applica mai il preset.",
"learning": {
"enabled": false,
"weeklyCycle": false,
"challenger": false
},
"_baskets": "I cinque basket della specifica. Il cross sintetico e il verso delle gambe sono derivati dai codici delle valute, non configurati.",
"baskets": [
{ "a": "EURUSD", "b": "USDCHF", "enabled": true, "note": "cross sintetico EURCHF" },
{ "a": "AUDUSD", "b": "USDCAD", "enabled": true, "note": "cross sintetico AUDCAD" },
{ "a": "NZDUSD", "b": "EURNZD", "enabled": true, "note": "cross sintetico EURUSD: replica EURUSD pagando due spread" },
{ "a": "USDCAD", "b": "EURUSD", "enabled": true, "note": "cross sintetico EURCAD (stessa esposizione del basket 5)" },
{ "a": "EURAUD", "b": "AUDCAD", "enabled": true, "note": "cross sintetico EURCAD (stessa esposizione del basket 4)" }
]
}
+35
View File
@@ -0,0 +1,35 @@
#!/bin/sh
# Encelado — entrypoint del container.
#
# 1. Fuso orario da TZ (tzdata è nell'immagine).
# 2. Utente e gruppo da PUID/PGID (default 99/100, i «nobody:users» di Unraid):
# /config e /data vengono riassegnati a quell'utente, così i file scritti dal
# bot sono leggibili dalla share appdata senza giochi di permessi.
# 3. exec del processo finale con gosu: PID 1 è dotnet, SIGTERM arriva a lui.
#
# Con PUID=0 il bot resta root: sconsigliato, ma ammesso per il debug.
set -eu
PUID="${PUID:-99}"
PGID="${PGID:-100}"
if [ -n "${TZ:-}" ] && [ -f "/usr/share/zoneinfo/${TZ}" ]; then
ln -sf "/usr/share/zoneinfo/${TZ}" /etc/localtime
echo "${TZ}" > /etc/timezone
fi
if [ "${PUID}" != "0" ]; then
if ! getent group "${PGID}" >/dev/null 2>&1; then
groupadd -g "${PGID}" encelado
fi
if ! getent passwd "${PUID}" >/dev/null 2>&1; then
useradd -r -o -u "${PUID}" -g "${PGID}" -M -d /data -s /usr/sbin/nologin encelado
fi
mkdir -p /config /data
chown -R "${PUID}:${PGID}" /config /data
echo "encelado: avvio come uid ${PUID} gid ${PGID}, fuso ${TZ:-UTC}"
exec gosu "${PUID}:${PGID}" "$@"
fi
echo "encelado: avvio come root (PUID=0), fuso ${TZ:-UTC}"
exec "$@"
+145
View File
@@ -0,0 +1,145 @@
# Encelado su Unraid
Il template `encelado.xml` installa il container dall'immagine sul registro di Gitea
(`192.168.30.23:3000/alby96/encelado:latest`). Dalla 5.1 il container ha **una sola
variabile**, la password dell'interfaccia: conto, chiavi eToro, Telegram e ogni altra
impostazione si fanno dalla pagina. Dettagli su volumi, variabili, healthcheck e rete in
`docs/DOCKER.md`; guida operativa in `docs/RUNBOOK.md`.
## 1. Il registro di Gitea è in HTTP: dillo a Docker di Unraid
Docker rifiuta un registro senza TLS finché non è dichiarato «insecure». Su Unraid, dal
terminale (o da *Tools ▸ Terminal*):
```sh
echo 'DOCKER_OPTS="--insecure-registry 192.168.30.23:3000"' >> /boot/config/docker.cfg
/etc/rc.d/rc.docker restart # oppure Impostazioni ▸ Docker: disabilita e riabilita
docker info | grep -A2 "Insecure Registries" # deve elencare 192.168.30.23:3000
```
Il repository Encelado è pubblico, quindi anche il pacchetto lo è: `docker pull` non ha
bisogno di login. Se un giorno diventa privato: `docker login 192.168.30.23:3000` con
utente Gitea e un token con permesso `package:read`.
## 2. Installa dal template
*Docker ▸ Add Container*, in fondo alla pagina **Template repositories** non serve: incolla
l'URL del template nel campo **Template** (in alto, «Select a template» ▸ voce vuota, poi il
campo URL), oppure scarica il file e mettilo in `/boot/config/plugins/dockerMan/templates-user/`:
```
http://192.168.30.23:3000/Alby96/Encelado/raw/branch/main/deploy/unraid/encelado.xml
```
Lo stesso file è allegato a ogni release su Gitea con la versione nel nome.
## 3. Compila i campi
| Campo | Cosa mettere |
|---|---|
| **Porta web** | `8080` (o un'altra libera: la WebUI del container la segue) |
| **Configurazione (/config)**, **Dati (/data)** | lascia i default `/mnt/user/appdata/encelado/config` e `/mnt/user/appdata/encelado/data` |
| **Password interfaccia** (`ENCELADO_PASSWORD`) | **obbligatoria**: una frase lunga a piacere. Apre l'interfaccia e cifra le chiavi eToro e il token Telegram che salverai dalla pagina. Senza, il server ascolta solo dentro il container e dalla rete non si vede niente |
Non serve altro: niente chiavi, ambiente, modalità, `TZ`, `PUID`/`PGID` (l'immagine usa
99/100, `nobody:users`; `TZ` lo aggiunge Unraid da sé e vale solo per gli orari mostrati dal
server e per il log).
## 4. Primo avvio
1. **Apply**. Il container semina `encelado.json` e `strategy.json` in `/mnt/user/appdata/encelado/config`.
2. Apri `http://<ip-unraid>:8080/` e scrivi la password (resta in un cookie per trenta giorni).
3. **Impostazioni ▸ Conto**: il conto è `Demo`. Nella scheda delle chiavi del conto demo incolla
`x-api-key` e `x-user-key` (dal portale sviluppatori eToro; demo e reale hanno chiavi
diverse) e premi **Verifica e salva**: vengono provate su quel conto e salvate cifrate in
`/config/secrets.enc`.
4. Facoltativo: **Impostazioni ▸ Notifiche Telegram** (token del bot, chat, notifiche, comandi;
**Invia messaggio di prova**), valuta e tema in Interfaccia, preset in Strategia.
5. Premi **AVVIA** (⏻ in alto a destra). La pill del motore nella barra in alto dice `DEMO`. Con
«Avvio automatico» acceso (di fabbrica) ai riavvii successivi il motore parte da solo.
6. Per un test lungo guarda: contatori di Posizioni (le orfane devono restare 0), **Storico ▸
Ordini** (unità richieste ed eseguite uguali, esito `Filled`), il Log. Il kill-switch è
**KILL** in alto a destra, o un file `STOP` in `/mnt/user/appdata/encelado/config`.
Il log è in `docker logs encelado` e in `/mnt/user/appdata/encelado/data/logs/encelado.log`; il
ledger in `.../data/data/ledger/`.
Le chiavi e il token si cambiano **sempre dalla pagina** (Impostazioni ▸ Conto, Notifiche
Telegram), anche più avanti: una variabile come `ETORO_API_KEY` aggiunta al container viene
ignorata (e segnalata), e il bot continuerebbe con le chiavi vecchie.
## 5. Aggiornare un container 5.0 alla 5.1
Il container 5.0 ha una dozzina di variabili (chiavi eToro, `ETORO_ENVIRONMENT`,
`ENCELADO_EXECUTION_MODE`, `ENCELADO_WEB_TOKEN`, Telegram, `TZ`, `PUID`/`PGID`…). La 5.1 le
legge **una volta sola**, al primo avvio, e poi le ignora. Quindi:
1. **Prima di aggiornare non togliere niente.** Le variabili servono al primo avvio della 5.1
per portare chiavi, token, chat e impostazioni nel posto nuovo. Se le chiavi erano salvate
dall'interfaccia della 5.0 (`/config/etoro.keys.enc`), lascia anche `ENCELADO_KEY_PASSPHRASE`.
Facoltativo ma consigliato: una copia di `/mnt/user/appdata/encelado`.
2. **Rinomina la password**: *Docker ▸ Encelado ▸ Edit*, sul campo `ENCELADO_WEB_TOKEN` premi
*Edit* e cambia la **Key** in `ENCELADO_PASSWORD`, **con lo stesso valore** (e *Password
Mask* acceso). La password dell'interfaccia resta quella di prima e i segreti che la 5.1
cifrerà con lei restano leggibili. (Anche lasciandola com'è la 5.1 parte: `ENCELADO_WEB_TOKEN`
vale come alias deprecato, con un avviso.)
3. **Apply**: Unraid scarica `:latest` (la 5.1) e riavvia il container. Al primo avvio la 5.1:
- importa le variabili e i file della 5.0 (`docker logs encelado`: «importazione una tantum
dalla 5.0: …»; il resoconto resta in `/config/import-5.1.json`); il vecchio
`etoro.keys.enc` diventa `etoro.keys.enc.migrato`;
- sposta lo stato del motore nel file del suo conto (`baskets_state.json` →
`baskets_state.demo.json` o `.live.json`; l'originale resta come `.migrato`) e riprende i
basket aperti. Il conto è quello su cui lavorava la 5.0 (con `ENCELADO_EXECUTION_MODE=Live`
e `ETORO_ENVIRONMENT=demo` era il conto demo): per questo al primo avvio le variabili vanno
lasciate come sono. Lo stato della modalità Paper non viene ripreso (il log dice «non
ripreso: …»);
- verifica sullo storico eToro il P&L delle righe scritte dalla 4.0.0-5.0.0 (che erano i
proceeds delle chiusure, non il profitto) e scrive righe di correzione; se ne ha corrette,
mette da parte una volta i modelli addestrati su quei numeri.
4. Apri la pagina con la **stessa password** (serve un nuovo accesso: il cookie della 5.1 contiene
anche un segreto del server, `/config/session.key`, creato ora). Controlla **Sistema ▸ Segreti** (chiavi del conto
demo, ed eventualmente reale, presenti; la nota dell'importazione) e la striscia sotto la
barra in alto: «Variabili d'ambiente ignorate: …» elenca quelle da togliere.
5. *Edit* di nuovo e **togli tutte le variabili tranne `ENCELADO_PASSWORD`**: `ETORO_API_KEY`,
`ETORO_USER_KEY`, `ETORO_ENVIRONMENT`, `ENCELADO_EXECUTION_MODE`, `ENCELADO_KEY_PASSPHRASE`,
`ENCELADO_CONFIRM_LIVE`, `ENCELADO_AUTOSTART`, `ENCELADO_DISPLAY_CURRENCY`,
`ENCELADO_LOG_LEVEL`, `TELEGRAM_BOT_TOKEN`, `TELEGRAM_CHAT_ID`, e anche i campi `TZ`,
`PUID` e `PGID` del template vecchio (l'immagine usa già 99/100 e Unraid aggiunge `TZ` da
sé). **Apply**: la striscia non elenca più niente.
6. Nella pagina **Apprendimento** premi **Esegui ciclo**, per rifare calibrazione e intuizioni
sulle etichette corrette.
Se a un certo punto la password **cambia** (un valore diverso da quello della 5.0), la pagina
si apre con la nuova ma i segreti risultano **bloccati** (striscia rossa «SEGRETI BLOCCATI»,
il motore non parte): in **Impostazioni ▸ Conto** scegli **Sblocca con la password
precedente** e scrivi quella vecchia (i segreti vengono ricifrati con la nuova), oppure
**Ricomincia** (il deposito vecchio resta come `secrets.enc.<data>.bak`) e reinserisci chiavi e
token.
Se il container 5.0 lavorava in **Live**: la 5.1 non parte mai da sola sul conto reale. Dopo
l'aggiornamento (e dopo ogni riavvio) premi **AVVIA** e scrivi `CONFERMO LIVE`; nel frattempo i
basket aperti hanno solo gli stop nativi. Dalla 5.1 la modalità è anche il conto: un file o
delle variabili della 5.0 valgono Live solo se dicevano modalità `Live` **e** ambiente `real`
(il Live delle variabili viene importato solo con «Consenti il conto reale» acceso);
altrimenti la 5.1 lavora sul conto demo e il log dice perché.
## 6. Aggiornamenti successivi
*Docker ▸ Check for Updates*: il tag `latest` segue l'ultima release. Il container si ferma
con SIGTERM (45 s di grazia): i basket aperti restano sul conto con gli stop nativi e
vengono ripresi dallo stato del conto e dalla riconciliazione al riavvio (`docs/RUNBOOK.md`,
«Recupero dopo inattività»); un kill-switch in corso ha 30 s per finire. Per tornare a una
versione precisa cambia il tag nel campo **Repository** (`…/encelado:5.1.0`).
## Reverse proxy
Se metti l'interfaccia dietro un reverse proxy (Nginx Proxy Manager, SWAG, Caddy, Traefik),
il proxy deve passare l'header `Host` originale o `X-Forwarded-Host`, altrimenti ogni
salvataggio e ogni comando ricevono 403. I proxy citati lo fanno di fabbrica; un `nginx`
scritto a mano vuole `proxy_set_header Host $host;`. Dietro il proxy tutti i client sembrano
un solo indirizzo: l'attesa dopo una password sbagliata vale per tutti.
## Icona
`assets/encelado.png` nel repository, servita da Gitea come file raw (`Icon` nel
template). Non serve pubblicarla altrove (D-29).
+29
View File
@@ -0,0 +1,29 @@
<?xml version="1.0"?>
<Container version="2">
<Name>Encelado</Name>
<Repository>192.168.30.23:3000/alby96/encelado:latest</Repository>
<Registry>http://192.168.30.23:3000/Alby96/-/packages/container/encelado</Registry>
<Network>bridge</Network>
<MyIP/>
<Shell>sh</Shell>
<Privileged>false</Privileged>
<Support>http://192.168.30.23:3000/Alby96/Encelado/issues</Support>
<Project>http://192.168.30.23:3000/Alby96/Encelado</Project>
<Overview>Encelado: bot di trading "Correlation Baskets" su eToro (Public API). Motore, ledger e interfaccia web in un solo container. L'unica cosa da scegliere qui e' la password dell'interfaccia: tutto il resto (conto demo o reale, chiavi eToro dei due conti, Telegram, strategia, valuta, log) si imposta dalla pagina Impostazioni, e il bot applica subito ogni cambio. Le chiavi e il token Telegram restano cifrati in /config con questa password: se la cambi, l'interfaccia chiede quella precedente per riaprirli. La modalita' Live non parte mai da sola: serve AVVIA e la frase CONFERMO LIVE. Configurazione in /config, dati in /data (ledger, stato, barre, conoscenza, rapporti, log).</Overview>
<Category>Tools: Productivity:</Category>
<WebUI>http://[IP]:[PORT:8080]/</WebUI>
<TemplateURL>http://192.168.30.23:3000/Alby96/Encelado/raw/branch/main/deploy/unraid/encelado.xml</TemplateURL>
<Icon>http://192.168.30.23:3000/Alby96/Encelado/raw/branch/main/assets/encelado.png</Icon>
<ExtraParams>--restart=unless-stopped --stop-timeout 45</ExtraParams>
<PostArgs/>
<CPUset/>
<DateInstalled/>
<DonateText/>
<DonateLink/>
<Requires/>
<Config Name="Porta web" Target="8080" Default="8080" Mode="tcp" Description="Porta dell'interfaccia web e dell'API (http://IP:porta/)." Type="Port" Display="always" Required="true" Mask="false">8080</Config>
<Config Name="Configurazione (/config)" Target="/config" Default="/mnt/user/appdata/encelado/config" Mode="rw" Description="encelado.json, strategy.json, instruments.json e i segreti cifrati (secrets.enc). Seminati al primo avvio dai valori di fabbrica; si modificano dall'interfaccia." Type="Path" Display="always" Required="true" Mask="false">/mnt/user/appdata/encelado/config</Config>
<Config Name="Dati (/data)" Target="/data" Default="/mnt/user/appdata/encelado/data" Mode="rw" Description="Ledger (data/ledger), stato (data/state), barre, cache dei feed, conoscenza, rapporti e log. Non cancellare: il ledger e' la memoria del bot." Type="Path" Display="always" Required="true" Mask="false">/mnt/user/appdata/encelado/data</Config>
<Config Name="Password interfaccia" Target="ENCELADO_PASSWORD" Default="" Mode="" Description="Password di accesso all'interfaccia web (una frase lunga a piacere). Cifra anche le chiavi eToro e il token Telegram salvati dall'interfaccia. Senza password il server ascolta solo su localhost del container e l'interfaccia non e' raggiungibile dalla rete." Type="Variable" Display="always" Required="true" Mask="true"></Config>
</Container>
+33
View File
@@ -0,0 +1,33 @@
# Encelado in locale con Docker Compose: immagine costruita dalla Dockerfile alla
# radice, cartelle di configurazione e dati sotto deploy/local (ignorate da git).
#
# docker compose up --build # costruisce e avvia, log a video (Ctrl+C = stop pulito)
# docker compose up -d --build # in background → http://localhost:8080/ (password "sviluppo")
# docker compose logs -f encelado # segue il log
# docker compose down # ferma (SIGTERM: stop pulito del motore)
# Oppure: scripts/run-docker.ps1 (o .sh), che fa le stesse cose e stampa l'indirizzo.
#
# L'unica variabile è la password dell'interfaccia (ENCELADO_PASSWORD, di default
# "sviluppo", la stessa di F5 e degli script, così i segreti cifrati in deploy/local
# restano leggibili in entrambi i modi; una vera in un file .env accanto a questo).
# Conto, chiavi eToro, Telegram e tutto il resto si impostano dall'interfaccia.
# Per Unraid usa invece il template in deploy/unraid/encelado.xml.
services:
encelado:
build:
context: .
args:
GIT_COMMIT: ${GIT_COMMIT:-n/d}
VERSION: ${VERSION:-dev}
image: 192.168.30.23:3000/alby96/encelado:${VERSION:-dev}
container_name: encelado
restart: unless-stopped
ports:
- "${ENCELADO_WEB_PORT:-8080}:8080"
volumes:
- ./deploy/local/config:/config
- ./deploy/local/data:/data
environment:
ENCELADO_PASSWORD: ${ENCELADO_PASSWORD:-sviluppo}
stop_grace_period: 45s
+484
View File
@@ -0,0 +1,484 @@
# API dell'interfaccia web (5.1)
Aggiornato: 2026-10-01. È il contratto fra il server (`src/Encelado.Server/Web`) e l'interfaccia (`Web/wwwroot`): i nomi dei campi qui sono quelli veri. Chi cambia un campo aggiorna questo file nello stesso commit.
## Convenzioni
- JSON scritto a mano con `Utf8JsonWriter` (nessuna serializzazione per riflessione); nomi dei campi in inglese, camelCase.
- **Importi in USD**: la conversione nella valuta di visualizzazione la fa solo il browser, con `fxRates` del tick.
- **Tempi** in ISO-8601 UTC (`"O"`, es. `2026-09-30T08:15:04.1230000Z`); il browser li mostra nel proprio fuso.
- Numeri non finiti (NaN, ∞) → `null`. Un valore sconosciuto è `null`, mai `0`.
- Testi per l'operatore (motivazioni, intenti, messaggi) in italiano.
- Le risposte dei comandi e delle scritture hanno sempre `{ "ok": bool, "message": string }` più i campi propri.
- Autenticazione: se il container ha `ENCELADO_PASSWORD` (alias deprecato `ENCELADO_WEB_TOKEN`) ogni rotta chiede il cookie `encelado_session` o `Authorization: Bearer <password>`; senza sessione le rotte `/api/*` rispondono **401**, le pagine rimandano a `/login`. Libere: `/login`, `/logout`, `/api/health`, `/css/*`, `/img/*`, `/icon.svg`, `/manifest.webmanifest`. Una password errata — dal form o dall'header Bearer — costa al suo indirizzo un'attesa che raddoppia fino a 30 s (vedi [Accesso](#accesso)); il cookie non è una password: valido entra anche durante l'attesa, sbagliato riceve 401 subito.
- Rete: il server ascolta su tutte le interfacce solo con una password **e** nel container (o con l'argomento `--listen-all`); fuori dal container (F5, `run-dev`) resta su localhost anche con la password, che lì serve ai segreti della sandbox. Senza password ascolta solo su localhost e non chiede niente.
- Richieste da altrove: vedi [Richieste che cambiano qualcosa](#richieste-che-cambiano-qualcosa) (`Content-Type: application/json`, `Origin`, `Sec-Fetch-Site`, Host senza password).
- `--sample`: ogni rotta risponde con dati d'esempio realistici e coerenti fra loro (nessuna chiave, nessun mercato), per lavorare sulle pagine e fotografarle. Il server campione lavora in cartelle temporanee (cancellate all'uscita): non legge né scrive la configurazione, i segreti o i dati dell'operatore e non apre il bot Telegram. Le impostazioni sono quelle di fabbrica e ogni scrittura (comandi, impostazioni, segreti) risponde **400** «modalità dimostrativa (--sample)».
## File statici
Ogni file incorporato sotto `wwwroot/` è servito al suo percorso (`/css/app.css`, `/js/app.js`, `/js/pages/dashboard.js`, `/img/…`), con il tipo dal suffisso (`.html`, `.css`, `.js` come `text/javascript`, `.svg`, `.webmanifest`, `.png`, `.ico`), `ETag` e `Cache-Control: no-cache` (la richiesta con `If-None-Match` uguale riceve **304**). `/` → `index.html`, `/login` → `login.html`.
L'interfaccia (docs/UI_GUIDELINES.md): `index.html` carica `/css/tokens.css`, `/css/app.css`, `/css/pages/<pagina>.css`, lo script classico `/js/boot.js` (il tema prima del primo disegno) e il modulo `/js/app.js`, che importa staticamente gli altri moduli di `/js/` e `/js/pages/`. `login.html` non ha script (`/js/*` chiede la sessione) e porta il segnaposto `<!--login-error-->`.
## Accesso
- `GET /login` — la pagina.
- `POST /login` — form `password` (accettato anche `token`, il nome della 5.0). Corretta: cookie `encelado_session` (HttpOnly, SameSite=Strict, 30 giorni) e **302** su `/`. Il cookie è un HMAC della password e di un segreto del server (32 byte casuali in `/config/session.key`, creato al primo avvio con una password e tenuto fra un riavvio e l'altro), mai la password: senza il segreto non si calcola da una password indovinata. Cambiare la password, o cancellare `session.key`, chiude tutte le sessioni. Errata: **401** con la pagina di login e il messaggio (`<p class="login-error" role="alert">`), messo al posto del segnaposto `<!--login-error-->` se la pagina lo contiene, altrimenti prima di `</form>`, dopo l'attesa qui sotto.
- `POST /logout` — cancella il cookie, **302** su `/login`.
- `/login` e `/logout` sono form semplici: **403** se l'`Origin` nomina un altro host o porta (vedi sotto); `Sec-Fetch-Site` e `Content-Type` non contano.
Il prezzo di una password errata (uguale per il form e per `Authorization: Bearer`, contato per indirizzo del client; un client IPv6 per il suo /64): la risposta errata arriva dopo 1 s, poi 2, 4, 8, 16 e al più 30 s per ogni errore di fila. Finché l'attesa non è finita nessuna password di quell'indirizzo viene controllata, nemmeno quella giusta: la richiesta riceve **429** con `Retry-After` (JSON `{ ok: false, message }` sotto `/api/`, la pagina di login con «Troppi tentativi…» altrove). Così i tentativi in parallelo non aiutano. Una password giusta azzera il conto; dieci minuti senza errori lo dimenticano. Il cookie di sessione **non** passa da qui: valido, la richiesta entra subito anche mentre l'indirizzo aspetta (chi tenta password dietro lo stesso NAT, /64 o reverse proxy non tiene fuori una pagina già entrata, né le azzera il conto); sbagliato (una scheda rimasta aperta dopo un cambio di password) o assente, la richiesta non è un tentativo: 401 (o la pagina di login) subito. L'interfaccia, a un 401 o a un 429, torna alla pagina di login e smette di interrogare il server. Gli altri indirizzi non aspettano (dietro un reverse proxy che mostra a Encelado un solo indirizzo, l'attesa per le password vale per tutti).
## Richieste che cambiano qualcosa
Controllate prima di guardare la password, su ogni rotta:
- **Senza password** il server risponde **403** a ogni richiesta (anche GET) il cui header `Host` non è `localhost`, `127.0.0.1` o `[::1]`, con o senza porta: una pagina che fa puntare il proprio nome a 127.0.0.1 (DNS rebinding) manda il suo nome.
- Ogni metodo diverso da GET, HEAD e OPTIONS riceve **403** se `Sec-Fetch-Site` è presente e diverso da `same-origin` o `none` (un'altra origine, anche `same-site`), oppure se `Origin` è presente e il suo host:porta è diverso da quello dell'header `Host` (o di `X-Forwarded-Host`, per un reverse proxy che riscrive l'Host; un `Host` senza porta confronta il solo nome). `Origin: null` è sempre un'altra origine. Senza `Origin` né `Sec-Fetch-Site` (uno script con curl) il controllo non scatta. `/login` e `/logout` hanno solo il controllo dell'`Origin`.
- Sotto `/api/` ogni POST e DELETE (ogni metodo diverso da GET, HEAD e OPTIONS) deve dire `Content-Type: application/json`, anche senza corpo (`DELETE /api/settings/keys?account=demo`, `POST /api/settings/secrets/reset`…): altrimenti **415**. Un form o una fetch "semplice" di un altro sito non possono mandarlo senza un preflight CORS, che il server non concede mai.
Le risposte di rifiuto sotto `/api/` sono `{ ok: false, message }`.
## Il flusso in tempo reale
### `GET /api/stream` (Server-Sent Events)
Un tick al secondo, `event: snapshot`, la stessa serializzazione condivisa da tutti i client (niente viene calcolato se nessuno è connesso). Il primo tick arriva subito; il server manda `retry: 3000`. Un client lento riceve solo il tick più recente.
### `GET /api/snapshot`
Lo stesso tick, una volta (per il polling senza `EventSource` e per gli screenshot con `?once=1`).
### Il tick (v2)
`nowUtc` è sempre il primo campo.
```ts
type Tick = {
nowUtc: string; // primo campo
v: 2;
frame: number; // contatore dei tick del server
state: "stopped" | "starting" | "running" | "stopping" | "faulted";
error: string; // vuoto se nessun errore
account: "demo" | "live"; // modalità: Demo = conto demo, Live = conto reale
preset: "Conservative" | "Moderate" | "Aggressive";
startedAtUtc: string | null;
uptimeSeconds: number;
engineTickAgeSeconds: number | null; // da quanto il ciclo di decisione non gira (null a motore fermo)
heartbeatSeconds: number; // intervallo del battito del motore in esecuzione (recovery.heartbeatSeconds, 5-600, cambia senza riavvio); 0 se fermo.
// L'heartbeat è vecchio oltre 3 × heartbeatSeconds + 15 s (105 s con il default 30): è la soglia di /api/health
alarms: {
halted: boolean; // kill-switch o equity stop: entrate bloccate fino al reset
haltKind: "" | "kill" | "equity";
haltReason: string;
haltedWithResidue: boolean; // Halted-Residuo: posizioni del bot ancora sul conto
residueCount: number;
entriesBlockedReason: string; // vuoto se le entrate sono libere
entriesBlockedUntilUtc: string | null;
paused: boolean; // pausa dell'operatore (/pausa)
unreconciled: boolean;
unreconciledReason: string;
dailyLossHit: boolean; // il calo dell'equity netta da mezzanotte è oltre la soglia adesso, o lo è stato al minimo di un calo del saldo
// che lo storico eToro non spiega ancora (entrate sospese finché non si chiarisce); il blocco della giornata è dailyLossLatched
recoveryPending: boolean;
secretsLocked: boolean; // segreti cifrati con un'altra password
liveNeedsConfirmation: boolean; // modalità Live, motore fermo: serve AVVIA con la frase
ignoredEnv: string[]; // variabili d'ambiente ignorate (da togliere dal container)
};
closeForeignOnKill: boolean; // strategy.json → risk.closeForeignOnKill: da qui parte la casella «posizioni esterne» del dialogo del
// kill-switch; la scelta del dialogo, sempre esplicita, vale per quel kill-switch (vedi il comando kill)
equity: number | null;
balance: number | null;
availableBalance: number | null;
usedMargin: number | null;
marginRatio: number | null; // equity / margine usato (null senza margine)
peakEquity: number | null; // al netto dei movimenti di cassa
drawdownPct: number | null; // 0..1
equityStopPct: number; // 0..1, dalla strategia
dailyLossPct: number; // 0..1, soglia dalla strategia
dailyLossUsedPct: number | null;// 0..1: quanto della soglia giornaliera è consumato
dailyLossLatched: boolean; // D-52: la perdita giornaliera è stata raggiunta oggi; niente nuove entrate né aggiunte fino alle 00:00 UTC,
// anche se l'equity recupera. Sopravvive al riavvio (stato del conto); false a motore fermo.
// Un calo del saldo che lo storico eToro non spiega ancora (forse un prelievo) sospende subito le entrate
// (dailyLossHit), anche se intanto l'equity recupera; quando lo storico lo spiega, se era una perdita la
// giornata si blocca (giudicata sul minimo toccato nel frattempo), se era un movimento di cassa no.
cumulativeCashFlow: number;
todayPnl: number | null; // realizzato netto (netProfit − fees) delle posizioni del bot chiuse oggi UTC, dallo storico eToro (+ stime provvisorie)
todayPnlPct: number | null; // todayPnl / equity netta di inizio giornata
todayPnlProvisional: boolean; // true se contiene stime non ancora confermate dallo storico
todayEquityChange: number | null; // equity netta ora − equity netta alle 00:00 UTC (realizzato + variazione dell'aperto, cassa esclusa)
dayStartEquity: number | null;
todayClosed: { baskets: number; won: number; lost: number; loneLegs: number };
openPnl: number | null; // P&L aperto dei basket del bot
accountOpenPnl: number | null; // P&L aperto di tutto il conto
openBaskets: number;
maxBaskets: number;
pendingBaskets: number;
pendingOrders: number;
orphanLegs: number;
foreignPositions: number;
displayCurrency: string; // USD, EUR, GBP, CHF, JPY, AUD, CAD, NZD
theme: "dark" | "light";
navExpanded: boolean;
statusLines: number; // logging.statusLines (Impostazioni ▸ Log ▸ righe di attività): quante righe tiene la striscia della dashboard,
// 20-2000 (il browser ne tiene 2000; un valore più grande scritto a mano nel file vale 2000); cambia subito
fxRates: Record<string, { usdPerUnit: number; ageSeconds: number | null }>; // USD compreso (1)
baskets: TickBasket[];
quotes: Array<{ symbol: string; bid: number | null; ask: number | null; spreadPips: number | null; spreadMedianPips: number | null; ageSeconds: number | null }>;
// solo gli strumenti dei basket; le coppie di sola conversione (GBPUSD, USDJPY) sono in /api/market.
// bid e ask sono null per uno strumento non ancora quotato (subito dopo AVVIA); spreadPips anche, finché non c'è né una
// quotazione né una barra. La pagina mostra «—», mai 0
health: {
api: "ok" | "degraded" | "error" | "off";
apiLatencyMs: number | null; // solo il viaggio HTTP, senza attese del limitatore
clockSkewSeconds: number | null;
quotaPeakPct: number | null; // 0..1: la classe di quota più usata
feeds: "ok" | "stale" | "error" | "off";
telegram: "ok" | "queue" | "error" | "off";
heartbeatAgeSeconds: number | null;
secrets: "open" | "empty" | "locked" | "localKey";
sseClients: number;
};
learning: {
mode: "ombra-disabilitato" | "ombra" | "attivo";
labelledRows: number; // basket etichettati come li conta il dataset (con le feature d'ingresso): lo stesso numero di dataset.labelledRows
// di /api/learning; ricontato dal ledger all'avvio dopo la verifica del realizzato e a ogni ciclo
target: number; // 300
rollingAuc: number | null;
banditPreset: string; // proposta, mai applicata
volModel: string; // "EWMA" | "HAR"
cycleRunning: boolean;
warnings: number;
};
nextEvent: { timeUtc: string; currency: string; title: string; impact: "High" | "Medium" | "Low" } | null;
events: Array<{ seq: number; timeUtc: string; level: "trace" | "debug" | "info" | "warn" | "error"; source: string; message: string }>;
// solo le righe di log nuove dall'ultimo tick (≤ 100), già su una riga; il client recupera il pregresso con /api/log
eventsSeq: number; // l'ultimo seq emesso finora
versions: { positions: number; market: number; learning: number; settings: number; system: number; history: number };
// un numero cambia quando la sezione cambia: il client rilegge l'endpoint solo allora
};
type TickBasket = {
name: string; // "EURUSD/USDCHF"
pairA: string; pairB: string;
cross: string; // cross sintetico, "EURCHF"
currencies: string[]; // valute coinvolte, es. ["EUR","USD","CHF"] (per le bandiere)
state: "Idle" | "Entering" | "PendingA" | "PendingB" | "Open" | "Adding" | "Exiting" | "Closed" | "Error" | "Disabled";
enabled: boolean;
isOpen: boolean;
side: "" | "buy" | "sell"; // verso del cross quando aperto
openLegs: number;
z: number | null; zIn: number | null; zOut: number | null; zStop: number | null;
rho: number | null; rhoShort: number | null; halfLife: number | null;
pips: number | null; tpPips: number; pnlUsd: number | null; costPips: number | null;
spreadRatioMax: number | null; // spread attuale / mediana 24 h, il peggiore delle due gambe
pMl: number | null; mlActive: boolean;
barsHeld: number; adds: number; entryZ: number | null;
minutesToEvent: number | null;
nextEvent: string; // etichetta del motore: "USD 13:33 Core PCE Price Index m/m (fra 37 min)", ora UTC; "—" o
// "nessun evento ad alto impatto noto" se non c'è. Il browser la mostra nel proprio fuso.
intent: string; // cosa farebbe il bot adesso, o perché non entra (italiano)
reasonCodes: string[];
};
```
## Sezioni a richiesta
Ogni sezione ha `asOfUtc`, un `ETag` e risponde **304** a `If-None-Match` uguale. Il client la rilegge quando cambia il numero corrispondente in `versions`, o ogni 30 s mentre la pagina è visibile.
### `GET /api/positions`
Le posizioni del conto, classificate a ogni riconciliazione (nessuna chiamata a eToro in più). A motore fermo le legge dallo storico/portafoglio (`source: "history"`) se ci sono le chiavi.
```ts
{ asOfUtc: string; source: "engine" | "history" | "none"; problem: string;
totals: { count: number; unrealizedPnl: number; margin: number; fees: number;
byOrigin: Record<"basket" | "orfana-bot" | "esterna", { count: number; unrealizedPnl: number; margin: number }> };
rows: Array<{ positionId: number; symbol: string; instrumentId: number; side: "long" | "short"; units: number;
openRate: number; currentRate: number | null; pips: number | null; openedUtc: string; minutesOpen: number;
stopLoss: number | null; takeProfit: number | null; leverage: number; margin: number; exposureUsd: number | null;
unrealizedPnl: number | null; fees: number; origin: "basket" | "orfana-bot" | "esterna";
basket: string; basketId: string; leg: "A" | "B" | "add" | ""; reason: string }>;
pendingOrders: Array<{ clientRef: string; orderId: number; basket: string; basketId: string; leg: string; symbol: string;
side: "buy" | "sell"; requestedUnits: number; sentUtc: string; ageSeconds: number; lastStatus: string; checks: number }> }
```
### `GET /api/market`
```ts
{ asOfUtc: string;
quotes: Array<{ symbol: string; bid: number | null; ask: number | null; mid: number | null; spreadPips: number | null; spreadMedian24hPips: number | null;
spreadRatio: number | null; quoteUtc: string | null; ageSeconds: number | null; realtime: boolean; atrPips: number | null;
usedBy: string[]; conversionOnly: boolean }>; // bid, ask, mid e ageSeconds null finché lo strumento non è mai stato quotato
fx: Array<{ currency: string; usdPerUnit: number; sourcePair: string; inverted: boolean; timeUtc: string | null; ageSeconds: number | null }>;
calendar: { updatedUtc: string | null; state: string;
events: Array<{ timeUtc: string; currency: string; title: string; impact: "High" | "Medium" | "Low" | "Holiday";
forecast: string; previous: string; actual: string; affectsBaskets: string[]; blackout: boolean }> };
sentiment: Array<{ currency: string; net1h: number | null; net4h: number | null; net24h: number | null; hawkish4h: number | null; count24h: number }>;
riskOff4h: number | null;
news: { updatedUtc: string | null; state: string;
items: Array<{ publishedUtc: string; source: string; title: string; link: string; currencies: string[]; net: number; hawkish: number; riskOff: number }> };
volatility: Array<{ basket: string; model: "EWMA" | "HAR"; sigmaForecast: number | null; sigmaAverage30d: number | null; ratio: number | null; zInScale: number | null; bars: number }> }
```
Query facoltative: `calendarDays` (default 7), `impact` (default `High,Medium`), `news` (default 50).
### `GET /api/baskets/detail?name=EURUSD/USDCHF`
Il nome va nella query (`%2F` nel percorso non verrebbe decodificato).
```ts
{ asOfUtc: string; name: string; pairA: string; pairB: string; cross: string; signB: 1 | -1; enabled: boolean;
disabledReason: string; disabledUntilUtc: string | null; state: string; intent: string;
lastDecision: { kind: "Skip" | "Enter" | "Add" | "Exit" | "Hold"; reasonCodes: string[]; motivazione: string; atUtc: string } | null;
thresholds: { zIn: number; zInEffective: number | null; zOut: number; zStop: number; rhoMin: number; rhoShortMin: number;
halfLifeMin: number; halfLifeMax: number; tpPips: number; maxHoldingBars: number; costMultiple: number;
spreadMedianMultiple: number; spreadAnomalyMultiple: number; mlMinProbability: number };
eval: { z: number | null; dPips: number | null; rhoW: number | null; rhoShort: number | null; halfLife: number | null;
atrPipsA: number | null; atrPipsB: number | null; sigmaX: number | null; ewmaVolX: number | null; trendStrength: number | null;
priceA: number | null; priceB: number | null; spreadPipsA: number | null; spreadPipsB: number | null;
spreadMedianA: number | null; spreadMedianB: number | null; costPips: number | null; breakEvenWinRate: number | null;
cost: { passed: boolean; markupPipsA: number; markupPipsB: number; overnightPips: number; reason: string } | null } | null;
sizing: { unitsA: number; unitsB: number; notionalUsdA: number; notionalUsdB: number; lossAtStopUsd: number;
effectiveLeverage: number; marginUsd: number; bound: string } | null;
context: { minutesToNextHigh: number | null; minutesSinceLastHigh: number | null; surpriseLast: number | null;
netSentimentDiff1h: number | null; netSentimentDiff4h: number | null; netSentimentDiff24h: number | null;
hawkishDiff: number | null; riskOff: number | null; newsCount: number; nextEventLabel: string };
ml: { pMl: number | null; active: boolean; features: Array<{ name: string; label: string; value: number | null }> };
vol: { sigmaForecast: number | null; sigmaAverage30d: number | null; model: string };
position: null | { basketId: string; buyCross: boolean; openedUtc: string; minutesOpen: number; barsHeld: number; adds: number;
entryZ: number; lastAddZ: number | null; entryCostPips: number; tpPips: number; zStop: number; maxAdds: number;
pipsOpen: number | null; pnlOpenUsd: number | null; accruedFeesUsd: number; maxLossUsd: number;
stopDistanceUsd: number | null; zStopDistance: number | null; barsToTimeStop: number | null;
barsWithBrokenCorrelation: number; barsWithSpreadAnomaly: number; equityAtEntry: number; entryMotivazione: string;
legs: Array<{ leg: "A" | "B"; symbol: string; side: "buy" | "sell"; units: number; totalUnits: number; entryPrice: number;
bid: number | null; ask: number | null; pips: number | null; pnlUsd: number | null; entryFeesUsd: number;
nativeStopLoss: number | null; positionIds: number[];
venue: { unrealizedPnl: number | null; fees: number; currentRate: number | null; margin: number; leverage: number } | null }> };
pending: null | { leg: "A" | "B"; decidedUtc: string; ageSeconds: number; unitsA: number; unitsB: number; entryZ: number };
recent: Array<{ atUtc: string; evento: string; z: number | null; motivazione: string }> } // ultime 20 decisioni di chiusura barra, dalla più recente
```
### `GET /api/system`
Tutto ciò che non serve in dashboard: stato del motore, collegamento eToro, quote, feed, Telegram, processo, disco, log, informazioni.
```ts
{ asOfUtc: string;
engine: { state: string; account: "demo" | "live"; runId: string; strategyHash: string; preset: string;
startedUtc: string | null; uptimeSeconds: number; lastTickUtc: string | null; tickAgeSeconds: number | null;
heartbeatUtc: string | null; heartbeatAgeSeconds: number | null;
heartbeatSeconds: number; heartbeatStaleSeconds: number; // intervallo del battito e soglia di /api/health (3 × intervallo + 15 s); 0 a motore fermo
recoveryPending: boolean; recoveryCause: string;
entriesBlockedReason: string; entriesBlockedUntilUtc: string | null; paused: boolean; autostart: boolean;
orphanPolicy: "Close" | "Report"; instanceLock: string };
api: { endpoint: string; account: "demo" | "live"; state: string; latencyMs: number | null; latencyAvg1mMs: number | null;
clockSkewSeconds: number | null; clockSkewMaxSeconds: number; consecutiveErrors: number;
lastError: { utc: string; message: string } | null;
quotas: Array<{ name: string; used: number; limit: number; windowSeconds: number; pausedUntilUtc: string | null; count429: number }> };
feeds: Array<{ name: string; kind: "calendar" | "rss"; currency: string; host: string; lastRequestUtc: string | null;
lastSuccessUtc: string | null; failures: number; backoffUntilUtc: string | null; robotsAllowed: boolean | null; lastError: string }>;
telegram: { configured: boolean; enabled: boolean; commands: boolean; hourlyStatus: boolean; eventAlerts: boolean;
dailySummaryUtcHour: number; chatId: string; queued: number; sent: number; failed: number;
lastDeliveredUtc: string | null; lastError: string };
secrets: { state: "open" | "empty" | "locked" | "localKey"; etoro: { demo: SecretInfo; live: SecretInfo }; telegram: SecretInfo;
passwordSource: "ENCELADO_PASSWORD" | "ENCELADO_WEB_TOKEN" | "none"; ignoredEnv: string[]; importNote: string; problem: string };
process: { version: string; informationalVersion: string; commit: string; buildDate: string; dotnet: string; os: string;
container: boolean; pid: number; serverUptimeSeconds: number; workingSetBytes: number; gcHeapBytes: number;
gen0: number; gen1: number; gen2: number; gcPauseTimePct: number | null; threadPoolThreads: number; timeZone: string };
disk: { configPath: string; strategyPath: string; dataPath: string; knowledgePath: string; reportsPath: string; logFile: string;
freeBytes: number | null; totalBytes: number | null; writable: boolean; checkedUtc: string; logBytes: number | null };
log: { enqueued: number; dropped: number; bufferLines: number; bufferCapacity: number; level: string };
web: { sseClients: number; framesSent: number; lastFrameBytes: number };
about: { name: "Encelado"; author: "Alberto Balbo"; version: string; buildDate: string; commit: string; license: string; docs: string } }
type SecretInfo = { present: boolean; masked: string; savedUtc: string | null };
```
### `GET /api/learning`
Il rapporto sull'apprendimento. La parte viva la pubblica il motore (immutabile); a motore fermo e per i file di `knowledge/` la legge dal disco in sola lettura. Query: `features=all` aggiunge il vettore completo per basket. L'`ETag` è la versione della sezione (`versions.learning`) con l'impronta dei file letti — modelli, `knowledge/`, `baskets.csv`, i file delle decisioni e `strategy.json`, da cui un motore fermo prende interruttori, `pMin` e basket: anche una modifica a mano del file cambia l'`ETag` (entro 2 s) —: con `If-None-Match` uguale la risposta è **304** senza costruire niente. Ogni salvataggio di un campo `strategy:` dalle Impostazioni fa avanzare `versions.learning`, così la pagina rilegge subito. `generatedUtc` è l'ora in cui il motore ha pubblicato il rapporto (o quella della lettura dal disco).
I contributi di un basket (`topContributions`, `features`) spiegano sempre la `pMl` mostrata accanto: vengono dal modello che l'ha data, nel momento in cui l'ha data, e la somma dei `contribution` di `features` più `intercept` è il logit di `pMl`. Il motore li prende insieme alla p a ogni chiusura di barra a basket piatto e li conserva con l'ingresso, anche in `learning_state.json` (così sopravvivono a un riavvio). Una p che nessuna spiegazione accompagna è mostrata senza contributi (`topContributions` vuoto, `features` vuoto con `features=all`, `intercept` `null`): per esempio la p all'ingresso di un basket aperto prima della 5.1, quando il modello nel frattempo è cambiato, o la p del campione MLP. Senza `pMl` (il modello non ha ancora visto un basket) non ci sono contributi.
A motore fermo:
- per un basket in posizione all'ultima riga di valutazione, `pMl` è quella dell'ingresso con i contributi salvati con l'ingresso (`pMlKind` «all'ingresso», `pMlUtc` l'ora dell'ingresso);
- per un basket senza posizione, `pMl` è quella dell'ultima riga di valutazione del ledger se il modello salvato la ridà per i valori di quella riga (`pMlKind` «ultima barra»); altrimenti — il modello ha imparato dopo quella barra, o il motore aveva dato al modello un vettore diverso da quello che la riga registra (il vettore valutato alla chiusura di barra non ha ancora il costo dell'ingresso, la riga sì) — è quella che il modello salvato dà ai valori della riga (`pMlKind` «ricalcolata con il modello di oggi», `pMlUtc` l'ora della riga);
- `vol` porta solo σ prevista, σ media, rapporto e scala di `z_in` dell'ultima riga (`bars` 0, `activeModel` vuoto, `context` −1), oppure `null`;
- un file dei modelli che non si riesce a leggere (modificato a mano, schema diverso) lascia l'ultima lettura buona di quella parte, e un avviso in `warnings` lo dice («… non leggibile (…): mostro l'ultima lettura buona»); se non c'è mai stata una lettura buona l'avviso dice che sono mostrati i valori iniziali. Un file assente vale i valori iniziali, senza avviso.
`dataset` è ricalcolato quando cambia `baskets.csv`, quando compare un file delle decisioni, quando il ledger riceve una correzione `pnl_realizzato` o la marcatura `feature_inaffidabile` di `lastNOutcomes` (lette in modo incrementale), e comunque al più ogni ora.
```ts
{ schema: 1; generatedUtc: string; source: "engine" | "disk"; engineState: string;
status: { mode: "ombra-disabilitato" | "ombra" | "attivo"; enabled: boolean; weeklyCycle: boolean; challengerEnabled: boolean;
activeFlag: boolean; gateEffective: boolean; champion: string; modelVersion: number; seen: number;
pMin: number; deactivationAuc: number; lastReport: string; reason: string; trackedEntries: number };
dataset: null | { computedUtc: string; datasetHash: string; closedRows: number; labelledRows: number; withoutEntryRow: number;
entryRowsWithoutFeatures: number; loneLegRows: number; correctedRows: number; unverifiedRows: number;
wins: number; losses: number; winRate: number | null; pnlNetUsd: number; meanPnlUsd: number | null;
medianPnlUsd: number | null; p5PnlUsd: number | null; firstOpenedUtc: string | null; lastClosedUtc: string | null;
demoClosed: number; activationTarget: number; activationProgress: number;
byMode: Array<{ key: string; count: number }>;
byBasket: GroupStats[]; byPreset: GroupStats[]; byExitReason: GroupStats[];
labelsSuspect: boolean; labelsSuspectReason: string };
activation: { passesWalkForward: boolean; passesAdr0006: boolean; operatorEnabled: boolean; motivazione: string;
items: Array<{ key: string; label: string; current: string; required: string; ok: boolean | null; source: string }> };
logistic: { inputs: number; seen: number; learningRate0: number; currentLearningRate: number; l2: number; bias: number;
weightNorm: number; standardizerRows: number; standardizerHalfLifeRows: number;
weights: Array<{ index: number; name: string; label: string; weight: number; mean: number; stdDev: number }> }; // per |peso| decrescente
challenger: null | { hidden: number; seed: number; seen: number; outputBias: number; w1Norm: number; w2Norm: number;
silentUnits: number; standardizerRows: number; challengerWins: boolean };
lastCycle: null | { version: number; utc: string; durationMs: number; trigger: "settimanale" | "manuale" | "offline"; rows: number;
datasetHash: string; trainedOnUntilUtc: string | null; logistic: ModelEvaluation; mlp: ModelEvaluation | null; challengerWins: boolean };
rolling: { count: number; pAt: "entry" | "close"; auc100: number | null; auc200: number | null; auc100Low: number | null; auc100High: number | null;
brier100: number | null; logLoss100: number | null; hitRate100: number | null; meanP100: number | null; lastOutcomes10: number | null;
recentP: number[]; recentLabel: number[]; aucHistory: Array<{ utc: string; auc100: number }>; calibration: CalibrationBin[] };
baskets: Array<{ basket: string; cross: string; enabled: boolean; state: string; pMl: number | null; pMlUtc: string | null;
pMlKind: "ultima barra" | "all'ingresso" | "ricalcolata con il modello di oggi" | "";
intercept: number | null; // intercetta del modello che ha dato pMl: Σ features[].contribution + intercept = logit(pMl); null senza contributi
wouldBeFiltered: boolean;
topContributions: Array<{ index: number; name: string; label: string; value: number | null; z: number | null; contribution: number | null }>;
features: Array<{ index: number; name: string; label: string; value: number | null; z: number | null; contribution: number | null }> | null;
vol: null | { bars: number; activeModel: string; ewmaSigma: number | null; harSigma: number | null; forecastSigma: number | null;
average30dSigma: number | null; volRatio: number | null; zInScale: number | null; rmseEwma: number | null;
rmseHar: number | null; scored: number; pending: number; lastHarFitUtc: string | null; context: number; contextLabel: string } }>;
bandit: { contexts: number; explorationCap: number; choices: number; explorations: number; explorationShare: number | null;
currentPreset: string; applied: false; rewardsSuspect: boolean;
arms: Array<{ context: number; contextLabel: string; preset: string; alpha: number; beta: number; successes: number; failures: number;
n: number; mean: number; low95: number; high95: number; bestInContext: boolean }>;
// bestInContext: la media a posteriori più alta del contesto, solo per un braccio con almeno un esito (n > 0):
// un bandit nuovo non ha bracci migliori, e nemmeno un contesto i cui bracci provati non fanno meglio del prior
// (a pari media vince il primo braccio nell'ordine Conservative, Moderate, Aggressive)
lastProposal: null | { utc: string; context: number; preset: string; explored: boolean; means: number[]; text: string } };
volatility: null | { historyCount: number; tercileLow: number | null; tercileHigh: number | null };
knowledge: { calibration: Array<{ dimension: string; bucket: string; count: number; winRate: number | null; meanPnl: number | null; totalPnl: number | null; motivazione: string }>;
proposals: Array<{ utc: string; origin: string; parameter: string; currentValue: string; proposedValue: string; evidence: string; state: string; motivazione: string; basedOnSuspectData: boolean }>;
registry: Array<{ version: string; utc: string; type: string; nTrain: number; aucWf: number | null; brier: number | null; logLoss: number | null; state: string; motivazione: string }>;
insights: null | { fileName: string; modifiedUtc: string; markdown: string; truncated: boolean };
modelFiles: Array<{ name: string; bytes: number; modifiedUtc: string; kind: string; version: number | null; rows: number | null }>;
files: Array<{ name: string; bytes: number; modifiedUtc: string }> };
schedule: { lastCycleUtc: string | null; nextDueUtc: string | null; runsInBot: boolean; due: boolean; running: boolean;
runningSinceUtc: string | null; runningPhase: string; lastDurationMs: number | null; lastError: string; lastTrigger: string };
warnings: string[] }
type GroupStats = { key: string; count: number; winRate: number | null; pnlNetUsd: number; meanPnlUsd: number | null };
type CalibrationBin = { lower: number; upper: number; count: number; meanPredicted: number | null; observedRate: number | null };
type ModelEvaluation = { model: string; rows: number; burnIn: number; auc: number | null; aucLow: number | null; aucHigh: number | null;
brier: number | null; logLoss: number | null; calibration: CalibrationBin[]; pnlAllUsd: number; pnlFilteredUsd: number;
filteredCount: number; sharpeAll: number | null; sharpeFiltered: number | null; dsrFiltered: number | null;
passesActivation: boolean; motivazione: string };
```
### `GET /api/log?level=&q=&limit=&after=`
`level`: `tutti` (default), `info`, `warn`, `error` (minimo). `q`: testo (nel messaggio o nella sorgente). `limit`: default 500, massimo 5000. `after`: solo le righe con `seq` maggiore.
```ts
{ lastSeq: number; file: string;
rows: Array<{ seq: number; timeUtc: string; time: string; level: string; source: string; message: string }> }
// message è sempre su una riga: gli a capo diventano " ⏎ "
```
### Storico (invariato dalla 5.0)
`GET /api/history/orders | positions | periods` con i filtri `from`, `to`, `basket`, `symbol`, `outcome`, `origin` e `format=csv`. Forma delle righe come in `src/Encelado.Server/Web/WebHost.cs` (la pagina Storico della 5.0).
## Comandi
`POST /api/commands/{nome}` con corpo JSON facoltativo, sempre con `Content-Type: application/json` (anche senza corpo; 415 altrimenti). Risposta `{ ok, message, needsPhrase, code?, … }`: `needsPhrase` è `true` (HTTP **409**) quando serve la frase `CONFERMO LIVE`; `code` (se presente) è `needsPhrase`, `restart`, `refused` o `timeout`. Anche `refused` risponde **409**: lo stato rifiuta il comando adesso (un ciclo di apprendimento già in corso, AVVIA durante la manutenzione a motore fermo, il motore che si avvia o si ferma, FERMA durante un kill-switch) e il messaggio dice perché. Un comando che il motore non ha eseguito perché si è fermato prima di prenderlo, o a metà, risponde subito `refused` con «comando interrotto: il motore si è fermato» (mai un'attesa di 120 s). `timeout` risponde **504**: il motore, occupato, non ha risposto entro 120 s; il comando resta in coda e l'esito va nel log (per un kill-switch, una chiusura o la chiusura dei residui il messaggio dice che il motore lo porta a termine e che FERMA e i riavvii aspettano). Nessun comando risponde 500 per un'attesa scaduta.
Il ciclo di vita del motore è serializzato: AVVIA, FERMA, i riavvii automatici delle impostazioni e il ciclo di apprendimento a motore fermo passano uno alla volta. FERMA durante un avvio aspetta il motore in costruzione e lo ferma; AVVIA subito dopo FERMA aspetta che il motore precedente abbia lasciato la cartella dati (lo stato resta `stopping` fino ad allora). Un kill-switch, una chiusura (`close`), la chiusura dei residui o una chiusura della bonifica in coda o in corso non vengono mai interrotti da FERMA o da un riavvio automatico (409 `refused`), anche quando chi li ha chiesti ha smesso di aspettare la risposta (scheda chiusa o ricaricata, risposta 504 dopo 120 s, poller Telegram fermato durante `/kill`): contano finché il motore non li ha conclusi, o finché la sua esecuzione non finisce senza prenderli. Solo l'arresto del processo (SIGTERM) li interrompe, dopo 30 s, e un kill-switch interrotto lascia il residuo registrato (Halted-Residuo).
| Nome | Corpo | Effetto |
|---|---|---|
| `start` | `{ confirm?: string }` | Avvia il motore. In modalità Live serve `confirm = "CONFERMO LIVE"` (409 `needsPhrase` altrimenti). 409 `refused` mentre gira un ciclo di apprendimento a motore fermo. |
| `stop` | — | Ferma il motore; i basket restano sul conto salvo `run.closeOnShutdown`, con cui il motore stesso, sul suo thread di decisione, blocca le nuove entrate e chiude basket, gambe in attesa e orfane (al più 30 s) prima di fermarsi. 409 `refused` mentre è in corso un kill-switch, una chiusura o la chiusura dei residui. |
| `close` | `{ argument: "EURUSD/USDCHF" }` | Chiude il basket. |
| `kill` | `{ foreign?: boolean }` | Kill-switch. `foreign` esplicito decide per le posizioni esterne e vince sull'impostazione `risk.closeForeignOnKill`: `true` le chiude, `false` le lascia (il dialogo manda sempre il valore della sua casella, che parte da `closeForeignOnKill` del tick). Senza il campo, o `null`, vale l'impostazione, come per Telegram `/kill` e il file STOP; la console chiede solo se ci sono posizioni esterne e propone l'impostazione come risposta di partenza. Un altro valore risponde 400. Risposta con `positions[]` residue. |
| `reset` | `{ reason: string }` | Ripristino in cinque passi; risposta con `steps[]`. |
| `residue` | `{ argument?: "all" \| "<positionId>" }` | Richiude i residui del kill-switch. Le gambe di un basket rimasto aperto diventano una riga sola di `baskets.csv`, come basket, quando tutte sono chiuse; una posizione già registrata (chiusa nel frattempo dall'uscita del basket o da eToro) non riceve una seconda riga. Un residuo che il conto non mostra più esce dall'elenco alla riconciliazione successiva. |
| `pause`, `resume` | — | Pausa/ripresa delle entrate. |
| `bonifica` | `{ argument: "list" \| "close:<positionId>" }` | Elenco o chiusura delle orfane; `positions[]`. |
| `learn` | — | Ciclo di apprendimento in background. Motore acceso: lo avvia il motore e la risposta è immediata (avanzamento in `schedule.running` / `runningPhase` di `/api/learning` e in `learning.cycleRunning` del tick). Motore fermo o in errore: manutenzione che prende il lock di istanza della cartella dati; `start` risponde 409 `refused` finché dura. 409 `refused` con un ciclo già in corso, con il motore che si avvia (finché il ciclo di decisione non è partito: verifica, riscaldamento, riconciliazione) o si ferma, o con il lock tenuto da un altro processo. |
Le righe di `positions[]` (`kill`, `residue`, `bonifica`) hanno la forma della 5.0: `{ positionId: number; symbol: string; isBuy: boolean; units: number | null; openedUtc: string; unrealizedPnl: number | null; origin: "basket" | "orfana-bot" | "esterna"; basket: string; reason: string }`.
In `--sample` ogni comando risponde `{ ok: false, message: "modalità dimostrativa (--sample): …" }` con HTTP **400**: niente viene eseguito.
Il comando `preset` non esiste più: il preset si cambia in Impostazioni.
## Impostazioni
### `GET /api/settings`
```ts
{ configPath: string; strategyPath: string;
version: number; // cambia a ogni salvataggio (impostazioni o segreti)
engine: { state: string; account: "demo" | "live"; running: boolean };
groups: Array<{ key: string; title: string; description: string; target: "config" | "strategy"; advanced: boolean;
// key: "conto" | "esecuzione" | "strategia" | "avanzate" | "telegram" | "interfaccia" | "log"
fields: Array<{ path: string; // "run.pollSeconds" oppure "strategy:preset"
label: string; kind: "text" | "number" | "integer" | "choice" | "bool" | "list";
value: string; // sempre stringa; bool = "true"/"false"; list = valori separati da virgola
options: string[]; // per choice
suffix: string; tooltip: string; readOnly: boolean; error: string;
scope: "immediate" | "engine" | "restart"; // quando ha effetto
min: number | null; max: number | null;
allowEmpty: boolean }> }>; // vuoto ammesso: per un numero significa "il valore del preset" (la chiave sparisce dal file)
secrets: { state: "open" | "empty" | "locked" | "localKey"; etoro: { demo: SecretInfo; live: SecretInfo }; telegram: SecretInfo;
passwordSource: string; ignoredEnv: string[];
importNote: string; // cosa ha fatto l'importazione una tantum dalla 5.0 (vuoto se niente)
problem: string } } // perché i segreti sono bloccati (vuoto altrimenti)
```
L'input è tollerante: un numero può avere la virgola decimale (`0,65`), un booleano può essere `sì`/`no`; il valore restituito è sempre normalizzato (`0.65`, `true`). Le stringhe arrivano già in italiano.
In `--sample` la risposta è un dato d'esempio: i valori di fabbrica di `encelado.json` e `strategy.json` (nessun file viene letto), il motore e i segreti del campione (gli stessi di `/api/system`); `configPath` e `strategyPath` dicono «campione (--sample): valori di fabbrica» e «niente viene salvato». Ogni scrittura di questa sezione e di [Segreti](#segreti) risponde **400** `{ ok: false, message: "modalità dimostrativa (--sample): le impostazioni e i segreti non vengono salvati", … }` senza leggere il corpo né chiamare eToro o Telegram.
### `POST /api/settings`
Corpo `{ "edits": { "<path>": "<valore>", … }, "confirm"?: "CONFERMO LIVE" }` (accettato anche l'oggetto piatto `{ "<path>": "<valore>" }` della 5.0).
Risposta:
```ts
{ ok: boolean; message: string;
results: Array<{ path: string; applied: "immediate" | "engine" | "restart" | "stored" | "error"; message: string }>;
restart: "none" | "done" | "needsPhrase" | "refused";
needsPhrase: boolean; // = restart === "needsPhrase"
errors: Record<string, string>; // path → errore di validazione ("*" = la combinazione dei valori)
version: number }
```
Con `restart = "needsPhrase"` (HTTP 409) niente è stato scritto: il client chiede la frase e ripete con `confirm`. Con `restart = "refused"` (HTTP 409) niente è stato scritto, e `message` dice perché: mancano le chiavi del conto scelto a motore acceso, oppure il cambio riavvierebbe il motore mentre è in corso un kill-switch, una chiusura o la chiusura dei residui, oppure — per il cambio di conto (Demo ↔ Live) o delle coppie dei basket — sul conto in uso c'è ancora qualcosa in sospeso: basket aperti o in attesa di una gamba, ingressi, aggiunte o uscite in corso, basket in errore con una gamba sul conto, ordini senza esito, gambe orfane del bot o residui del kill-switch, chiusure in attesa dello storico eToro (al più 30 minuti). Il messaggio elenca solo ciò che c'è e dice cosa fare. Lo stesso cambio è rifiutato mentre il motore si avvia (finché il ciclo di decisione non è partito non ha letto il suo stato), mentre si ferma, o se il motore, occupato, non risponde al controllo entro 30 s. Valori non validi: HTTP 400 con `errors`.
Il controllo del cambio di conto (decisione C8) a motore acceso lo fa il motore stesso, sul suo thread di decisione, dopo aver bloccato le nuove entrate e le aggiunte e dopo una riconciliazione con il conto: mai la vista pubblicata, dove un basket a metà ingresso sembra piatto, né l'ultima riconciliazione, che può avere fino a 20 s (una gamba del bot che nessuno slot tiene — la gamba A rimasta sul conto quando la sua richiusura è stata rifiutata — diventa così un'orfana e conta). Se le posizioni del conto non si leggono, il cambio è rifiutato («le posizioni del conto non lette da eToro»). Se il conto è libero le entrate restano bloccate fino al riavvio (`alarms.entriesBlockedReason` lo dice nel frattempo); se il cambio poi non avviene, il blocco viene tolto. A motore fermo decide il file di stato del conto in uso. Dopo l'arresto, prima di avviare l'altro conto, il file lasciato dal motore fermato viene giudicato di nuovo: se il conto non è piatto — o se nel frattempo è partito un kill-switch, una chiusura o la chiusura dei residui, o FERMA ha lasciato il conto non piatto — `encelado.json` e `strategy.json` tornano byte per byte come prima del salvataggio e la risposta è 409 `refused` con il motivo; il motore resta fermo (o acceso sul conto di prima, se non era stato fermato). Ogni conto ha il suo stato (basket, blocchi, residui, pausa, picco, chiusure in attesa del P&L), che il cambio non tocca: tornando sull'altro conto lo si ritrova com'era.
Il riavvio automatico riavvia solo un motore che è ancora acceso quando tocca a lui: se nel frattempo è arrivato FERMA, il motore resta fermo e i valori salvati valgono al prossimo avvio (`applied = "stored"`, `restart = "none"`). Se i file sono stati scritti ma il riavvio non è riuscito (raro: un kill-switch partito fra il controllo e il riavvio, o il motore fermato che non riparte) la risposta è HTTP 400 con `ok: false` e un messaggio che dice che i valori sono salvati e cosa fare («salvato, ma il motore non è stato riavviato: …», «il motore si è fermato ma non è ripartito: …»).
### Segreti
| Rotta | Corpo | Effetto |
|---|---|---|
| `POST /api/settings/keys` | `{ account: "demo" \| "live", apiKey, userKey }` | Verifica le chiavi su quel conto (profilo e saldo) e le salva cifrate. Se è il conto attivo e il motore gira, lo riavvia (Live: serve `confirm`). |
| `DELETE /api/settings/keys?account=demo` | — | Rimuove le chiavi di quel conto (a motore fermo, o del conto non attivo). |
| `POST /api/settings/telegram-token` | `{ token }` | Verifica con `getMe` e salva cifrato; riconfigura Telegram subito. |
| `DELETE /api/settings/telegram-token` | — | Rimuove il token; Telegram si spegne. |
| `POST /api/settings/telegram-test` | — | Manda un messaggio di prova alla chat configurata. |
| `POST /api/settings/secrets/unlock` | `{ previous }` | Decifra con la password precedente e ricifra con quella attuale. |
| `POST /api/settings/secrets/reset` | — | Ricomincia con un deposito vuoto (il vecchio file resta come `.bak`). |
| `POST /api/settings/restore` | — | Valori di fabbrica di `encelado.json` (a motore fermo; backup con la data). |
Ogni rotta dei segreti risponde `{ ok, message, restart, needsPhrase, detail, version }`: `detail` è ciò che la verifica ha trovato (utente ed equity del conto, nome del bot Telegram) o il percorso del backup. Chiavi rifiutate da eToro o token rifiutato da Telegram: HTTP 400, niente salvato. Deposito bloccato o chiavi del conto in uso a motore acceso: HTTP 409. Nuove chiavi del conto in uso mentre è in corso un kill-switch, una chiusura o la chiusura dei residui: HTTP 409 `restart = "refused"`, niente salvato. Lo stato del motore e il conto in uso si rileggono dopo la verifica (che dura fino a 25 s): se nel frattempo è arrivato FERMA, o il conto è cambiato e le chiavi non sono più del conto del motore, vengono salvate senza riavviare niente; se il motore da riavviare ora è in Live e il salvataggio non portava la frase, vengono salvate e il motore non viene riavviato (il messaggio dice di premere FERMA e poi AVVIA con `CONFERMO LIVE`). Chiavi salvate ma motore che non riparte dopo il riavvio: HTTP 500 con `ok: false`, `restart = "done"` e il motivo (le chiavi restano salvate); un errore del disco nel «Ricomincia» del deposito: HTTP 500.
## Salute
`GET /api/health` (libera, per il `HEALTHCHECK` del container):
```ts
{ ok: boolean; state: string; apiState: string; heartbeatAgeSeconds: number | null; heartbeatSeconds: number; diskWritable: boolean; uptimeSeconds: number }
```
`ok` è falso se il disco dei dati non è scrivibile o se, a motore acceso, l'heartbeat è più vecchio di 3 × `heartbeatSeconds` + 15 s (105 s con il default di 30 s; `heartbeatSeconds` è l'intervallo che il motore sta usando, 0 a motore fermo); prima del primo heartbeat, se l'avvio risale a più di dieci minuti. `apiState` usa le parole di `health.api` del tick (`ok`, `degraded`, `error`, `off`). La prova di scrittura del disco si ripete al più una volta al minuto; nessuno snapshot viene costruito.
+196
View File
@@ -0,0 +1,196 @@
# Architettura di Encelado
Aggiornato: 2026-10-01 (5.1: viste pubblicate e tick condiviso, impostazioni applicate a caldo, segreti cifrati con la password, stato per conto, realizzato dallo storico, ciclo di apprendimento in background, interfaccia in stile Mimante). La storia della ricognizione del 2026-09-16 (l'albero che non compilava, i motori Binance/cTrader, SQLite) è nella versione della 4.0 di questo file nella storia git e in ADR-0004.
## 1. Progetti
```
Encelado.slnx
├── src/Encelado.Core libreria portabile (net10.0), zero NuGet, AOT/trim-compatibile, zero I/O
│ ├── Broker/ IBroker e modelli (Instrument, QuoteSnapshot, AccountSnapshot, BrokerPosition, ClosedTrade, OrderRequest, OrderOutcome,
│ │ CloseOutcome), RateLimiter, LatencyWindow
│ ├── Baskets/ SyntheticCross, PipMath, BasketMath, SymbolSeries, BasketDecider, CostGate, VolParitySizing, BasketExecutor, BasketPosition
│ │ (con PendingA/PendingB), PendingEntry, BasketStrategyConfig (strategy.json: preset, risk, recovery, learning), BasketSlotPolicy,
│ │ ExecutionMode (Demo/Live = conto), OrderTracker (ADR-0009, per conto), PositionClassifier, EquityTracker, StartupCash,
│ │ DailyLoss + DailyLossLatch (D-52), FlattenProcedure, Heartbeat/HeartbeatFile, InstanceLock, RecoveryPlanner
│ ├── Baskets/History/ OrderRecord (orders.jsonl), BasketOutcomeRow (baskets.csv), PnlCorrections (righe correzione e lettore corretto), PositionMap
│ │ (posizioni di una riga per la verifica), PositionOrigins (basket/orfana-bot/esterna), RealizedToday («P&L oggi»),
│ │ SettlementQueue (chiusure in attesa dello storico), HistoryBuilder (la pagina Storico, pura)
│ ├── Baskets/Data/ BidAskBar + CSV, TickToBars (tick MT5 → M15)
│ ├── Baskets/Learning/ OnlineLogistic, SmallMlp, ThompsonBandit, VolForecast, LearningFeatures, ModelEvaluator (+ CalibrationTables), CycleTrainer,
│ │ LearningAnalytics, LearningReport, LearningJson (il rapporto di /api/learning e last_cycle.json)
│ ├── Baskets/Backtest/ BasketBacktest (con ReplayDailyLoss), BacktestBroker, BasketTrials
│ ├── News/ CalendarParser, RssParser, SentimentLexicon, SentimentEngine
│ ├── Notifications/ INotifier, NotifierHub (Telegram acceso, spento o cambiato a caldo), TelegramNotifier (solo HttpClient), TelegramStatus
│ ├── Ml/ Classification, Pbo
│ └── Statistics/ Ols, Distributions, Performance (Sharpe, PSR, DSR, drawdown)
├── src/Encelado.Etoro EtoroOptions, EtoroHttp (x-api-key/x-user-key/x-request-id, limitatore per classe di quota, 429, latenza del solo viaggio
│ HTTP, scarto orologio), EtoroBroker : IBroker, Json
├── src/Encelado.Engine libreria (net10.0): il motore e tutto ciò che tocca il disco o la rete oltre al broker
│ ├── Baskets/ BasketEngine in undici file parziali (.cs ciclo e decisioni, .Pending, .Reconcile, .Kill, .Recovery, .State, .Commands,
│ │ .Realized, .Learning, .View, .Snapshot), AccountStateFiles (stato per conto), Settlements (coda di regolamento), RealizedBackfill
│ │ (verifica del realizzato all'avvio), Ledger, Feeds + ContextProvider + ContextRefresher (calendario e notizie in background),
│ │ LearningState, LearningCycle (+ CycleRunner), LearningDataset, LearningDiskReader, LearningFiles (AtomicFile, stato
│ │ dell'apprendimento), HistoryService (fonti della pagina Storico, con cache), TelegramReports, TelegramCommands, HeadlessRunner
│ ├── Configuration/ BotConfig, ConfigLoader (JsonDocument; regola di fusione modalità/ambiente; RemoveObsoleteKeys), ConfigDefaults (JSON di
│ │ fabbrica incorporato), ConfigWriter, AppPaths (/config, /data, sandbox, Documenti), InterfacePassword, SecretStore,
│ │ EnvironmentImport (importazione una tantum dalla 5.0), KeyStore (solo per leggere il vecchio etoro.keys.enc)
│ ├── Engine/ IEngine, BotSupervisor (ciclo di vita), EngineView (la vista pubblicata), ContextView, HealthRules, ReadModel (IBotReadModel,
│ │ LiveReadModel), SectionVersions, SnapshotAdapter + BotSnapshot (la fotografia per console e Telegram), SampleData +
│ │ SampleReadModel (dati d'esempio per --sample e test), SnapshotJson, SampleSnapshot
│ ├── Logging/ Log statico non bloccante su Channel<T>, file ';' con rotazione, console, riconfigurabile a caldo
│ └── Settings/ SettingsCatalogue + SettingField (il form di Impostazioni, con file e momento d'effetto), SettingsService (descrizione,
│ validazione su copie, scrittura), SettingsRuntime (applicazione a caldo, segreti, AVVIA), AccountActivity (guardia del
│ cambio di conto), StrategyCache, AutostartPolicy, UiClock
├── src/Encelado.Server l'eseguibile (Microsoft.NET.Sdk.Web, framework reference Microsoft.AspNetCore.App, nessun NuGet)
│ ├── Program.cs password, configurazione, segreti, importazione, log, feed, notifier, supervisore, impostazioni, WebHost, avvio
│ │ automatico, SIGTERM, --health, --sample, --listen-all
│ ├── SampleFolders.cs le cartelle temporanee di --sample (create all'avvio, cancellate all'uscita)
│ └── Web/ WebHost (Kestrel, RequestGuard, autenticazione, rotte), AuthBackoff (attesa dopo una password errata), SnapshotHub (un tick al
│ secondo per tutti), TickWriter (tick v2), SectionJson + SectionCache (sezioni a richiesta con ETag), SystemJson (+ DiskProbe),
│ SettingsApi, StaticFiles, Json (Utf8JsonWriter), LogBuffer (finestra del log con seq), LogBridge (log di ASP.NET → Log),
│ wwwroot/ (index.html, login.html, css/, js/, js/pages/, icon.svg, manifest.webmanifest — incorporati)
├── tools/Encelado.Backtest ticks, baskets, falsify, learn (referenzia Core ed Engine; learn prende il lock di istanza)
├── tests/Encelado.Tests xunit (net10.0, gira su Windows e nello stadio di build dell'immagine)
├── .gitea/workflows/ ci.yml (build, test, docker build a ogni push), release.yml (immagine sul registro e release a ogni tag)
├── deploy/docker/ entrypoint.sh (TZ, PUID/PGID, gosu, exec)
├── deploy/unraid/ encelado.xml (template Container v2: porta, /config, /data, ENCELADO_PASSWORD), README.md
├── deploy/local/ sandbox ignorata da git: /config e /data delle prove sul PC (F5, run-dev, compose)
├── scripts/ run-dev, run-docker, screenshots (.ps1 e .sh), cdp-shot.mjs
├── Dockerfile, docker-compose.yml, .dockerignore
└── build/ Release.proj (Verifica, Backtest, Pubblica, Docker, Pacchetto, Rilascia), README.md
```
- **Target framework**: `net10.0` ovunque, `Nullable` e `TreatWarningsAsErrors` attivi via `Directory.Build.props` (che porta anche la versione di sviluppo, 5.1.0); `InvariantGlobalization` nei progetti dell'applicazione (i test lo spengono per verificare i fusi IANA e Windows). SDK 10.0.301.
- **Pattern**: nessun contenitore DI; oggetti costruiti a mano in `Program.cs` e nel supervisore; async/await con `ConfigureAwait(false)` nel motore; `Channel<T>` per il log e le notifiche; `Lock` per lo stato condiviso; viste immutabili pubblicate verso il server; ogni tabella è CSV `;` con colonna finale `motivazione`; log strutturato `timestamp;level;source;subject;event;message;exception;stack`.
- **Storage**: solo file (ADR-0002). Nel container `/config` (configurazione, segreti cifrati, file `STOP`) e `/data` (`data/`, `knowledge/`, `reports/`, `results/`, `logs/`); fuori dal container la sandbox `deploy/local/` (`ENCELADO_CONFIG_DIR` + `ENCELADO_DATA_DIR`) o `Documenti\Encelado`.
- **Build ed esecuzione**: `dotnet build Encelado.slnx`; `dotnet run --project src/Encelado.Server`; immagine con `dotnet msbuild build/Release.proj -t:Docker`; la versione rilasciata viene dal tag git, commit e data di build da `AssemblyMetadata`.
## 2. Flusso dati (live)
```mermaid
flowchart LR
E[eToro Public API] -->|rates ogni pollSeconds| Q[Quote poller]
Q --> B[Bar builder M15]
E -->|candles| B
B --> S[Ciclo di decisione<br/>un solo thread]
C[Calendario + RSS<br/>in background, del processo] --> F[ContextView]
F --> S
M[Meta-modello in ombra<br/>vol forecast] --> S
S -->|decisione| X[Executor<br/>leg-risk + OrderTracker]
X --> E
E -->|storico posizioni chiuse| R[Coda di regolamento<br/>realizzato, P&L oggi]
R --> S
S --> L[(Ledger jsonl/csv)]
X --> L
S -->|Volatile.Write| V[EngineView<br/>vista pubblicata]
V --> H[SnapshotHub<br/>un tick al secondo]
H --> W[SSE /api/stream]
V --> D[Sezioni a richiesta<br/>ETag/304]
W --> U[Browser]
D --> U
V --> T[Console, Telegram]
U -->|POST /api/commands, /api/settings| P[Supervisore e impostazioni]
P -->|comandi sul thread di decisione| S
L --> K[Ciclo di apprendimento<br/>in background]
K -->|applicato fra due tick| M
```
Le decisioni avvengono su un solo thread; l'I/O è asincrono; nessuno approva il singolo ordine (ADR-0005): i gate umani sono l'avvio del reale, il kill-switch e il reset, dall'interfaccia web, dalla console o da Telegram.
## 3. Macchine a stati
### Il basket
```
Idle ──(segnale + cancelli)──► Entering ──(A e B eseguite)──► Open ──(add)──► Adding ──► Open
▲ ▲ │ (B rifiutata → chiudi A, leg_risk_unwind, basket disattivato 1 h)
│ │ │ (A senza esito oltre legTimeoutSec) ──► PendingA ──(A eseguita, segnale valido)──► Entering
│ │ │ │ (A rifiutata → Idle; A eseguita e segnale decaduto → chiudi A → Idle)
│ │ │ (A eseguita, B senza esito) ──► PendingB ──(B eseguita)──► Open
│ └───────────────────────────────────────────────────────────────── (B rifiutata → chiudi A → Idle)
│ ▼
└────────── Closed ◄──── Exiting ◄──(TP | z_out | stop | time-stop | manuale | forzata)── Open
│ (una gamba non chiude dopo 3 tentativi)
▼
Error (blocco nuove entrate finché non risolto)
```
Stati del motore (non del basket): `Halted` dopo un kill-switch o un equity stop con il conto piatto per le posizioni del bot; **`Halted-Residuo`** quando la verifica di piattezza trova ancora posizioni del bot sul conto (o un kill-switch è stato interrotto dall'arresto del processo): allarme con l'elenco, reset rifiutato finché restano. Negli stati `PendingA`/`PendingB` il basket non viene valutato e non manda ordini; il registro degli ordini (`OrderTracker`) chiede l'esito al server e, quando manca, lo ricostruisce dalla posizione comparsa sul conto. Gli ingressi in sospeso sopravvivono a un riavvio (`pendingEntries` nello stato del conto) e vengono risolti all'avvio prima di qualsiasi decisione. Un basket spento in Impostazioni continua a gestire le uscite di ciò che ha sul conto (`BasketSlotPolicy`).
### Il supervisore
`stopped` → `starting` → `running` → `stopping` → `stopped`, oppure `faulted` quando l'avvio fallisce o il ciclo del motore finisce senza che nessuno l'abbia fermato. Un motore in errore viene rilasciato (lock di istanza compreso) prima di un nuovo avvio o di una manutenzione dell'apprendimento. Vedi §5.
## 4. Interfacce
- `IBroker`: `Environment`, `GetInstrumentsAsync`, `GetQuotesAsync(ids)`, `GetCandlesAsync(id, interval, count)`, `GetAccountAsync`, `GetPositionsAsync`, `OpenAsync(OrderRequest)` (esito per `orderId`, poi per posizione comparsa; mai un esito inventato), `LookupOrderAsync(clientRef)`, `LookupOrderByIdAsync(orderId)`, `CancelOrderAsync(orderId)`, `CloseAsync(positionId, instrumentId)` (`CloseOutcome` con `PositionId`, `Proceeds` e `ConversionRate` solo per diagnostica e stima; `RealizedPnl` è NaN per eToro: il realizzato viene dallo storico), `UpdateStopsAsync(positionId, sl, tp)`, `GetCostAsync(OrderRequest)`, `GetClosedTradesAsync` (lancia un errore su HTTP fallito, mai un elenco vuoto), `ClockSkew`.
- `IContextProvider` (Engine): calendario, notizie e sentiment per basket (`FeedContextProvider`), con la fotografia immutabile `ContextView`; appartiene al processo e si aggiorna in background (`ContextRefresher`) anche a motore fermo.
- `IModel`: `Predict(features)`, `Update(features, label)`, JSON, implementato da `OnlineLogistic` e `SmallMlp`.
- `IEngine` (Engine): `RunAsync`, `ExecuteAsync(EngineCommand)`, `View` (l'ultima `EngineView` pubblicata), `Learning` (l'ultimo rapporto dell'apprendimento), `LoopStarted` (il ciclo di decisione è partito: prima, «Esegui ciclo» e il cambio di conto rispondono 409). Comandi (`EngineCommandKind`): `Close`, `KillSwitch` (argomento `esterne`, `solo-bot` o vuoto = vale l'impostazione), `ResetEquityStop` (la procedura in cinque passi), `CloseResidue`, `Bonifica`, `History`, `Pause`, `Resume`, `ApplySettings`, `Learn`, `Shutdown` (argomento `chiudi`: la chiusura all'arresto con `run.closeOnShutdown`), `PrepareAccountSwitch` e `CancelAccountSwitch` (la guardia del cambio di conto). Ogni comando eseguito, o interrotto da un arresto, è una riga `comando` nel ledger. Non esiste più nessun metodo del motore chiamato da un altro thread (`CloseAllAsync` è privato; il comando `preset` non esiste più).
- `INotifier` (Core): `Notify(kind, title, text)` non bloccante e `Status`; `NotifierHub` lo implementa e scambia a caldo il canale nullo con quello Telegram (token dal deposito dei segreti, poller dei comandi acceso e spento) quando cambiano le impostazioni.
- `IBotReadModel` (Engine): ciò che il web legge — la vista del motore (`EngineStatus`: stato, vista viva, ultima vista dopo l'arresto), il contesto, Telegram, i segreti, l'apprendimento —, implementato da `LiveReadModel` (il processo vero) e `SampleReadModel` (`--sample`).
- `WebContext` (Server): configurazione, supervisore, finestra del log, storico, percorso del file, `SettingsRuntime`, la funzione di avvio, il provider del contesto e lo stato di Telegram; `Read` è il modello di lettura, `Strategy()` la strategia in cache (quella di fabbrica in `--sample`).
## 5. Thread, viste e ciclo di vita (ADR-0012)
- **Un solo thread tocca il motore.** Il ciclo di decisione pubblica un'`EngineView` immutabile con `Volatile.Write` all'avvio, dopo ogni giro, ogni lettura delle quotazioni, ogni transizione, lo smaltimento dei comandi e ogni riconciliazione: per basket valutazione, decisione con costo e size, contesto, feature del meta-modello, volatilità, posizione con le gambe e i numeri del conto, ingresso in attesa, le ultime 20 decisioni di chiusura barra; quotazioni con mediana 24 h e ATR, cambi con la coppia d'origine, posizioni classificate, registro degli ordini, quote HTTP, allarmi, conto e giornata, intervallo dell'heartbeat. Costruirla non ha effetti collaterali (`VolForecaster.Stats/Describe` sono letture pure). Web, console (`SnapshotAdapter` → `BotSnapshot`) e Telegram leggono solo quella. Tutto ciò che cambia il motore è un `EngineCommand` eseguito sul thread di decisione.
- **SnapshotHub**: un `PeriodicTimer` di 1 s costruisce il tick (`TickWriter`) **una volta** per tutti i client SSE e manda gli stessi byte; senza client non costruisce niente; ogni client ha un canale di un frame che tiene il più recente (un client lento non rallenta gli altri); il primo frame parte subito, con `retry: 3000`. `/api/snapshot` risponde con lo stesso tick. Un iscritto il cui primo frame fallisce viene tolto subito.
- **Sezioni a richiesta**: `/api/positions`, `/api/market`, `/api/baskets/detail`, `/api/system`, `/api/learning` hanno `ETag` e 304 (`SectionCache`, con età massime di 30, 15, 2 e 2 s); `SectionVersions` (motore, supervisore, impostazioni, tick per firma) dice al browser quando rileggerle (`versions` nel tick).
- **Lucchetto del ciclo di vita** (`BotSupervisor`, revisione 5.1): un solo `SemaphoreSlim` serializza `StartAsync`, `StopAsync`, `ShutdownAsync`, `RestartAsync`, il rilascio di un motore in errore e la manutenzione dell'apprendimento, ciascuno dal primo controllo all'ultimo cambio di stato. Ogni avvio ha un numero di generazione: la fine del ciclo di un motore e la fine di un arresto cambiano stato e campi solo per la loro generazione e non scrivono mai sopra `stopping`. Lo stato resta `stopping` finché il motore vecchio non è stato smaltito e ha liberato `instance.lock`: un AVVIA arrivato nel frattempo aspetta invece di fallire. I **comandi critici** (kill-switch, chiusura, chiusura dei residui, chiusura della bonifica: `EngineCommand.IsCritical`) li conta il motore stesso (`IEngine.CriticalCommand`) dalla coda finché il thread di decisione non li ha conclusi, o finché la sua esecuzione non finisce senza prenderli — non finché chi li ha chiesti aspetta (seconda revisione: una scheda chiusa, un poller Telegram fermato o un 504 dopo 120 s liberavano FERMA a metà kill-switch); il supervisore aggiunge quelli che sta inoltrando (`CommandInProgress`). FERMA, un riavvio automatico e le chiavi del conto in uso rispondono 409 finché durano.
- **Arresto**: con `run.closeOnShutdown` il supervisore manda il comando `Shutdown` (`chiudi`): il motore blocca nuove entrate e aggiunte, chiude basket, gambe in attesa e orfane sul suo thread entro `ShutdownBudget` (30 s), e solo dopo il ciclo viene annullato. All'arresto del processo (`ShutdownAsync`, mai rifiutato) un kill-switch in corso ha gli stessi 30 s; se non basta, le posizioni note del bot diventano il residuo (`kill_switch_interrotto`, Halted-Residuo). Annullamento, attesa (al più 45 s), smaltimento e stato finale stanno in un `finally`: un arresto non resta mai bloccato in `stopping`. La coda dei comandi del motore si chiude alla fine del suo `RunAsync` (anche quando l'avvio fallisce) e risponde subito «comando interrotto: il motore si è fermato» a tutto ciò che restava; un'attesa scaduta sul web è 504, mai 500.
- **Heartbeat e salute**: `HealthRules` dà le parole delle icone (API, feed, Telegram) e il giudizio di `/api/health`: a motore acceso l'heartbeat è vecchio oltre 3 × `heartbeatSeconds` + 15 s; la prova di scrittura del disco (`DiskProbe`) si ripete al più una volta al minuto.
## 6. Impostazioni, segreti e accesso (ADR-0010)
- **Catalogo** (`SettingsCatalogue`): sette gruppi — `conto`, `esecuzione`, `strategia`, `avanzate` (chiuso), `telegram`, `interfaccia`, `log` —; ogni campo dice in che file vive (`encelado.json` o `strategy.json`, prefisso `strategy:`), il tipo (testo, numero, intero, scelta, sì/no, elenco) e quando ha effetto (`SettingScope`): `immediate` nel processo (log, interfaccia, Telegram), `engine` nel motore in esecuzione sul suo thread (strategia, intervalli, timeout), `restart` con un riavvio automatico del motore che non chiude niente (modalità/conto, chiavi del conto attivo, coppie dei basket, `preferDirectCross`).
- **Salvataggio** (`SettingsRuntime.ApplyAsync`, un lock di scrittura): validazione su copie dei due file (con l'overlay vero e la stessa scrittura che verrà fatta: `ConfigLoader.RemoveObsoleteKeys` scrive la modalità che il file intendeva quando `etoro.environment` esce), scrittura atomica di `strategy.json` e poi di `encelado.json` (`ConfigWriter`, encoder rilassato, chiavi cancellate, righe `_` di documentazione aggiornate), `BotConfig.CopyFrom` in memoria, poi l'effetto: hook del processo (`Log.Reconfigure`, `LogBuffer.Resize`, `NotifierHub`, `HistoryService.Invalidate`), comando `ApplySettings` al motore (`BasketStrategyConfig.CopyFrom`, `BasketDecider.Reload`, nuovo hash, riga `configurazione` nel ledger), oppure `BotSupervisor.RestartAsync`, che sotto il lucchetto del ciclo di vita rilegge lo stato e riavvia solo un motore ancora acceso. Live: 409 `needsPhrase` prima di scrivere. La risposta dice per ogni campo `immediate`/`engine`/`restart`/`stored`/`error`.
- **Cambio di conto** (C8, D-53): a motore acceso `BotSupervisor.PrepareAccountSwitchAsync` manda `PrepareAccountSwitch`; il motore blocca le entrate (`_switchBlock`, controllato anche negli ingressi e nelle aggiunte), riconcilia con il conto (lo stesso passo del ciclo: una gamba del bot che nessuno slot tiene diventa un'orfana e conta; posizioni non lette → rifiuto, `AccountUnread`) e conta sui propri slot (`AccountActivity.FromEngine`); occupato → il blocco si toglie e la risposta elenca cosa c'è; libero → le entrate restano bloccate fino al riavvio. Dopo l'arresto, nel gancio `beforeStart` di `RestartAsync`, il file del conto lasciato si giudica di nuovo (`AccountActivity.FromDisk`); se non è piatto, o è partito un comando critico, i due file delle impostazioni tornano byte per byte come prima e niente riparte. A motore fermo decide `AccountActivity.FromDisk` sul conto in uso. `CancelAccountSwitch` toglie il blocco su ogni percorso in cui il cambio non avviene.
- **Segreti** (`SecretStore`, `/config/secrets.enc`): chiavi eToro dei due conti e token Telegram, AES-256-GCM con chiave PBKDF2-SHA256 (600 000 iterazioni) dalla password; formato `ENC2` | sorgente della chiave | iterazioni | sale | nonce | tag | testo cifrato, intestazione autenticata; iterazioni fuori da 100 000-10 000 000 = file danneggiato. Stati `empty`, `open`, `locked` (password cambiata: sblocco con la precedente o ripartenza con un `.bak`), `localKey` (senza password: chiave casuale in `secrets.key`, sostituita dalla password appena compare). Motore e storico ricevono una copia privata delle chiavi (`EtoroOptions`), mai la configurazione condivisa.
- **Importazione una tantum** (`EnvironmentImport`, `import-5.1.json`): le variabili e i file di un container 5.0 passano nel deposito e in `encelado.json`, poi le variabili rimaste vengono ignorate ed elencate (log, Sistema, `alarms.ignoredEnv`). Il caricatore della configurazione non legge più l'ambiente.
- **Password e accesso** (`InterfacePassword`, `WebHost`): `ENCELADO_PASSWORD` (alias deprecato `ENCELADO_WEB_TOKEN`); cookie `encelado_session` = Base64Url(HMAC-SHA256(SHA-256("encelado/cookie/v2" ‖ segreto ‖ password), "session")), con il segreto del server in `<config>/session.key` (`SessionKey`, 32 byte casuali creati una volta), HttpOnly, SameSite=Strict, 30 giorni; `Authorization: Bearer` per gli script; confronti a tempo costante. Prima dell'autenticazione `RequestGuard` rifiuta ciò che viene da altrove: senza password ogni `Host` che non sia `localhost`/`127.0.0.1`/`[::1]` (403, DNS rebinding); per ogni metodo diverso da GET/HEAD/OPTIONS un `Sec-Fetch-Site` di un'altra origine o un `Origin` con un altro host:porta (403; `/login` e `/logout` solo l'`Origin`; `X-Forwarded-Host` per i reverse proxy); sotto `/api/` un `Content-Type` diverso da `application/json` (415). `AuthBackoff` fa pagare ogni password errata (form, Bearer) all'indirizzo del client (IPv6 per /64): 1, 2, 4, 8, 16, poi 30 s, con 429 a ogni richiesta con una password durante l'attesa. Il cookie si controlla prima e fuori da lì (seconda revisione): valido entra anche durante l'attesa e non azzera il conto, sbagliato riceve 401 subito. Il server ascolta su tutte le interfacce solo con la password e nel container (`AppPaths.InContainer`) o con `--listen-all` (`WebHost.ListensOnTheNetwork`); altrimenti su localhost.
- **`--sample`**: `SampleFolders` crea `%TEMP%/encelado-campione-<pid>-<guid>/{config,data}` e `AppPaths.UseFolders` ci punta; niente importazione, niente canale Telegram, niente feed; `SampleReadModel` serve dati d'esempio coerenti per ogni rotta; ogni comando e ogni scrittura di impostazioni o segreti risponde 400. Le cartelle si cancellano all'uscita, e quelle di processi campione morti al prossimo avvio campione.
## 7. Realizzato, rischio e stato per conto (ADR-0011, D-52, D-53)
- **Coda di regolamento** (`Settlements` + `SettlementQueue`, persistita come `pendingSettlements`): ogni chiusura (basket, gamba singola, orfana, residuo, chiusura del broker, gamba richiusa) entra con la stima dai prezzi di chiusura; la riga di `baskets.csv` si scrive quando lo storico eToro mostra tutte le sue posizioni (`netProfit − fees`), oppure dopo 30 minuti con la stima marcata, che non addestra niente. Una posizione già registrata (marcatore `posizioni:` delle righe del conto) o già in coda non viene registrata di nuovo da nessun percorso (`IsRecorded`); il residuo del kill-switch si pota alla riconciliazione delle posizioni che il conto non mostra più.
- **Storico eToro** (`RefreshRealizedAsync`, una lettura condivisa): circa ogni 5 minuti, ogni 5 s nel minuto dopo una chiusura, ogni 30 s finché una chiusura attende. Serve la coda, «P&L oggi» (`RealizedToday`, pubblicato in modo atomico, uguale al periodo «oggi» dello Storico grazie alla stessa classificazione `PositionOrigins`) e il giudizio sui movimenti di cassa (`EquityTracker`, che non giudica finché lo storico non mostra le chiusure).
- **Perdita giornaliera**: `DailyLoss.IsHit` sull'equity netta dalla mezzanotte UTC, valutata a ogni lettura del conto e a ogni decisione; `DailyLossLatch` tiene il blocco fino alle 00:00 UTC (salvato come `dailyLossDay`); un calo del saldo non ancora spiegato dallo storico sospende le entrate senza chiudere la giornata (D-54): il motore ricorda l'equity più bassa vista nel frattempo, la vista lo dice in `DailyLossHit` anche se l'equity recupera, e la lettura che lo spiega giudica la giornata su quel minimo (una perdita la blocca, un movimento di cassa no; seconda revisione). Il backtest usa la stessa regola (`ReplayDailyLoss`). Vista: `FundsView.DailyLossLatched`, tick `dailyLossLatched`.
- **Saldo all'avvio** (`StartupCash`): il saldo salvato si giudica solo quando lo storico mostra ogni posizione chiusa da allora (`lastPositionIds`, `vanishedUnsettled`, coda); altrimenti resta il riferimento e giudica la riconciliazione.
- **Verifica del realizzato all'avvio** (`RealizedBackfill`, `PositionMap`): righe della 4.0.0-5.0.0 del conto in uso, soglia per conto, abbinamento globale delle note delle gambe singole; righe `correzione` nuove, mai una riga modificata; poi `LearningState.Reseed` e, una volta sola, il ritiro dei modelli addestrati sui proceeds.
- **Stato per conto** (`AccountStateFiles`): `data/state/baskets_state.demo.json` e `.live.json`; migrazione una tantum del file unico della versione precedente (sotto il lock di istanza, `LegacyTarget`): un file della 5.1 va al conto del suo `mode`; uno della 5.0, dove `mode` era la modalità e non il conto, va al conto su cui operava la configurazione della 5.0 (`LegacyStateOwner`, registrato dall'importazione in `import-5.1.json`), senza registrazione solo al conto del motore che lo trova se nomina la sua modalità; Paper, o una modalità diversa da quella della configurazione registrata, resta solo come `.migrato`, mai letto. Un file dell'altro conto non viene mai letto né scritto. Il registro degli ordini (`OrderTracker(path, account)`) è un file solo ma ogni motore lavora solo sui suoi ordini.
- **Kill-switch** (`FlattenProcedure` + `KillAsync`): la scelta esplicita sulle posizioni esterne (`EngineCommand.ForeignChoice`) vince su `risk.closeForeignOnKill`.
## 8. Apprendimento (ADR-0006, ADR-0014)
- **Un solo scrittore** di `data/models` e `knowledge/`: chi tiene `instance.lock`. `LearningState` si costruisce dopo il lock e si salva sotto il suo lock prima di rilasciarlo.
- **Ciclo** = `LearningCycle.Train`, funzione pura in background che legge il ledger in condivisione (`LearningDataset`: righe con `FileShare.ReadWrite|Delete`, cache per file) e restituisce tutto; `CycleRunner` ne fa girare uno alla volta; `LearningState.Apply` lo applica sul thread di decisione in pochi millisecondi (modelli sostituiti, basket chiusi nel frattempo rigiocati, file scritti con `AtomicFile`, `last_cycle.json`).
- **«Esegui ciclo»** (`BotSupervisor.RunLearningCycleAsync`): comando `Learn` al motore acceso; manutenzione sotto il lock a motore fermo (AVVIA 409 finché dura); 409 con un ciclo in corso, con il motore che si avvia (`LoopStarted` falso) o si ferma, o con il lock di un altro processo. Il ciclo settimanale usa lo stesso percorso.
- **Rapporto**: a motore acceso `LearningLiveReport` pubblicato dal thread di decisione (chiusura di barra e di basket, ciclo, comandi, avvio, ogni 60 s); a motore fermo `LearningDiskReader` legge i file in sola lettura (mai un `Ledger` o un `LearningState`), tiene l'ultima lettura buona di un file illeggibile e ricalcola il dataset appena compare una correzione; `LearningReportBuilder` compone `/api/learning`. Ogni `p_ML` viaggia con la sua spiegazione (`ScoreExplanation`: p, intercetta, contributi), salvata con l'ingresso.
## 9. API web
Il contratto completo (campi, tipi, codici HTTP) è `docs/API.md`. Libere senza sessione: `/login`, `/logout`, `/api/health`, `/css/*`, `/img/*`, `/icon.svg`, `/manifest.webmanifest`. JSON scritto a mano con `Utf8JsonWriter`, mai serializzazione per riflessione.
| Rotta | Cosa |
|---|---|
| `GET /`, `/login`, ogni file sotto `wwwroot/` (`/css/…`, `/js/…`, `/js/pages/…`); `POST /login`, `POST /logout` | la pagina e i suoi file, incorporati, con `ETag` e 304; il login mette il cookie e rimanda a `/`, il logout lo toglie |
| `GET /api/health` | `{ok, state, apiState, heartbeatAgeSeconds, heartbeatSeconds, diskWritable, uptimeSeconds}`; usato dal `HEALTHCHECK` del container |
| `GET /api/stream`, `GET /api/snapshot` | il tick v2 (SSE, uno al secondo condiviso; oppure una volta) |
| `GET /api/positions`, `/api/market`, `/api/baskets/detail?name=`, `/api/system` (alias `/api/info`), `/api/learning` | le sezioni a richiesta, con `ETag` |
| `GET /api/log?level=&q=&limit=&after=` | la finestra del log (`LogBuffer`), una riga per messaggio, a incrementi per `seq` |
| `POST /api/commands/{start\|stop\|close\|kill\|reset\|residue\|pause\|resume\|bonifica\|learn}` | corpo `{argument, reason, confirm, foreign}`; risposta `{ok, message, needsPhrase, code?, steps[], positions[]}`; 409 `needsPhrase`/`refused`, 504 `timeout` |
| `GET /api/history/orders\|positions\|periods[?format=csv&from=&to=&basket=&symbol=&outcome=&origin=]` | le tre viste dello Storico (`HistoryBuilder`); `format=csv` scarica il file `;` |
| `GET/POST /api/settings` | il form (gruppi, campi, segreti, versione) e il salvataggio per percorso, applicato a caldo |
| `POST/DELETE /api/settings/keys`, `POST/DELETE /api/settings/telegram-token`, `POST /api/settings/telegram-test`, `POST /api/settings/secrets/unlock`, `POST /api/settings/secrets/reset`, `POST /api/settings/restore` | segreti (verificati contro eToro o Telegram e cifrati), sblocco o ripartenza del deposito, valori di fabbrica |
Il ciclo di vita del processo (`Program.cs`): risolve la password; in `--sample` crea le cartelle temporanee; carica `AppPaths` (semina `encelado.json` e `strategy.json`); inizializza il log (file + console); apre il deposito dei segreti; esegue l'importazione una tantum dalla 5.0 ed elenca le variabili ignorate; crea il provider dei feed, il `NotifierHub`, il supervisore, `HistoryService` e `SettingsRuntime`; avvia Kestrel (rete solo nel container o con `--listen-all`); decide l'avvio automatico (`AutostartPolicy`: mai in Live, che aspetta AVVIA con la frase e manda un avviso; mai con `--no-autostart` o `run.autostart` spento); legge i comandi da stdin; a motore fermo tiene aggiornati i feed; si ferma su Ctrl+C, SIGTERM, `stop` o `--minutes` con `ShutdownAsync`. `--health` interroga `/api/health` ed esce 0/1; `--bonifica` avvia con la bonifica interattiva.
## 10. Vincoli e limiti dell'API eToro
- L'endpoint candele accetta solo `count ≤ 1000` senza data di partenza: dà al massimo ~10 giorni di M15. Lo storico per il backtest viene dai tick MT5 forniti dall'utente (`A:\Download\Trading`, 2018-12 → 2026-09, UTC), convertiti in M15 bid/ask dallo strumento `backtest ticks`.
- Quote di mercato (`/api/v2/market-data/rates`) in batch fino a 1000 strumenti per chiamata: un polling ogni 3 s costa 20 richieste/min sulla quota condivisa di 120/min. Le coppie di conversione della valuta di visualizzazione (EURUSD, GBPUSD, USDCHF, USDJPY, AUDUSD, USDCAD, NZDUSD) viaggiano nella stessa richiesta.
- Quota ordini: 20 richieste/min (demo e reale separate). Un basket costa 2 aperture + 2 chiusure.
- Le quote di `rates` sono senza markup; il costo effettivo (markup + spread di mercato + overnight) arriva da `POST /trading/info/{demo/}costs` (20/min dedicate). Il cost gate somma i due.
- Ordini: `POST /api/v2/trading/execution/{demo/}orders` (asincrono: esito con `orders:lookup?orderId=`; il server **non** registra l'`x-request-id` come `referenceId`, verificato il 2026-09-23); `sellShort` e leva > 1 richiedono `stopLossRate`. Il server può **ridurre** un ordine invece di rifiutarlo (2 000 USD di margine a margine esaurito, 2026-09-16): le unità eseguite si leggono dalla risposta, mai date per scontate. Chiusura: `POST /api/v1/trading/execution/{demo/}market-close-orders/positions/{id}`; la sua risposta non ha il profitto (`proceeds` = margine + profitto): il realizzato si legge dallo storico per `positionId` (`docs/DATA_SOURCES.md` §1.1). Cancellazione: `DELETE /api/v2/trading/execution/{demo/}orders/{id}`.
- Esposizione minima per posizione: 1000 USD (`minPositionExposure`); leva ammessa 1-30 (majors) e 1-20 (minors). Il conto reale dell'utente vale 224,90 USD: con i limiti di rischio della strategia il reale non è praticabile oggi (vedi QUESTIONS D-05).
+110
View File
@@ -0,0 +1,110 @@
# Fonti dei dati
Aggiornato: 2026-10-01 (5.1: rotte di chiusura e storico delle posizioni chiuse come P&L di record, §1.1; feed scaricati in background, §2-3; segreti e file di stato per conto, §4). Ogni fonte è stata verificata alla data indicata; se un feed cambia o sparisce, la voce va aggiornata e la decisione annotata in `docs/QUESTIONS.md`.
## 1. Mercato
| Fonte | Cosa | Formato | Frequenza | Limiti | Fallback |
|---|---|---|---|---|---|
| **eToro Public API** — `GET /api/v2/market-data/rates?instrumentIds=…` | bid/ask di tutti gli strumenti in una chiamata | JSON `{results:[{instrumentId,bid,ask,date,quoteType}]}` | polling ogni `run.pollSeconds` (3 s) | quota condivisa 120/min con le altre rotte di market data; il bot ne usa ~20/min | nessuno: senza quote il bot non decide |
| **eToro Public API** — `GET /api/v1/market-data/instruments/{id}/history/candles/asc/FifteenMinutes/1000` | ultime 1000 candele M15 (mid, senza spread) | JSON | all'avvio, per il riscaldamento e il delta | **non pagina**: niente data di partenza, al massimo ~10 giorni | le barre locali salvate a ogni chiusura |
| **eToro Public API** — `GET /api/v2/market-data/instruments?symbols=…`, `POST /trading/info/{demo/}eligibility` | id, nome, esposizione minima, leve, limiti di stop | JSON | all'avvio, scritti in `instruments.json` | 120/min e 20/min dedicate | valori prudenti incorporati (esposizione minima 1000 USD, leve 1-20) |
| **eToro Public API** — `POST /trading/info/{demo/}costs` | markup, spread di mercato, commissione, overnight e weekend per un ordine ipotetico | JSON `{costs:[{costType, currency, value}]}` — il campo è **`value`** (verificato il 2026-09-16: EURUSD 10 000 unità → markup 0, marketSpread 0,1 USD, overnightFee 0,91 USD/giorno) | ogni 15 minuti per strumento | 20/min dedicate | markup 0 e overnight da `strategy.json` |
| **Tick MetaTrader 5** — `A:\Download\Trading\<SYMBOL>_<da>_<a>.csv` | tick bid/ask 2018-12-12 → 2026-09-15, **UTC** (verificato sui fine settimana: chiusura venerdì 20:53 estate / 21:57 inverno, riapertura domenica 21:05 / 22:05) | tab-separato `<DATE> <TIME> <BID> <ASK> <LAST> <VOLUME> <FLAGS>`; flag 2 = solo bid, 4 = solo ask, 6 = entrambi | una tantum, `backtest ticks` | EURAUD copre solo parte del 2018, del 2021 e del 2026 (39 615 barre contro ~192 000 delle altre): il basket EURAUD/AUDCAD è misurabile solo su quei tratti | — |
| Barre M15 derivate — `Documenti\Encelado\data\market\candles_<SYMBOL>_M15.csv` | OHLC bid e ask, spread medio, numero di tick, provenienza | CSV `;` (schema in `docs/LEDGER_SCHEMA.md`) | scritte dallo strumento e aggiornate dal bot a ogni barra chiusa | — | — |
Qualità (`data/market/data_quality.csv`, generato da `backtest ticks`, e `reports/data_quality.csv` dal bot): buchi > 1 h nei giorni feriali, salti > 2 % fra barre, duplicati. Una barra sospetta sospende le decisioni sul basket coinvolto per quella barra.
### 1.1 Ordini e posizioni (rotte verificate il 2026-09-23 sull'OpenAPI v1.379.0 e con chiamate reali sul conto demo)
| Rotta | Uso | Note verificate |
|---|---|---|
| `POST api/v2/trading/execution/{demo/}orders` | invio dell'ordine (`action open`, `transaction buy/sellShort`, `orderType mkt`, `units`, `leverage`, `stopLossRate`) | risponde 200 con `orderId`; il server lavora l'ordine in modo asincrono. **Non registra l'`x-request-id` come riferimento**: la lettura per `orderId` di un ordine del bot mostra `referenceID = 00000000-0000-0000-0000-000000000000`. Quota 20/min condivisa con chiusure e cancellazioni. |
| `GET api/v2/trading/info/{demo/}orders:lookup?orderId=<id>` | esito dell'ordine, con le posizioni prodotte (`positionExecutions[].positionId`, `openingData.avgPrice`, `units`, `executionTime`, `fees`) | è la **chiave** usata dal bot. `requestedUnits`/`requestedAmount` possono differire dalle unità inviate: il 2026-09-16 il server ha ridotto gli ordini a 2 000 USD di margine (`frozenAmount 2000`, unità a sei decimali ricalcolate). Quota 60/min condivisa con `close-orders/{id}` e `orders/{id}`. |
| `GET api/v2/trading/info/{demo/}orders:lookup?referenceId=<x-request-id>` | ripiego quando la risposta al `POST` è andata persa | 404 per gli ordini v2 del bot (vedi sopra). |
| `GET api/v1/trading/info/{demo/}orders/{orderId}` | ripiego per `orderId` con la risposta v1 (`statusID`, `errorCode`, `positions[] {positionID, rate, units, occurred, isOpen}`) | verificato con l'ordine 381739181. |
| `DELETE api/v2/trading/execution/{demo/}orders/{orderId}` | cancellazione di un ordine non ancora eseguito (kill-switch) | 200 = richiesta accettata, non annullamento avvenuto: confermare con il lookup (7 o 9 = annullato, 6 = in corso). Idempotente su ordini già chiusi. |
| `GET api/v1/trading/info/{demo/}pnl` | conto e posizioni in una chiamata: `clientPortfolio.credit`, `bonusCredit`, `unrealizedPnL`, `positions[] {positionID, instrumentID, isBuy, units, openRate, openDateTime, amount (margine), leverage, unrealizedPnL.pnL, totalFees}` | `equity = credit + bonus + Σ amount + unrealized`; `available = credit + bonus`; `usedMargin = Σ amount`. Il conto demo **non compare** in `api/v1/balances` (solo i conti reali). |
| `POST api/v1/trading/execution/{demo/}market-close-orders/positions/{positionId}` | chiusura di una posizione (corpo `{"InstrumentID": …}`) | risponde con `orderForClose.orderID`: l'esito si legge sulla rotta seguente. Quota 20/min condivisa con gli ordini. |
| `GET api/v1/trading/info/{demo/}close-orders/{orderId}` | esito della chiusura: `statusID`, `errorCode`, `proceeds`, `positions[] {positionID, occurred, rate, units, conversionRate, amount}` | schema verificato il 2026-09-30 (API v1.383.0). **Non ha alcun campo di profitto.** `proceeds` è, per la specifica, il totale restituito dalla chiusura sulle posizioni coinvolte: margine liberato più profitto (una posizione con `amount` 7 210,02 chiusa a +32,00 restituisce 7 242,02). I numeri della 5.0.0 lo confermano: «P&L oggi» di circa 47 000 USD su 139 000 di equity, in linea con la somma di investimento + profitto delle chiusure del giorno. **Non è mai il P&L**. Dalla 4.0.0 alla 5.0.0 il bot lo registrava come realizzato (vedi `docs/LEDGER_SCHEMA.md`, correzioni `pnl_realizzato`); dalla 5.1 resta solo come diagnostica (`CloseOutcome.Proceeds`). `rate` e `conversionRate` (valuta quotata → USD, 1 per le coppie in USD) servono alla **stima provvisoria**: `unità × Δprezzo × conversionRate − fee`, che coincide al centesimo con lo storico su NZDUSD, EURNZD e USDCAD. L'`orderId` della chiusura non è quello dello storico. Quota Lookup (60/min). |
| `GET api/v1/trading/info/trade/{demo/}history?minDate=…&page=…&pageSize=200` | posizioni chiuse: `positionId`, `orderId`, `instrumentId`, `isBuy`, `units`, `openRate`, `closeRate`, `openTimestamp`, `closeTimestamp`, `netProfit`, `fees`, `investment` | **Il P&L di record** di ogni posizione chiusa (dalla 5.1): `netProfit − fees`. `netProfit` **non** include `fees` (nello storico demo del 2026-09 le fee sono sempre 0). `minDate` filtra sull'**ora di chiusura** a partire dalla mezzanotte UTC di quel giorno (verificato il 2026-09-30: `minDate=2026-09-29` comprende le posizioni aperte il 28 e chiuse il 29, esclude quelle chiuse il 28 alle 22:45 UTC); le righe arrivano dalla più recente; lo sguardo all'indietro dev'essere inferiore a un anno. L'`orderId` è l'ordine di **apertura** (`orders/{id}` risponde 200, `close-orders/{id}` 404): lo storico si unisce ai file del bot **per `positionId`**. Quota Default (60/min, budget locale 55): il motore lo legge circa ogni 5 minuti, ogni 5 s nel minuto dopo una chiusura e ogni 30 s finché una chiusura attende. Una pagina che non si legge è un **errore** (`BrokerException`), mai una lista vuota. Fonte del realizzato della scheda Storico, di «P&L oggi», delle righe di `baskets.csv` e della distinzione fra chiusure e movimenti di cassa. |
**Stati dell'ordine** (`status.id` / `statusID`): 1 Received, 2 Placed, 3 Filled, 4 Rejected, 5 PartiallyFilled, 6 PendingCancel, 7 Canceled, 8 Expired, 9 CanceledPartiallyFilled, 10 RejectedPartiallyFilled, 11 WaitingForMarket, 12 PendingTriggeredRate. Il bot tratta 3 e 5 come eseguito, 4, 7, 8, 9, 10 come rifiutato/annullato, 1, 2, 6, 11, 12 come in corso; in assenza di risposta lo stato è `Unknown` e l'ordine resta nel registro. Esiste anche `POST api/v3/trading/execution/{demo/}orders` (202, stessa semantica, `settlementType` obbligatorio): non usato, annotato per il futuro.
## 2. Calendario economico
| Fonte | URL | Formato | Aggiornamento | Note |
|---|---|---|---|---|
| Forex Factory via FairEconomy | `https://nfs.faireconomy.media/ff_calendar_thisweek.json` | JSON `[{title,country,date,impact,forecast,previous,actual}]`, `date` con offset (ora di New York) | il feed cambia più volte al giorno; il bot lo rilegge ogni 10 minuti, mai più di una richiesta al minuto | `country` è già il codice valuta (`USD, EUR, GBP, JPY, AUD, NZD, CAD, CHF, CNY`, `All`); `impact` ∈ {High, Medium, Low, Holiday} |
**Come si scaricano (dalla 5.1).** Calendario e notizie appartengono al processo, non al motore: un solo `FeedContextProvider` li scarica **in background** ogni 10 minuti (`ContextRefresher`, mai dentro il ciclo di decisione: fino alla 5.0 il ciclo aspettava tredici fonti una dopo l'altra, e dopo un'interruzione di rete quotazioni e uscite potevano aspettare minuti) e pubblica una fotografia immutabile; il sentiment, che decade nel tempo, si ricalcola circa una volta al minuto. Il processo li tiene aggiornati **anche a motore fermo**, così la pagina Mercato resta viva. Per ogni fonte la pagina Sistema (`/api/system` → `feeds`) mostra ultima richiesta, ultimo successo, errori di fila, attesa crescente in corso, verdetto di `robots.txt` e ultimo errore; nel tick, `health.feeds` vale `stale` quando il calendario non arriva da tre ore o nessuna fonte di notizie da due, `error` quando tutte le fonti falliscono.
| variante XML | `https://nfs.faireconomy.media/ff_calendar_thisweek.xml` | `<weeklyevents><event>` con `date` MM-DD-YYYY e `time` 8:15am **in UTC** (verificato contro il JSON: "10:30pm" del 09-13 = "18:30-04:00") | idem | usata solo come riserva |
Archivio: `data/calendar/events.jsonl` (append-only, una riga per evento, dedup per `title+date+country`; un `actual` che arriva dopo la pubblicazione è una riga nuova). Feature derivate per ogni valuta: `minutesToNextHigh`, `minutesSinceLastHigh`, `surpriseLast = (actual − forecast)/|forecast|`.
Limite: il feed copre **la settimana corrente**. Non esiste uno storico gratuito: il backtest non applica il blackout né le feature di calendario, e lo dice (`docs/STRATEGY.md`).
## 3. Notizie (RSS)
Tutte lette con `User-Agent: Encelado/4.0 (+correlation baskets; contact: operator)`, al massimo una richiesta al minuto per fonte, con backoff esponenziale sugli errori e rispetto di `robots.txt` (gruppo `User-agent: *`). Verifica del 2026-09-16:
| Fonte | URL | Formato | Esito |
|---|---|---|---|
| FXStreet | `https://www.fxstreet.com/rss/news` | RSS 2.0 | 200 |
| ForexLive | `https://www.forexlive.com/feed/` | RSS 2.0 | 200 |
| Federal Reserve | `https://www.federalreserve.gov/feeds/press_all.xml` | RSS 2.0 | 200 con lo User-Agent del bot; con uno User-Agent minimale risponde con una pagina HTML "not found" |
| BCE | `https://www.ecb.europa.eu/rss/press.html` | RSS 2.0 | 200 |
| Bank of England | `https://www.bankofengland.co.uk/rss/news` | RSS 2.0 | 200 |
| RBA | `https://www.rba.gov.au/rss/rss-cb-media-releases.xml` | RSS 1.0 (RDF) | 200 alla prima verifica, poi "Access Denied" (Akamai) a richieste successive: tenuta con backoff, coperta anche da Google News `"Reserve Bank of Australia"` |
| Bank of Canada | `https://www.bankofcanada.ca/content_type/press-releases/feed/` | RSS 1.0 (RDF) | 200 |
| SNB | `https://www.snb.ch/en/rss/press-releases` | — | **404**: omessa (D-08); coperta da Google News `"Swiss National Bank"` |
| RBNZ | `https://www.rbnz.govt.nz/rss/news` | — | **403** "website unavailable": omessa (D-08); coperta da Google News `RBNZ` |
| Google News | `https://news.google.com/rss/search?q=<query>&hl=en-US&gl=US&ceid=US:en` per `EURUSD`, `"Swiss National Bank"`, `RBNZ`, `forex dollar` | RSS 2.0 | 200 |
Archivio: `data/news/news_YYYYMM.jsonl` (append-only, una riga per item, dedup per `hash(link)`), con `published, source, title, summary, link, currencies, scores{net, hawkish, riskOff}`.
Sentiment senza librerie (`Encelado.Core/News/SentimentLexicon.cs`, `SentimentEngine.cs`): lessico incorporato in tre dimensioni (tono positivo/negativo ~180 termini ciascuno, hawkish/dovish ~80, risk-on/risk-off ~50), negazione a finestra di tre parole, attribuzione alle valute per entità (`Fed, Powell, FOMC → USD; ECB, Lagarde → EUR; BoJ → JPY; RBA → AUD; RBNZ → NZD; BoC → CAD; SNB → CHF; BoE → GBP`), parole-paese e nomi di coppia. Per ogni valuta e finestra (1 h, 4 h, 24 h): `netSentiment`, `hawkishScore`, `riskOff` (globale), `newsCount`, con decadimento esponenziale a emivita 2 h. Le feature di un basket sono le differenze fra le sue due valute non comuni.
Copie dei feed usate dai test: `tests/fixtures/` (scaricate il 2026-09-16).
## 3.1 Telegram Bot API (dalla 5.0)
| Rotta | Uso | Note |
|---|---|---|
| `POST https://api.telegram.org/bot<token>/sendMessage` | notifiche e risposte, corpo `{chat_id, text, parse_mode: "HTML", disable_web_page_preview: true}` | limite 4096 caratteri per messaggio (il bot spezza sulle righe); un invio al secondo; su 429 il corpo porta `parameters.retry_after`; un 4xx (token, chat o markup sbagliati) non viene ritentato |
| `GET https://api.telegram.org/bot<token>/getUpdates?offset=<n>&timeout=25&allowed_updates=["message"]` | comandi in ingresso, long polling da un solo task | solo i messaggi con `chat.id` uguale a `notifications.telegram.chatId` vengono eseguiti; gli altri sono ignorati e annotati nel log; `offset` avanza all'ultimo `update_id` + 1 |
| `GET https://api.telegram.org/bot<token>/getMe` | verifica del token quando si salva da Impostazioni (dalla 5.1) | risponde con il nome del bot, che la pagina mostra; un token rifiutato non viene salvato |
Dalla 5.1 il token del bot si inserisce da **Impostazioni ▸ Notifiche Telegram**, viene verificato con `getMe` e vive solo in `/config/secrets.enc`, cifrato con la password dell'interfaccia; la chat (`chatId`) si imposta nella stessa pagina. Il token non è mai in un file del repository, in `encelado.json` o nell'ambiente: `TELEGRAM_BOT_TOKEN`, `TELEGRAM_CHAT_ID` e il `botToken` scritto a mano in `encelado.json` o in `encelado.local.json` di un'installazione 5.0 vengono importati una volta al primo avvio della 5.1 e poi ignorati (D-48). Il server campione (`--sample`) non apre mai un canale Telegram: un secondo poller sullo stesso bot ruberebbe i comandi a quello vero.
## 4. Schema dei file (nel container `/config` e `/data`; fuori dal container la sandbox `deploy/local/` o `Documenti\Encelado`)
```
/config: encelado.json, strategy.json, instruments.json, STOP (kill-switch da file)
secrets.enc chiavi eToro dei due conti e token Telegram, AES-256-GCM con la password dell'interfaccia (5.1)
secrets.enc.<data>.bak il deposito messo da parte da «Ricomincia» (password cambiata e non sbloccata)
secrets.key chiave locale casuale, solo senza password (sviluppo); sparisce quando la password compare
session.key segreto del server nel cookie di sessione (32 byte casuali, creato al primo avvio con una password); cancellarlo chiude le sessioni
import-5.1.json cosa ha importato una volta l'avvio della 5.1 dalle variabili e dai file della 5.0, e su che conto operava la 5.0 (legacyState)
etoro.keys.enc.migrato il file di chiavi della 5.0, dopo l'importazione (non più letto)
encelado.json.<data>.bak backup di «Ripristina encelado.json di fabbrica»
/data:
data/market/candles_<SYMBOL>_M15.csv timeUtc;bidOpen;bidHigh;bidLow;bidClose;askOpen;askHigh;askLow;askClose;spreadMean;ticks;motivazione
data/market/data_quality.csv simbolo;tick_letti;tick_scartati;barre;prima_barra;ultima_barra;buchi_feriali_oltre_1h;barre_spike;spread_mediano_pip;motivazione
data/calendar/events.jsonl {title,country,date,impact,forecast,previous,actual}
data/news/news_YYYYMM.jsonl {hash,published,source,title,summary,link,currencies[],scores{net,hawkish,riskOff}}
data/cache/<fonte>.xml|json ultimo corpo buono di ogni feed
data/ledger/decisions.jsonl vedi docs/LEDGER_SCHEMA.md (rotazione mensile in decisions_YYYYMM.jsonl)
data/ledger/baskets.csv vedi docs/LEDGER_SCHEMA.md
data/ledger/orders.jsonl una riga per ordine inviato e per cambio di stato (5.0)
data/state/baskets_state.demo.json stato del motore del conto demo: basket aperti, ingressi in attesa, chiusure in attesa del P&L,
picco al netto dei movimenti di cassa, blocchi, residuo, pausa, giornata della perdita giornaliera (5.1)
data/state/baskets_state.live.json lo stesso per il conto reale (5.1); il file unico baskets_state.json della 5.0 resta come .migrato
data/state/pending_orders.json il registro degli ordini (5.0), uno per i due conti: ogni ordine porta il suo mode (5.1)
data/state/heartbeat.json ultimo battito (recovery.heartbeatSeconds, 30 s), run, nota di arresto (5.0)
data/state/instance.lock un solo scrittore per cartella dati: motore, ciclo di apprendimento a motore fermo, backtest learn
data/models/*.json modelli (livelli 1-3), stato del bandit, last_cycle.json, learning_state.json (vedi LEDGER_SCHEMA)
knowledge/*.csv, *.md calibrazione, proposte, registri, insight settimanali
reports/*.csv qualità dati, falsificazione, bonifica_YYYYMMDD, recupero_<run_id> (5.0)
logs/encelado.log log applicativo (;)
```
+96
View File
@@ -0,0 +1,96 @@
# Encelado in Docker
Aggiornato: 2026-10-01 (5.1). Il bot gira **solo** nel container (ADR-0007, ADR-0008): un processo `Encelado.Server` che ospita il motore e serve l'interfaccia web su Kestrel. Dalla 5.1 il container ha **una sola variabile**, la password dell'interfaccia: tutto il resto si imposta dalla pagina (ADR-0010). Per Unraid c'è il template in `deploy/unraid/` (vedi il README lì, anche per l'aggiornamento da un container 5.0).
## Immagine
`192.168.30.23:3000/alby96/encelado:<versione>` e `:latest`, sul registro dei container di Gitea. Si costruisce dalla `Dockerfile` alla radice:
```powershell
dotnet msbuild build/Release.proj -t:Docker # :<versione dal tag> e :latest, con i test dentro la build
docker build -t encelado:dev --build-arg GIT_COMMIT=$(git rev-parse --short=12 HEAD) . # a mano
```
Stadi: `build` (restore + compilazione Release), `test` (la suite xunit: se è rossa l'immagine non esiste), `publish` (framework-dependent, non trimmed), `runtime` (`mcr.microsoft.com/dotnet/aspnet:10.0` + `gosu` + `tzdata`). L'immagine porta le etichette OCI `version` e `revision`; commit e data di build sono in Sistema ▸ Informazioni.
## Volumi
| Dentro | Contenuto | Su Unraid |
|---|---|---|
| `/config` | `encelado.json`, `strategy.json`, `instruments.json`, `secrets.enc` (chiavi eToro dei due conti e token Telegram, cifrati con la password), `import-5.1.json` (cosa è stato importato da un container 5.0), `session.key` (il segreto del server nel cookie di sessione), file `STOP` per il kill-switch | `/mnt/user/appdata/encelado/config` |
| `/data` | `data/` (ledger, stato per conto, registro degli ordini, barre, cache, modelli), `knowledge/`, `reports/`, `results/`, `logs/` | `/mnt/user/appdata/encelado/data` |
Al primo avvio il container semina `encelado.json` e `strategy.json` dai valori di fabbrica. Nel container `run.dataPath`, `knowledgePath`, `reportsPath` e `logging.path` vengono rimappati sotto `/data` qualunque cosa dica il file: non c'è niente da cambiare a mano. I file appartengono a `PUID:PGID` (99:100 di fabbrica, `nobody:users` di Unraid).
## Variabili d'ambiente
| Variabile | Default | Effetto |
|---|---|---|
| `ENCELADO_PASSWORD` | vuoto | **L'unica da impostare**: la password dell'interfaccia («Password interfaccia» nel template, mascherata e obbligatoria). Si scrive una volta nella pagina di accesso e resta in un cookie HttpOnly per 30 giorni (un HMAC della password e di un segreto del server in `/config/session.key`, mai la password); l'API accetta anche `Authorization: Bearer <password>`. **Cifra anche i segreti** salvati da Impostazioni: cambiarla li blocca finché non li sblocchi con quella precedente (o ricominci). **Senza password il server ascolta solo su localhost del container**: dalla rete non si vede niente. `ENCELADO_WEB_TOKEN`, il nome della 5.0, vale ancora come alias deprecato (con un avviso; se sono diverse vince `ENCELADO_PASSWORD`). |
Conto (demo o reale), chiavi eToro dei due conti, Telegram (token, chat, notifiche, comandi), valuta di visualizzazione, livello e rotazione del log, avvio automatico, chiusura all'arresto, strategia: **tutto in Impostazioni**, applicato subito dal bot quando può.
Le altre variabili che il processo legge sono **interne all'immagine** o servono allo sviluppo, e non vanno toccate: `ENCELADO_IN_CONTAINER=1` (il rilevamento del container), `ENCELADO_WEB_PORT=8080` (la porta di Kestrel dentro il container: per un'altra porta si cambia la mappatura), `TZ=UTC`, `PUID=99`, `PGID=100` (l'entrypoint; su Unraid `TZ` lo aggiunge Unraid da sé), `ENCELADO_CONFIG_DIR` e `ENCELADO_DATA_DIR` (cartelle alternative, usate da F5 e dagli script sulla sandbox). `TZ` vale **solo per la visualizzazione**: gli orari scritti dal server (riga di stato) e l'offset del log; gli orologi della pagina usano il fuso del browser e il ledger è sempre UTC.
**Variabili della 5.0** (`ETORO_API_KEY`, `ETORO_USER_KEY`, `ETORO_ENVIRONMENT`, `ENCELADO_EXECUTION_MODE`, `ENCELADO_KEY_PASSPHRASE`, `ENCELADO_CONFIRM_LIVE`, `ENCELADO_AUTOSTART`, `ENCELADO_DISPLAY_CURRENCY`, `ENCELADO_LOG_LEVEL`, `ENCELADO_TIME_ZONE`, `TELEGRAM_BOT_TOKEN`, `TELEGRAM_CHAT_ID`): al **primo avvio della 5.1** vengono importate una volta (le chiavi e il token nel deposito cifrato, solo dove è vuoto; la chat e le impostazioni in `encelado.json`, le impostazioni solo se diverse dal valore di fabbrica e il file è ancora di fabbrica; il vecchio `etoro.keys.enc` con la sua passphrase, poi rinominato `.migrato`). `TZ` e `ENCELADO_CONFIRM_LIVE` non vengono mai importate. Da lì in poi ogni variabile rimasta è **ignorata** ed elencata nel log, nella striscia degli allarmi e in Sistema ▸ Segreti: si possono togliere dal container. Il file `/config/import-5.1.json` ricorda cosa è stato fatto e impedisce di ripeterlo: per cambiare le chiavi più avanti (chiavi rigenerate sul portale) non si tocca il container, si reinseriscono in Impostazioni ▸ Conto; una `ETORO_API_KEY` cambiata nel container verrebbe ignorata e il bot resterebbe con le chiavi vecchie.
## Avvio, arresto, aggiornamento
```powershell
docker compose up -d # sviluppo locale: cartelle in deploy/local/, password "sviluppo" (o ENCELADO_PASSWORD in .env)
docker compose logs -f encelado
docker compose down # SIGTERM → arresto pulito (45 s di grazia)
docker pull 192.168.30.23:3000/alby96/encelado:latest && docker compose up -d # aggiornamento
```
Su `SIGTERM` il server ferma il motore come da `run.closeOnShutdown` (default `false`: i basket restano sul conto con gli stop nativi; `true`: il motore stesso, sul suo thread, blocca le nuove entrate e chiude tutto entro 30 s), dà a un kill-switch in corso 30 s per finire (poi lo interrompe e registra il residuo, Halted-Residuo), chiude il ledger, scrive l'heartbeat con la nota di arresto ed esce con 0. I 45 s di grazia del container (`--stop-timeout 45` nel template, `stop_grace_period` nella compose) coprono questi tempi. Al riavvio riprende lo stato del conto, riconcilia il conto e, se è passato più di `recovery.thresholdMinutes`, esegue il recupero dopo inattività (`docs/RUNBOOK.md`). In modalità **Live** il motore non riparte da solo: resta fermo fino ad AVVIA con la frase `CONFERMO LIVE`, e Telegram lo dice.
## Healthcheck
`HEALTHCHECK` ogni 30 s: `dotnet /app/Encelado.Server.dll --health` chiama `GET /api/health` sulla porta configurata ed esce 0 solo se il server risponde, il disco dei dati è scrivibile e, a motore acceso, l'heartbeat è più fresco di 3 × `recovery.heartbeatSeconds` + 15 s (105 s con il default di 30 s; l'intervallo si cambia a caldo in Impostazioni ▸ Strategia). `docker inspect --format '{{.State.Health.Status}}' encelado` per leggerlo. Il campo JSON di `/api/health` dice quale condizione fallisce. L'heartbeat si scrive all'inizio di ogni giro del motore: un kill-switch o una chiusura che durano minuti possono far risultare il container non sano per quel tempo.
## Log
Sulla console (stdout, `docker logs`) **e** nel file `/data/logs/encelado.log` (CSV `;`, rotazione per dimensione). L'ora nel log è nel fuso `TZ` con l'offset esplicito; il ledger resta UTC. Livello, dimensione e numero dei file si cambiano da Impostazioni ▸ Log, con effetto immediato.
## Rete
Il server ascolta su tutte le interfacce **solo** con `ENCELADO_PASSWORD` impostata **e** nel container (fuori dal container, cioè con F5 o `run-dev`, solo con l'argomento `--listen-all`); altrimenti solo su localhost. Non c'è TLS: l'interfaccia è pensata per la rete locale (Unraid) o dietro un reverse proxy che lo aggiunge. Le rotte `/login`, `/logout`, `/api/health`, `/css/*`, `/img/*`, `/icon.svg` e `/manifest.webmanifest` sono libere; tutto il resto chiede la password.
Protezioni (ADR-0010): ogni POST o DELETE sotto `/api/` deve avere `Content-Type: application/json` (415 altrimenti) e venire dalla stessa origine (`Origin` e `Sec-Fetch-Site`: 403 altrimenti), così una pagina di un altro sito non può comandare il bot; senza password il server risponde 403 a ogni `Host` che non sia `localhost`, `127.0.0.1` o `[::1]`. Dopo una password errata l'indirizzo che l'ha mandata aspetta 1, 2, 4… fino a 30 s (429).
**Dietro un reverse proxy** il proxy deve passare l'header `Host` originale oppure `X-Forwarded-Host`, altrimenti l'`Origin` del browser non torna con l'`Host` che arriva al bot e **ogni salvataggio e ogni comando riceve 403**. Nginx Proxy Manager, SWAG, Caddy e Traefik lo fanno di fabbrica; un `nginx` scritto a mano vuole `proxy_set_header Host $host;`. Il proxy fa sembrare tutti i client un solo indirizzo: l'attesa dopo una password errata vale per tutti quelli che passano da lui.
## Registro privato in HTTP
Il Gitea dell'utente è raggiunto in HTTP: chi fa `docker pull` deve dichiararlo `insecure-registry` (Docker Desktop: *Settings ▸ Docker Engine* → `"insecure-registries": ["192.168.30.23:3000"]`; Unraid: vedi `deploy/unraid/README.md`). Il push dalla catena di rilascio (`-t:Rilascia`) fa `docker login` con il token di `build/gitea.json` e `docker logout` subito dopo.
## Gitea Actions
Due workflow in `.gitea/workflows/`, sul modello di Rea:
| Workflow | Quando | Cosa fa |
|---|---|---|
| `ci.yml` | push su `main`, pull request | `dotnet build -warnaserror` e `dotnet test`; poi `docker build` dell'immagine (senza pubblicarla) per accorgersi di una Dockerfile rotta |
| `release.yml` | tag `v*` | costruisce e pubblica `<host>/alby96/encelado:<versione>` e `:latest` sul registro di Gitea (solo `linux/amd64`: la build esegue i test e sotto QEMU sarebbe lentissima), poi crea la release con il template Unraid allegato; se la release esiste già (creata dalla catena) aggiunge solo l'allegato mancante |
Servono due cose che al 2026-10-01 **mancano ancora**:
1. **Un runner.** Sul server non ce n'è nessuno (`/api/v1/repos/Alby96/Encelado/actions/runners` è vuoto): i workflow restano in coda. Il modo più semplice è un container `gitea/act_runner` su Unraid con il socket di Docker montato (`/var/run/docker.sock`), registrato con il token di *Site Administration ▸ Actions ▸ Runners ▸ Create new runner* e con l'etichetta `ubuntu-latest:docker://catthehacker/ubuntu:act-latest`. Con il registro in HTTP il runner (e la sua immagine di lavoro) deve avere `192.168.30.23:3000` fra gli `insecure-registries`.
2. **Il segreto `REGISTRY_TOKEN`** nel repository (*Impostazioni ▸ Actions ▸ Segreti*): un token dell'utente con `package:write` e `repository:write` (lo stesso di `build/gitea.json` va bene).
Finché il runner non c'è, il rilascio si fa dal PC con `dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=X.Y.Z`, che produce lo stesso risultato (immagine sul registro, tag, release con allegati); i due percorsi sono idempotenti fra loro.
## Prove in locale: la sandbox `deploy/local`
`deploy/local/config` e `deploy/local/data` (ignorate da git) sono il `/config` e il `/data` delle prove sul PC, in tutti e tre i modi di avvio:
| Modo | Comando | Note |
|---|---|---|
| F5 in VS Code | `Encelado (server)` | processo locale, `ENCELADO_CONFIG_DIR`/`ENCELADO_DATA_DIR` puntati alla sandbox, password `sviluppo` (per i segreti della sandbox), **solo localhost** (per la rete serve `--listen-all`), browser aperto da solo, motore fermo finché non premi AVVIA |
| script | `scripts\run-dev.ps1` / `sh scripts/run-dev.sh` (`-Sample`/`--sample`, `-Autostart`/`--autostart`, `-Port`) | come F5 ma da terminale, con i comandi da tastiera |
| container | `scripts\run-docker.ps1` / `sh scripts/run-docker.sh` / `docker compose up -d --build` | l'immagine vera; password `sviluppo` salvo `ENCELADO_PASSWORD` in `.env` (lo script dice da dove viene, mai il valore); `-Down` / `--down` ferma con SIGTERM |
Tutti e tre usano la stessa password `sviluppo`, così i segreti cifrati salvati da Impostazioni (chiavi eToro, token Telegram) in `deploy/local/config/secrets.enc` valgono per F5, per gli script e per il container. `ENCELADO_DATA_DIR` vale anche fuori dal container: separa i dati dalla configurazione come fa `/data`. `Encelado (campione)`, `run-dev -Sample` e `--sample` servono dati d'esempio **in cartelle temporanee** (`%TEMP%/encelado-campione-…`, cancellate all'uscita): non leggono né scrivono la sandbox, i segreti o Telegram, e ogni comando o salvataggio risponde «modalità dimostrativa». Servono a lavorare sulle pagine e a fotografarle (`scripts\screenshots.ps1`).
Fuori dalla sandbox, senza variabili, il processo locale usa `Documenti\Encelado`: sconsigliato, è la cartella dell'installazione 4.0.0.
+70
View File
@@ -0,0 +1,70 @@
# Glossario
| Termine | Significato in Encelado |
|---|---|
| **Basket** | Due posizioni (una per coppia forex) aperte insieme e chiuse insieme, trattate come una sola scommessa sul cross sintetico. |
| **Cross sintetico** | La coppia implicita nelle due gambe: `X = ln A + s·ln B`, con `s = +1` se la valuta comune ha ruoli opposti (EURUSD/USDCHF → EURCHF) e `−1` se uguali. Tutti e cinque i basket della specifica hanno `s = +1`. |
| **Gamba** | Una delle due posizioni del basket. |
| **z-score** | `(X − media_W) / σ_W` del cross sintetico su una finestra di W barre M15. Ingresso a `|z| ≥ z_in`, uscita a `|z| ≤ z_out` o allo stop `|z| ≥ z_stop`. |
| **ρ_W, ρ_20** | Correlazione rolling dei rendimenti delle due gambe su W e su 20 barre. Attesa negativa per i basket della specifica (`rho_min` −0,6). |
| **Half-life (HL)** | Semiperiodo di mean reversion del cross, in barre, da un OLS di Δx su x(t−1). Ammesso fra `halfLifeMinBars` e `halfLifeMaxBars`. |
| **Preset** | Conservative / Moderate / Aggressive: z_in, rischio per basket, numero massimo di basket, TP in pip, aggiunte, z_stop. Dalla 5.1 è parte fissa della strategia (Impostazioni ▸ Strategia): un cambio vale per i basket nuovi, quelli aperti tengono i valori e il preset con cui sono entrati. |
| **TP di basket** | Take-profit in pip, somma dei pip delle due gambe (come nell'interfaccia di riferimento). |
| **Cost gate** | Il rifiuto di un ingresso se il TP non copre almeno `costMultiple` volte il costo stimato (spread reale + markup + commissioni + overnight atteso), o se lo spread è più del doppio della mediana delle ultime 24 ore. |
| **Break-even** | Il costo in pip oltre il quale il P&L medio lordo di un basket diventa negativo: se è vicino a zero, il segnale non ha contenuto. |
| **Vol-parity sizing** | Le unità di ogni gamba sono inversamente proporzionali alla sua volatilità (ATR), così le due gambe contribuiscono allo stesso rischio; il rischio totale è `riskPerBasketPct` dell'equity alla distanza dello stop. |
| **Leg-risk** | Il rischio di restare con una sola gamba: se la seconda viene rifiutata, la prima viene chiusa subito (`leg_risk_unwind`); se la seconda è senza esito, il basket aspetta (`PendingB`) finché il registro degli ordini non sa. |
| **Registro degli ordini** | `OrderTracker` e il file `data/state/pending_orders.json`: ogni ordine inviato, scritto prima della chiamata e seguito finché il server non dice eseguito, rifiutato o annullato, o finché la posizione non compare sul conto. Un file per i due conti; ogni ordine porta il suo conto e un motore tocca solo i suoi. |
| **PendingA / PendingB** | Stati del basket con una gamba senza esito: nessun nuovo ordine, valutazione sospesa, ripresa alla risoluzione. |
| **Orfana-bot** | Una posizione sul conto aperta dal bot (registro o firma nel ledger) che non appartiene a nessun basket: adottata e chiusa. |
| **Esterna** | Una posizione sul conto senza la firma del bot: segnalata, contata, mai toccata (salvo dal kill-switch con la scelta esplicita o con `risk.closeForeignOnKill`). |
| **Movimento di cassa** | Deposito, prelievo o accredito virtuale: un salto del saldo che nessuna chiusura spiega. Escluso dal P&L, dal picco e dal drawdown. |
| **Proceeds** | Il campo della risposta di chiusura di eToro: il denaro restituito al conto, cioè margine liberato più profitto. **Non è il P&L**: dalla 4.0.0 alla 5.0.0 il bot lo registrava come tale (il «P&L oggi» di 47 000 USD su 139 000), corretto dalla 5.1 (ADR-0011). |
| **Realizzato / P&L di record** | Il risultato di una posizione chiusa secondo lo storico di eToro: `netProfit − fees` della riga con lo stesso `positionId`. È la fonte della pagina Storico, di «P&L oggi», delle righe di `baskets.csv` e delle etichette. |
| **Stima provvisoria** | Il risultato di una chiusura calcolato dalla risposta di chiusura (unità × differenza di prezzo × tasso di conversione − costi), usato finché lo storico non conferma; scritto come «P&L: stima» dopo 30 minuti, mai usato per addestrare. |
| **Coda di regolamento** | `pendingSettlements` nello stato del conto: le chiusure che aspettano lo storico eToro per diventare righe di `baskets.csv`. Sopravvive ai riavvii. |
| **P&L oggi** | Il realizzato netto delle posizioni del bot chiuse nella giornata UTC (più le stime non ancora confermate, segnate «stima»); uguale al periodo «oggi» dello Storico. Accanto: la variazione dell'equity netta da mezzanotte. |
| **Correzione `pnl_realizzato`** | Una riga nuova di `decisions.jsonl` che dà il realizzato vero di una riga di `baskets.csv` scritta dalla 4.0.0-5.0.0; il lettore corretto la applica. Il ledger non si modifica mai. |
| **Bonifica** | La pulizia una tantum delle orfane con conferma per posizione (`--bonifica`, pagina Posizioni). |
| **Halted-Residuo** | Lo stato del motore dopo un kill-switch che non è riuscito ad appiattire le posizioni del bot (o interrotto dall'arresto del processo): allarme con l'elenco, reset rifiutato finché restano. |
| **Verifica di piattezza** | La rilettura del conto dopo il kill-switch finché le posizioni del bot non sono sparite; niente è «chiuso» prima. |
| **Margin guard** | Sotto equity / margine usato = 1,5 niente entrate; sotto 1,2 si chiude il basket con il P&L peggiore. |
| **sizing_bound** | Quale vincolo ha deciso la size di un basket: `risk`, `margin`, `leverage`, `units`; `min_exposure` quando nessuna size è ammessa. |
| **Heartbeat** | `data/state/heartbeat.json`, scritto ogni `recovery.heartbeatSeconds` (30 s): misura l'inattività che fa scattare il recupero; `/api/health` lo vuole più fresco di 3 intervalli + 15 s. |
| **Recupero** | La procedura dopo un'inattività oltre la soglia: ordini pendenti, riconciliazione, barre perse, ogni basket aperto rivalutato (chiudi/tieni), rapporto, riscaldamento. |
| **Lock di istanza** | `data/state/instance.lock`, tenuto in esclusiva: un solo scrittore per cartella dati (il motore, la manutenzione dell'apprendimento a motore fermo, `backtest learn`). |
| **Lucchetto del ciclo di vita** | Il lucchetto del supervisore che fa passare uno alla volta avvio, arresto, riavvio automatico, rilascio di un motore in errore e ciclo di apprendimento a motore fermo (ADR-0012). |
| **Comando critico** | Kill-switch, chiusura di un basket, chiusura dei residui o chiusura della bonifica in coda o in corso: FERMA e i riavvii automatici non li interrompono (409), finché il motore li ha in mano, anche se chi li ha chiesti ha smesso di aspettare. |
| **Equity stop** | Chiusura di tutto e blocco a un drawdown del 9 % dal picco; riparte solo con un reset motivato. |
| **Perdita giornaliera** | Il calo dell'equity netta dalla mezzanotte UTC oltre `dailyLossPct` (3 %): raggiunto una volta, niente nuove entrate né aggiunte fino alle 00:00 UTC anche se l'equity recupera (D-52); non chiude niente. |
| **Kill-switch** | Chiusura immediata di tutte le posizioni del bot e blocco delle nuove entrate: pulsante KILL, `kill` da console, `/kill CONFERMO` da Telegram o file `STOP` in `/config`. |
| **Demo / Live** | La modalità, che dalla 5.1 è anche il conto: Demo = conto demo eToro (ordini veri, denaro virtuale), Live = conto reale (`run.allowLive` e la frase `CONFERMO LIVE` a ogni avvio; non parte mai da solo). Il bot opera da solo in entrambe (D-20). `Paper` (simulatore locale) è stata eliminata nella 5.1. |
| **Stato per conto** | `baskets_state.demo.json` e `baskets_state.live.json`: basket, blocchi, residui, pausa, picco, chiusure in attesa e giornata della perdita giornaliera di ciascun conto; un cambio di conto non tocca l'altro (D-53). |
| **Ledger** | `decisions.jsonl` (ogni decisione con le sue feature), `baskets.csv` (ogni basket chiuso), `orders.jsonl` (ogni ordine). Append-only: le correzioni sono righe nuove. |
| **Meta-modello** | La regressione logistica (livello 1) che stima la probabilità che un basket finisca in utile. In ombra finché non supera i cancelli di attivazione. |
| **Challenger** | L'MLP (livello 2) valutato accanto al campione; addestrato solo con `learning.enabled` e `learning.challenger` accesi. |
| **Bandit** | Il campionamento di Thompson (livello 3) che propone il preset per terzile di volatilità; premia il preset con cui il basket è entrato e non applica mai niente. |
| **Ciclo di apprendimento** | Ricostruzione del dataset dal ledger, valutazione walk-forward, riaddestramento, base di conoscenza. Gira in background e il thread di decisione lo applica (ADR-0014); «Esegui ciclo» nella pagina Apprendimento, settimanale solo con `learning.weeklyCycle`. |
| **Manutenzione a motore fermo** | «Esegui ciclo» con il motore fermo: il server prende il lock di istanza, addestra e applica; AVVIA risponde 409 finché dura. |
| **Walk-forward** | Valutazione in cui ogni previsione usa solo dati precedenti; per la griglia del backtest: scegli il migliore dei 6 mesi passati, applicalo al mese successivo. |
| **PSR / DSR** | Probabilistic e Deflated Sharpe Ratio: la probabilità che lo Sharpe osservato sia sopra zero, tenendo conto di asimmetria, curtosi, lunghezza e (DSR) del numero di configurazioni provate. |
| **PBO** | Probabilità di overfitting del backtest (CSCV, 16 blocchi): quante volte la configurazione migliore in-sample finisce sotto la mediana out-of-sample. |
| **Falsificazione** | I test di §9.2: ZScore contro PipDivergence, averaging on/off, con e senza stop, cost gate a 2×/3×/4×, segnale invertito. Servono a rompere il risultato, non a confermarlo. |
| **Forward test** | Il periodo in Demo con metrica, soglia e durata scritte prima (`knowledge/preregistrazione.csv`). |
| **Blackout** | Niente entrate 45 minuti prima e 30 dopo un evento ad alto impatto sulle valute del basket. |
| **PSI** | Population Stability Index: misura la deriva della distribuzione di una feature rispetto all'addestramento (non collegato a niente: va reintrodotto quando il meta-modello sarà attivabile). |
| **HAR-RV** | Modello eterogeneo autoregressivo della varianza realizzata (medie a 15 minuti, 4 ore e 24 ore). |
| **Run id** | Identificatore della sessione del bot, scritto in ogni riga del ledger con l'hash di `strategy.json`. |
| **Vista pubblicata** | La fotografia immutabile dello stato del motore (`EngineView`) che il thread di decisione pubblica dopo ogni giro, quotazione, transizione, comando e riconciliazione. Web, console e Telegram leggono solo quella (ADR-0012). |
| **Tick** | Il JSON che il server manda alla pagina una volta al secondo (v2, `docs/API.md`): stato, allarmi, conto, basket, quotazioni, salute, apprendimento, le righe di log nuove e le versioni delle sezioni. Costruito una volta per tutti i browser. |
| **Sezione a richiesta** | Le parti pesanti (posizioni, mercato, dettaglio basket, sistema, apprendimento) lette dalla pagina con `ETag` solo quando la loro versione nel tick cambia. |
| **SSE** | Server-Sent Events: la rotta `/api/stream` che spinge il tick al browser, uno al secondo. |
| **Password interfaccia** | `ENCELADO_PASSWORD` (alias deprecato `ENCELADO_WEB_TOKEN`): apre l'interfaccia e cifra i segreti. Senza, il server ascolta solo su localhost e non chiede niente. |
| **Deposito dei segreti** | `/config/secrets.enc`: chiavi eToro dei due conti e token Telegram, cifrati con la password (AES-256-GCM). Stati: aperto, vuoto, bloccato (password cambiata: si sblocca con la precedente o si ricomincia), chiave locale (sviluppo senza password). |
| **Importazione una tantum** | Al primo avvio della 5.1 le variabili e i file della 5.0 (chiavi, token, chat, alcune impostazioni) passano nel deposito e in `encelado.json`; poi le variabili rimaste sono ignorate e segnalate (`import-5.1.json`). |
| **Applicazione a caldo** | Ogni impostazione salvata ha un momento d'effetto: ⚡ subito nel processo, ⚙ nel motore in esecuzione (sul thread di decisione), ↻ con un riavvio automatico del motore che non chiude niente (Live: con la frase). |
| **Valuta di visualizzazione** | La valuta con cui la pagina mostra gli importi (`ui.displayCurrency`, Impostazioni ▸ Interfaccia); conversione solo nel browser con il tasso delle quotazioni, ledger sempre in USD. |
| **Modalità campione** | `--sample`: il server serve dati d'esempio per ogni rotta e non avvia il motore; lavora in cartelle temporanee, non tocca configurazione, segreti, dati né Telegram, e rifiuta ogni scrittura. Per lavorare sulle pagine e fotografarle. |
| **Pill del motore** | Nella barra in alto: pallino dello stato (verde in esecuzione, grigio fermo, ambra in avvio/arresto o con entrate bloccate, rosso in errore o bloccato) e il conto (`DEMO`, `LIVE` su fondo rosso). |
| **Orologi delle valute** | Nella barra in alto, uno per fuso delle valute trattate (Nuova Zelanda, Australia, Europa centrale/Svizzera, USA/Canada) con le bandiere, più il fuso del computer solo se diverso (D-49). |
| **Menu** | La colonna a sinistra con le nove pagine (Dashboard, Basket, Posizioni, Mercato, Storico, Apprendimento, Log, Sistema, Impostazioni), 212 o 56 px. |
+66
View File
@@ -0,0 +1,66 @@
# Problemi noti e limiti
Aggiornato: 2026-10-01 (5.1). Una voce per limite, con lo stato. Quando un limite viene rimosso, la voce si sposta nel `CHANGELOG.md`.
## Strategia
- **Il backtest è negativo.** Su 7,75 anni di barre M15 nessuna configurazione della griglia è profittevole al netto dei costi assunti; il break-even è vicino a zero, cioè il segnale non ha contenuto misurabile (`docs/STRATEGY.md`). Il modulo resta uno strumento di forward test in Demo, non un sistema da mettere sul reale.
- I numeri del backtest in `docs/STRATEGY.md` §3 sono del 2026-09-16: precedono i limiti di margine della 5.0 e il blocco della perdita giornaliera fino a mezzanotte della 5.1. Vanno rifatti prima di trarne altre conclusioni (il segno del verdetto non dovrebbe cambiare).
- **EURAUD** ha tick solo per parti del 2018, 2021 e 2026: il basket EURAUD/AUDCAD è misurabile in backtest solo su quei tratti.
- Il backtest non ha calendario né notizie: blackout e sentiment sono attivi solo dal vivo. L'effetto del blackout sui risultati non è misurato.
- **Il cancello di correlazione ρ_W ≤ −0,6 si apre di rado sulle barre M15**: nelle 4 ore di Demo del 2026-09-16 31 segnali su 31 sono stati rifiutati per quel solo motivo. Non è un bug: è la soglia della specifica; va misurata sul ledger prima di proporre un valore diverso (`knowledge/proposals.csv`).
- I costi del backtest sono assunzioni (spread tipici pubblicati o spread dei tick, overnight 0,3 o 0,9 pip/gamba/giorno). Il costo vero si misura solo nel ledger del Demo.
## eToro
- L'endpoint delle candele non pagina: al massimo ~10 giorni di M15. Lo storico dipende dai tick forniti dall'utente.
- L'API demo mostra spread di mercato di 0,1-0,7 pip senza markup e un overnight di 0,91 USD/giorno per 10 000 EURUSD. Se l'esecuzione reale applica uno spread diverso, lo si vedrà dallo slippage scritto nel ledger a ogni ingresso.
- Il campo dei costi si chiama `value` (non `amount`, come si era scritto in prima battuta): corretto il 2026-09-16 pomeriggio; le righe del ledger della mattina hanno `markupA/B = 0` e `overnight` nullo per questo motivo.
- Il conto reale dell'utente vale 224,90 USD (2026-09-23): con l'esposizione minima di 1000 USD per gamba il Live non è praticabile a prescindere dai cancelli.
- **Il server non registra l'`x-request-id` come `referenceId`** degli ordini v2: il lookup per riferimento risponde 404 anche per ordini eseguiti. Dalla 5.0 l'esito si legge per `orderId`; il riferimento resta solo come ripiego (ADR-0009).
- **A margine esaurito il server riduce l'ordine** a un importo fisso (2 000 USD di margine osservati il 16-21/9) invece di rifiutarlo; la regola non è documentata nell'OpenAPI. Il bot registra `unita_richieste` e `unita_eseguite` in `orders.jsonl` e dimensiona la gamba B sulle unità eseguite di A; i limiti di margine della Fase 2 evitano di arrivarci.
- **La risposta di chiusura non ha il profitto** (solo `proceeds`, margine più profitto): il realizzato si legge dallo storico, che arriva da qualche secondo a qualche minuto dopo la chiusura. Fino ad allora «P&L oggi» porta una stima segnata «stima»; dopo 30 minuti senza storico la riga di `baskets.csv` viene scritta con la stima e non addestra niente (ADR-0011).
## Dati scritti dalla 4.0.0 alla 5.0.0
- **I messaggi Telegram e le righe di log già inviati** dalla 4.0.0 alla 5.0.0 mostravano i proceeds delle chiusure come «netto» e «P&L oggi» (per esempio 47 000 USD su 139 000 di equity): restano come sono, non si possono correggere. Il ledger invece è corretto con righe `correzione` (ADR-0011).
- Le righe 4.0.x di basket con aggiunte e senza `orders.jsonl` non si possono ricondurre alle loro posizioni: restano **non verificabili** (niente etichetta, escluse da addestramento e riepiloghi). Lo stesso per le gambe singole il cui abbinamento con le note è ambiguo.
- Un'installazione che aveva già fatto la verifica del realizzato con la prima 5.1 (nota senza `mode`) la ripete una volta, senza effetti, al primo avvio della 5.1.0, e scrive una nota per conto.
## Feed
- **Google News** vieta `/rss/search` nel `robots.txt`: le cinque query (EURUSD, SNB, RBNZ, RBA, forex) non vengono scaricate e restano vuote. SNB e RBNZ non hanno quindi nessuna fonte; RBA solo il feed ufficiale, che risponde 403 a intermittenza (Akamai). Il sentiment su CHF, NZD e in parte AUD è di fatto zero.
- Il feed della Fed risponde 404 a tratti (osservato alle 15:16 UTC+2 del 2026-09-16): la cache copre i buchi.
- Il calendario FairEconomy è settimanale: la settimana successiva compare solo da domenica.
- Telegram non avvisa dei feed (calendario, RSS) in errore da più di un'ora, e la barra in alto non li mostra: lo stato di ogni fonte si vede solo in Sistema ▸ Feed (ultimo successo, errori, attesa; `health.feeds` nel tick).
## Bot
- Un movimento di cassa viene riconosciuto dal salto del saldo (oltre 10 USD e 0,25 %): un accredito piccolo sotto quella soglia passa per rumore; un prelievo che coincide con una chiusura viene distinto solo se lo storico del conto risponde.
- Un movimento di cassa del demo che coincide con un'esecuzione ridotta dal server (il caso del 16-21/9) viene riconosciuto solo se il salto del saldo non è spiegato dalle chiusure: il matching è per differenza, non per una rotta dell'API.
- **Una gamba aperta e chiusa fra due riconciliazioni** (20 s; per esempio una gamba A richiusa subito per leg-risk) non entra mai nell'elenco delle posizioni viste: se il suo risultato supera la tolleranza (10 USD o lo 0,25 % del saldo) il salto del saldo viene giudicato un movimento di cassa, e quella perdita sfugge all'equity stop e alla perdita giornaliera. La riga di `baskets.csv` e «P&L oggi» restano giusti (vengono dallo storico). Da correggere aggiungendo all'elenco le posizioni in coda di regolamento.
- **Kill-switch interni**: il kill-switch del file `STOP` e l'equity stop non passano dal supervisore come comandi, quindi FERMA o un riavvio automatico possono interromperli a metà. Il residuo viene registrato e il blocco salvato forza l'uscita dei basket ripresi all'avvio successivo; chiuderlo del tutto richiede un'indicazione «occupato» del motore.
- **L'heartbeat si scrive all'inizio di ogni giro del ciclo**: un kill-switch o una chiusura che durano minuti fanno risultare il container non sano (`/api/health`); un sistema che riavvia i container non sani potrebbe interrompere un kill-switch.
- Le chiusure fatte all'arresto con `run.closeOnShutdown` sono scritte con `exit_reason = kill_switch`: un codice proprio (per esempio `arresto`) sarebbe più onesto, ma tocca il vocabolario del ledger e le etichette dell'interfaccia.
- Le coppie dei basket cambiate a mano in `strategy.json`, seguite da un salvataggio qualsiasi che tocca il motore, riavviano il motore senza la guardia del cambio (quella del cambio dalle Impostazioni): i basket delle coppie vecchie non vengono ripresi e la riconciliazione li chiude come orfane.
- Il ciclo settimanale gira solo con `learning.enabled` e `learning.weeklyCycle` accesi, mentre il bot è acceso la domenica dopo le 10 UTC (o al primo avvio dopo sette giorni); «Esegui ciclo» funziona sempre.
- **Apprendimento**: il vettore che il modello vivo valuta alla chiusura di barra ha `costPips` a 0 (il costo dell'ingresso non è ancora calcolato) e `buy_cross` senza l'eventuale inversione del segnale, mentre la riga d'ingresso su cui il ciclo addestra ha i valori veri; per questo a motore fermo la pagina dice spesso «ricalcolata con il modello di oggi» per i basket piatti. Un ingresso completato dopo un riavvio a metà (gamba in attesa) non ha il vettore della decisione e non diventa una riga di addestramento.
## Container e interfaccia web
- Il server non ha TLS: l'interfaccia è pensata per la rete locale (Unraid) o dietro un reverse proxy che lo aggiunge. Senza `ENCELADO_PASSWORD` ascolta solo su localhost del container.
- **Dietro un reverse proxy** il proxy deve passare l'`Host` originale o `X-Forwarded-Host`, altrimenti ogni salvataggio e ogni comando ricevono 403 (Nginx Proxy Manager, SWAG, Caddy e Traefik lo fanno da soli; un nginx scritto a mano vuole `proxy_set_header Host $host`). Il proxy fa sembrare tutti i client un solo indirizzo: l'attesa dopo una password errata vale per tutti (fidarsi di `X-Forwarded-For` richiederebbe un'impostazione dei proxy fidati, che non esiste).
- Le righe di `baskets.csv` e di `decisions.jsonl` scritte dalla 5.0 portano nel `mode` la modalità, non il conto: con `Live` accanto a `etoro.environment` demo (o `Demo` accanto a `real`) la verifica del realizzato le cerca sul conto sbagliato (un motore Live le dichiara non verificabili, uno Demo non le guarda) e finché non succede restano con l'etichetta dei proceeds. Lo stato della 5.0 invece va al conto giusto (la registrazione dell'importazione, `legacyState`). Con la configurazione di fabbrica della 5.0 (Demo e demo) il problema non c'è.
- Il registro dei container di Gitea è in HTTP: chi fa `docker pull` deve dichiararlo `insecure-registry` (Docker Desktop e Unraid, vedi `docs/DOCKER.md`).
- **Gitea Actions senza runner**: `ci.yml` e `release.yml` restano in coda finché sul server non c'è un runner (e il segreto `REGISTRY_TOKEN`); il rilascio si fa dal PC con la catena (`docs/DOCKER.md`).
- Il template Unraid non è pubblicato in un repository di template della community: si installa dall'URL raw del file (`deploy/unraid/README.md`).
- La valuta di visualizzazione usa il tasso della quotazione più recente ricevuta dal polling; con il mercato chiuso il tasso invecchia e il tooltip lo dice.
- L'interfaccia pesa circa 295 KB di JavaScript non minificato (90 KB con gzip) e Kestrel non comprime i file statici.
- Mercato: a 1440 px la colonna «Età» delle quotazioni sparisce (la sezione è stretta); Storico: il motivo d'uscita lungo (rientro dello z-score) finisce con i puntini, intero nel tooltip.
- Log: la ricerca usa il testo del file (il `q` del server), quindi trova `tp_pips` ma non «take-profit», che è l'etichetta italiana mostrata a schermo.
## Codice
- `BasketEngine` è spezzato in undici file parziali; il file principale resta di ~1 800 righe (loop, decisioni, esecuzione).
- I test dell'interfaccia (`EmbeddedUiTests`, `WebHostTests`) coprono l'HTML incorporato, ogni `import` dei moduli con i nomi esportati, i file serviti con il loro tipo, la password, il cookie e lo stream, non il comportamento della pagina nel browser (JavaScript, dialoghi): quello si controlla con `--sample`, con gli screenshot in `docs/img/` e con i controlli nel browser della revisione, che non stanno nel repository.
- Il test (l) copre i blocchi nel decisore, non la simulazione completa dell'equity stop nel motore live; quella è coperta dal backtest (`EquityStops` in `BacktestResult`) e dal ledger.
+173
View File
@@ -0,0 +1,173 @@
# Schema del ledger e delle tabelle
Regole comuni: UTC ovunque, `CultureInfo.InvariantCulture` per numeri e date, CSV con separatore `;` e ultima colonna `motivazione`, JSONL append-only. **Nessuna riga viene mai modificata**: le correzioni sono righe nuove con `evento = correzione`. Ogni riga porta `run_id` e, dove ha senso, `config_hash` (SHA-256 abbreviato di `strategy.json` canonicalizzato).
## `data/ledger/decisions.jsonl`
Una riga per **ogni** valutazione di ogni basket alla chiusura di ogni barra M15 (ingresso, skip, aggiunta, posizione, uscita) più le uscite decise su una quotazione intermedia e gli esiti di esecuzione. Le feature sono quelle disponibili **al momento della decisione**: è la regola anti look-ahead, e il dataset di addestramento è questo file, non una ricostruzione. Il file ruota ogni mese in `decisions_YYYYMM.jsonl`, solo in avanti (dalla 5.1: una riga tardiva del mese precedente, come l'ultima barra valutata dopo la mezzanotte, resta nel file corrente con la sua ora; un nome già preso diventa `decisions_YYYYMM_02.jsonl`, che si ordina subito dopo). Chi legge il ledger legge tutti i file `decisions*.jsonl`.
| Campo | Tipo | Significato |
|---|---|---|
| `ts` | ISO 8601 UTC | istante della valutazione |
| `run_id` | testo | `yyyyMMdd-HHmmss-xxxxxx` della sessione del bot |
| `config_hash` | testo | hash di `strategy.json` in vigore |
| `basket` | testo | `A/B`, es. `EURUSD/USDCHF` |
| `basket_id` | testo | id del basket aperto (`B<yyyyMMddHHmmss>-<AB>`), vuoto se piatto; collega a `baskets.csv` |
| `cross` | testo | cross sintetico (`EURCHF`) |
| `mode` | testo | `Demo` o `Live`, cioè il conto (dalla 5.1 la modalità sceglie il conto). Le righe storiche portano anche `Paper` (fino alla 5.0.0, mai riscritte e mai contate come Demo) e, prima del 2026-09-16 pomeriggio, `DemoApprove`/`DemoAuto`/`LiveApprove`/`LiveAuto` (contate come Demo e Live) |
| `preset` | testo | `CONSERVATIVE`, `MODERATE`, `AGGRESSIVE` |
| `evento` | testo | `skip`, `segnale_ingresso`, `ingresso`, `rifiuto`, `leg_risk_unwind`, `posizione`, `segnale_aggiunta`, `aggiunta`, `segnale_uscita`, `uscita`, `correzione`; dalla 5.0 anche le righe di evento (senza feature, solo `ts`, `run_id`, `evento`, `basket_id`, campi propri e `motivazione`): `pending` (gamba senza esito, con `leg`, `client_ref`, `order_id`), `pending_risolto` (con `esito`, `fonte`, `position_id`), `orfana_adottata` e `orfana_chiusa` (con `position_id`, `strumento`, `exit_reason` e, fino alla 5.0.0, `pnl` = il `proceeds` della chiusura; dalla 5.1 `stima`), `movimento_di_cassa` (con `importo`, `saldo_prima`, `saldo_dopo`, `chiusure_nel_frattempo`, `cassa_cumulata`), `margin_guard` (con `equity`, `margine_usato`), `kill_switch_avviato` (dalla 5.1 con `esterne` = se il kill-switch chiude anche le posizioni esterne ed `esterne_da` = `comando` quando l'ha scelto chi l'ha lanciato — la casella del dialogo, la risposta della console — o `impostazione` quando vale `risk.closeForeignOnKill`), `kill_switch_concluso` (con `stato` = `Halted` o `Halted-Residuo`, `chiuse`, `residuo`, `annullati` e, fino alla 5.0.0, `pnl` = somma dei `proceeds`; dalla 5.1 `pnl_bot` e `pnl_esterne` — stime dai prezzi di chiusura, le posizioni del bot separate da quelle esterne —, `pnl_bot_sconosciuti`, `pnl_esterne_sconosciuti`, `pnl_fonte`), `kill_switch_interrotto` (dalla 5.1: l'arresto del processo ha interrotto un kill-switch in corso dopo 30 s; `residuo` = quante posizioni note del bot sono state registrate come residuo, stato `Halted-Residuo`), `residuo_chiuso`, `reset_rifiutato`, `reset_concluso`, `recupero_avviato` (con `inattivita_min`, `barre`; dalla 5.1 anche per un conto i cui basket nessuno ha seguito oltre la soglia mentre il bot girava sull'altro), `recupero_concluso` (con `inattivita_min`, `barre`, `chiusi`, `tenuti`), `comando` (ogni comando dall'interfaccia, dalla console o da Telegram: `comando` = il tipo — `Close`, `KillSwitch`, `ResetEquityStop`, `CloseResidue`, `Bonifica`, `History`, `Pause`, `Resume`, `ApplySettings`, `Learn`, e dalla 5.1 `Shutdown` (argomento `chiudi`, la chiusura all'arresto con `run.closeOnShutdown`), `PrepareAccountSwitch` e `CancelAccountSwitch` (il controllo del cambio di conto) —, `argomento`, `ok`; la motivazione porta l'origine e la prima riga dell'esito; dalla 5.1 anche i comandi mai eseguiti o interrotti dall'arresto del motore, con `ok = false` e «comando interrotto: il motore si è fermato»), `configurazione` (dalla 5.1: un salvataggio delle impostazioni applicato dal motore in esecuzione; `config_hash_precedente`, `config_hash`, `preset`, `chiavi` = i percorsi cambiati); la nota `leg_risk_unwind` (gamba A eseguita in ritardo e richiusa) porta `position_id` e fino alla 5.0.0 `pnl` (proceeds), dalla 5.1 `stima`. Dalla 5.1: `realizzato` (una chiusura regolata sullo storico eToro: `basket`, `exit_reason`, `fonte` = `storico eToro` / `stima dai prezzi di chiusura` / `simulatore`, `position_ids`, `pnl_lordo`, `pnl_netto`, `stima` = il valore stimato alla chiusura) e `verifica_realizzato` (la verifica del realizzato all'avvio: `mode` = il conto verificato, `fino_a` = ora di chiusura dell'ultima riga verificata, `righe`, `concordi`, `corrette`, `non_verificabili`; la motivazione dice «… (conto Demo)»). La nota `ingresso` (un ingresso completato dopo una gamba in attesa, senza riga di valutazione propria) dalla 5.1 porta `basket`, l'array `features` (il vettore della decisione che ha aperto il basket) e `p_ML`, quando il motore li ha ancora; dopo un riavvio a metà ingresso non li ha, e quel basket non diventa una riga di addestramento. I testi «netto … USD» delle righe `uscita` e `residuo_chiuso` fino alla 5.0.0 sono proceeds; dalla 5.1 dicono «stima … in attesa dello storico eToro» |
| `decision` | testo | `Skip`, `Enter`, `Add`, `Exit`, `Hold` |
| `buy_cross` | bool | verso deciso (compra il cross = compra entrambe le gambe nei cinque basket) |
| `z`, `z_in_eff` | numero | z-score del cross e soglia effettiva (scalata dalla vol prevista) |
| `D_pips` | numero | divergenza in pip dall'ancora (solo `PipDivergence`) |
| `rho_W`, `rho_20` | numero | correlazione rolling dei rendimenti su `window` e `windowShort` |
| `halfLife` | numero | emivita OLS in barre (null se λ ≥ 0) |
| `atrA`, `atrB` | numero | ATR(14) in pip |
| `sigmaX`, `ewmaVolX` | numero | deviazione standard del livello del cross sulla finestra; vol EWMA dei rendimenti del cross |
| `sigmaForecast`, `sigmaAverage30d` | numero | vol prevista 1-4 h e media 30 g (null finché il livello 8.5 non è attivo) |
| `costPips`, `breakEvenWinRate` | numero | costo stimato in pip-equivalenti di A; win rate di pareggio |
| `spreadA`, `spreadB`, `markupA`, `markupB` | numero | spread correnti in pip; markup dell'API in pip |
| `hourSin`, `hourCos`, `dow` | numero | ora sul cerchio; giorno della settimana (0 = domenica) |
| `minutesToNextHigh`, `minutesSinceLastHigh`, `surpriseLast` | numero/null | calendario per le valute del basket |
| `netSentDiff_1h/4h/24h`, `hawkishDiff`, `riskOff`, `newsCount` | numero | sentiment (valuta lunga − valuta corta del cross) |
| `regimeTrend` | numero | forza di trend (ADX-like) del cross |
| `lastNOutcomes` | numero | media degli ultimi esiti (null finché non c'è storia); dalla 5.1 gli esiti vengono dal ledger corretto, riletto dopo la verifica del realizzato all'avvio |
| `p_ML`, `mlActive` | numero, bool | probabilità del meta-modello e se è gate o ombra. Dalla 5.1 un basket aperto ripreso dopo un riavvio porta nelle sue righe la `p_ML` del suo ingresso (prima era vuota) |
| `equity`, `openBaskets` | numero | equity e basket aperti al momento |
| `priceA`, `priceB`, `pipsOpen`, `pnlOpenUsd`, `barsHeld` | numero | stato della posizione (se aperta) |
| `unitsA`, `unitsB`, `notionalUsd`, `lossAtStopUsd`, `effectiveLeverage`, `marginUsd` | numero | sizing (solo su `Enter`); `marginUsd` = margine previsto delle due gambe (5.0) |
| `sizing_bound` | testo | quale vincolo ha deciso la size (5.0): `risk`, `margin`, `leverage`, `units` |
| `reasonCodes` | array | codici: `no_signal`, `rho_low`, `rho_short_low`, `half_life`, `blackout_before`, `blackout_after`, `weekend`, `just_opened`, `session`, `max_baskets`, `same_cross`, `ml_gate`, `cost_gate`, `sizing`, `kill_switch`, `equity_stop`, `daily_loss`, `entries_blocked`, `data_quality`, `warmup`, `not_bar_close`, `enter`, `add`, `hold`, `tp_pips`, `tp_z`, `stop_z`, `stop_max_loss`, `spread_anomaly`, `time_stop`, `rho_break`; dalla 5.0 `margin` (nessun margine per un nuovo basket), `margin_guard` (equity / margine usato sotto la soglia), `min_exposure` (la size a margine non raggiunge l'esposizione minima) |
| `motivazione` | testo | la frase, in italiano, con i numeri |
### Correzioni (`evento = correzione`)
Una correzione è sempre una riga nuova: `baskets.csv` e le righe già scritte non cambiano mai. Oltre alle correzioni libere (motivazione del reset, equity stop; fino alla 5.0 anche il cambio di preset a caldo, che dalla 5.1 non esiste più: un cambio di strategia è una riga `configurazione`), dalla 5.1 esistono tre `tipo`:
| `tipo` | Campi | Significato |
|---|---|---|
| `pnl_realizzato` | `riga` (chiave della riga di `baskets.csv`: `basket_id` + `|` + `closed_utc` nel formato `O`, così si distinguono anche le gambe singole con `basket_id` vuoto), `basket`, `exit_reason`, `pnl_net_registrato`, `pnl_gross_corretto`, `pnl_net_corretto`, `label_corretta`, `verificata`, `position_ids`, `fonte` | il realizzato vero di una riga, dallo storico eToro (`netProfit − fees` delle sue posizioni). Con `verificata = false` (posizioni non ritrovate) i tre campi corretti sono `null`: la riga non ha etichetta, non addestra niente ed è esclusa dai riepiloghi. La scrive la verifica del realizzato all'avvio (`verifica_realizzato`), idempotente: una riga verificata non viene più controllata |
| `feature_inaffidabile` | `feature` (`lastNOutcomes`), `indice` (26), `fino_a` | la feature è inaffidabile in ogni riga di valutazione scritta prima di `fino_a`: era calcolata sulle etichette sbagliate. Nel dataset vale il suo valore neutro 0,5; mai ricostruita a posteriori. Vale la riga con il `fino_a` più recente: una seconda riga arriva quando un avvio sull'altro conto corregge righe della 4.0-5.0 dopo il ritiro dei modelli (le sessioni intermedie avevano calcolato la feature anche con quelle etichette) |
| `pnl_note_proceeds` | `da`, `a` | nelle righe scritte in quell'intervallo i campi `pnl` delle note (`leg_risk_unwind`, `orfana_chiusa`, `kill_switch_concluso`) e i testi «netto … USD» sono i `proceeds` della chiusura, non il P&L. Nessun codice li legge |
**La verifica all'avvio** (`RealizedBackfill`) lavora sul conto in uso: controlla solo le righe di quel conto (le modalità della 4.0 `DemoApprove`/`DemoAuto` contano come Demo, `LiveApprove`/`LiveAuto` come Live; le righe `Paper` mai) chiuse dopo l'ultima nota `verifica_realizzato` **dello stesso conto** (dalla 5.1 la nota porta `mode`; una nota senza `mode`, scritta dalla prima 5.1, non conta: la verifica si ripete una volta, senza effetti), più le righe ancora non verificabili e quelle scritte con la stima. Le posizioni di una riga vengono dal marcatore `posizioni:` della motivazione, da `orders.jsonl` (le aggiunte richiuse escluse), dai prezzi d'esecuzione delle note `ingresso` della 4.0.x o, per una gamba singola, dalla sua nota (`leg_risk_unwind`, `orfana_chiusa`): le note si abbinano alle righe tutte insieme, solo con lo stesso `basket_id` (vuoto con vuoto), lo stesso motivo d'uscita e strumento, entro 120 s, una nota per riga e in ordine di tempo; un abbinamento ambiguo lascia la riga non verificabile invece di indovinare.
**Lettore corretto** (`Ledger.ReadBasketsCorrected`): legge `baskets.csv` e applica a ogni riga la correzione `pnl_realizzato` più recente della sua chiave, cercandola in tutti i `decisions*.jsonl` (mesi ruotati compresi); marca non verificata (`Unverified`, niente etichetta) una riga con correzione non verificata, con P&L sconosciuto o scritta come stima dopo il timeout (`P&L: stima` nella motivazione). Lo usano il dataset di addestramento, il seme di `lastNOutcomes`, il riepilogo giornaliero e `/storico` di Telegram, la scheda Storico. Il file non viene mai toccato.
**Cosa non si può correggere**: i messaggi Telegram e le righe di log già emessi dalla 4.0.0 alla 5.0.0 mostravano i proceeds come «netto» e «P&L oggi»; restano come sono.
## `data/ledger/baskets.csv`
Una riga per basket chiuso (e per gamba singola). `label = 1` se `pnl_net_usd > 0`, altrimenti 0: è l'etichetta dei livelli 1-3; vuota quando il P&L è sconosciuto.
```
basket_id;run_id;basket;mode;preset;opened_utc;closed_utc;buy_cross;entry_z;exit_z;pnl_gross_usd;pnl_net_usd;pips_gross;cost_pips;cost_usd;slippage_pips;adds;bars_held;exit_reason;equity_at_entry;p_ml_at_entry;label;durata_min;motivazione
```
**Da dove viene il P&L (dalla 5.1).** eToro non dice il realizzato nella risposta di chiusura. La riga non viene scritta alla chiusura: resta nella coda di regolamento (`pendingSettlements` dello stato) con la **stima** dai prezzi di chiusura e viene scritta quando lo storico eToro mostra tutte le sue posizioni, con `pnl_net_usd = Σ (netProfit − fees)` e `pnl_gross_usd = Σ netProfit`; la motivazione finisce con `| P&L: storico eToro (netProfit − fees)`. Se dopo 30 minuti lo storico non le mostra ancora, la riga viene scritta con la stima e la motivazione finisce con `| P&L: stima dai prezzi di chiusura…`: non addestra niente e la verifica all'avvio la ricontrolla finché lo storico non la conferma. In un simulatore (backtest) il numero è quello finale del simulatore (`| P&L: simulatore`). La motivazione porta anche `posizioni: <id> <id> …`, le posizioni eToro della riga. **Fino alla 5.0.0** `pnl_net_usd` era la somma dei `proceeds` delle chiusure (margine restituito + profitto) meno l'overnight maturato, e `label` quasi sempre 1: quelle righe si leggono solo con il lettore corretto.
**Una posizione, una riga (dalla 5.1).** Una posizione eToro finisce in `baskets.csv` una volta sola: il motore ricorda le posizioni già scritte (il marcatore `posizioni:` delle righe del suo conto) e quelle in coda di regolamento, e nessun percorso (uscita del basket, chiusura dei residui, riconciliazione, orfana richiusa da un elenco vecchio) le registra di nuovo. Le gambe di un basket rimaste nel residuo di un kill-switch diventano, quando sono tutte chiuse, **una** riga del basket con `exit_reason = kill_switch` e titolo «Basket chiuso: …». Prima una chiusura vista da due percorsi poteva comparire due volte e raddoppiare il P&L dei riepiloghi.
**Preset (dalla 5.1)**: la colonna `preset` è il preset con cui il basket è **entrato** (salvato nel basket e nell'ingresso in sospeso), anche nelle righe `closed_by_broker`; le righe di una gamba singola di un'aggiunta o di un ingresso richiusi portano il preset del loro basket o del loro tentativo. Fino alla prima 5.1 era il preset in vigore alla chiusura.
`pips_gross` è la somma dei pip delle due gambe ai prezzi di esecuzione (la colonna "Pips" della UI), `cost_pips` il costo stimato all'ingresso, `slippage_pips` la differenza fra quotazione vista e prezzo eseguito sommata sulle gambe, `exit_reason` uno dei codici sopra più `manual`, `closed_by_broker`, `leg_closed_by_broker`, `end_of_data`, e dalla 5.0 `leg_risk_unwind` (gamba A eseguita in ritardo e richiusa, o B non coperta dal margine; dalla 5.1 anche la gamba A di un'aggiunta richiusa, con il `basket_id` del basket), `margin_guard` (chiuso dalla guardia del margine), `orphan_closed` (gamba orfana del bot adottata e chiusa alla riconciliazione), `bonifica_orfana` (chiusa dalla bonifica con conferma), `kill_switch`/`equity_stop` anche per le gambe singole (e, dalla 5.1, per i basket rimasti nel residuo di un kill-switch; le chiusure fatte da `run.closeOnShutdown` all'arresto usano anch'esse `kill_switch`). Le righe di una gamba singola hanno `entry_z`, `exit_z`, `pips_gross` e `cost_*` vuoti e `buy_cross` = verso della gamba. `p_ml_at_entry`: dalla 5.1 anche un basket aperto ripreso dopo un riavvio porta la `p_ML` del suo ingresso (prima era vuota).
## `data/ledger/orders.jsonl` (dalla 5.0)
Una riga per **ogni ordine inviato** e per **ogni cambio del suo stato** (append-only): la prima riga di un `client_ref` dice cosa è stato chiesto, l'ultima come è finita. Scritta dal registro degli ordini (`OrderTracker`) attraverso il ledger.
| Campo | Significato |
|---|---|
| `ts`, `run_id`, `mode` | come in `decisions.jsonl` |
| `basket`, `basket_id` | slot (`EURUSD/USDCHF`) e istanza (`B2026…-EURUSDUSDCHF`) |
| `strumento`, `instrument_id`, `verso` | la gamba; `verso` = `long`/`short` dell'ordine (per una chiusura è il verso opposto alla posizione) |
| `leg` | `A`, `B`, `Add`, `Close`, `Unwind` |
| `unita_richieste`, `unita_eseguite` | differiscono quando il server riduce l'ordine (osservato il 2026-09-16) |
| `prezzo_richiesto`, `prezzo_eseguito`, `slippage_pip` | quotazione vista all'invio, prezzo del server, differenza in pip con il segno del costo |
| `stato`, `stato_id` | l'ultima parola del server (`Submitted`, `Received`, `Placed`, `Filled`, `Rejected`, …, `Unknown` quando non ha risposto), con l'id numerico di eToro |
| `esito` | `Pending`, `Filled`, `Rejected`, `Cancelled` |
| `order_id`, `position_id`, `client_ref` | le tre chiavi; dalla 5.1 anche le righe di chiusura (`Close`, `Unwind`) portano il `position_id` della posizione chiusa, la chiave dello storico eToro |
| `fee` | commissioni riportate dal server all'esecuzione |
| `evento` | `inviato`, `stato`, `risolto` |
| `motivazione` | la motivazione della decisione o l'errore del server |
## `data/state/pending_orders.json` (dalla 5.0)
Il registro degli ordini: `savedUtc` e l'array `orders` con gli stessi campi di `orders.jsonl` più `checks`, `lastCheckUtc`, `source` (`venue`, `lookup`, `lookup-v1`, `positions`). Contiene tutti gli ordini senza esito e quelli risolti nelle ultime 48 ore (servono a riconoscere una posizione come propria). Scritto **prima** di ogni chiamata HTTP e a ogni cambio di stato, con `.tmp` + `File.Move`. Un file illeggibile viene messo da parte come `pending_orders.json.illeggibile-<data>`. **Un file solo per i due conti** (dalla 5.1): ogni ordine porta il suo `mode` e un motore vede, risolve, fa fallire e pota solo gli ordini del suo conto (quelli senza `mode`, più vecchi, appartengono a chi apre il registro); all'avvio il log dice quanti ordini senza esito ha l'altro conto. Il file `pending_orders_paper.json` della 5.0 non viene più letto.
## `data/state/baskets_state.demo.json` e `baskets_state.live.json` (stato del motore, uno per conto dalla 5.1)
Lo stato che il motore riprende all'avvio, **uno per conto** (D-53): il motore del conto demo legge e scrive solo `baskets_state.demo.json`, quello del conto reale solo `baskets_state.live.json`. Scritto in modo atomico (nome temporaneo unico + rinomina) dopo ogni cambiamento che conta; non si scrive finché lo stato non è stato letto, così un avvio fallito presto non sovrascrive niente.
Il file unico `baskets_state.json` della 5.0 e della prima 5.1 viene spostato **una volta sola**, dal primo motore che prende il lock della cartella, al conto a cui appartiene: per un file della prima 5.1 (ha `pendingSettlements`) il conto scritto nel suo `mode`; per un file della 5.0 o della 4.0, dove `mode` era la modalità e non il conto, il conto su cui operava la configurazione della 5.0, registrato dall'importazione in `import-5.1.json` (`legacyState`: `mode` = la modalità che quel file nomina, `account` = `demo`, `live` o vuoto per Paper) — un `Live` accanto a `etoro.environment` demo è il conto demo, un `Demo` accanto a `real` il reale. Senza registrazione lo prende solo il motore della modalità che il file nomina; un file di Paper, o di una modalità diversa da quella registrata, non viene mai letto (seconda revisione). Il `mode` del file spostato diventa quello del conto; un file che nomina nessun `mode` va al motore che lo trova. Se il conto ha già il suo file vince il più recente (`savedUtc`) e l'altro resta accanto. L'originale resta come `baskets_state.json.migrato`: niente viene cancellato. File messi da parte dal motore: `.precedente` (sostituito da uno più recente nella migrazione), `.altro-conto` (un file del conto demo copiato a mano nel nome del reale, o viceversa: mai usato), `.illeggibile` (JSON rotto: il motore riparte dalla riconciliazione); se il nome è già preso si aggiunge l'ora.
Campi:
| Campo | Significato |
|---|---|
| `savedUtc`, `runId`, `mode` | quando, da quale run e per quale conto |
| `peakNetEquity`, `cumulativeCashFlow` | picco dell'equity al netto dei movimenti di cassa e cassa cumulata (5.0); `peakEquity` resta per compatibilità e vale `peakNetEquity + cumulativeCashFlow` |
| `lastBalance`, `lastBalanceUtc` | l'ultimo saldo letto, per riconoscere un deposito o un prelievo avvenuto a bot spento |
| `lastPositionIds`, `vanishedUnsettled`, `vanishedSinceUtc` | dalla 5.1: le posizioni che l'ultima riconciliazione ha visto e quelle sparite senza ancora un verdetto sul saldo. All'avvio il saldo si giudica solo quando lo storico eToro mostra ognuna di quelle chiuse da allora |
| `sessionDate`, `dayStartEquity` | il giorno UTC e l'equity **netta** alla prima lettura del conto del giorno: la base della perdita giornaliera |
| `dailyLossDay` | dalla 5.1 (D-52): il giorno UTC (`yyyy-MM-dd`) in cui la perdita giornaliera è scattata, vuoto se non è scattata; un riavvio nello stesso giorno tiene il blocco, il giorno dopo lo ignora |
| `pendingSettlements` | dalla 5.1, **al posto di `todayRealized`** (5.0, la somma dei proceeds: non viene più né scritto né letto; «P&L oggi» si ricalcola dallo storico eToro). La coda delle chiusure che aspettano lo storico, un elemento per chiusura: `key` (la chiave della riga), `rowCsv` (la riga di `baskets.csv` come verrà scritta, con la stima nei campi P&L), `ids` (le posizioni eToro), `estimate` (null se sconosciuta), `closedUtc`, `learn` (se il regolamento istruisce i modelli: solo i basket, mai le stime), `volContext` (il terzile di volatilità alla chiusura, per il bandit), `title` e `detail` (il messaggio). Un riavvio non perde niente: la coda riparte dallo stato, e le righe già scritte in `baskets.csv` vengono scartate. Con lo stato per conto le chiusure in attesa di un conto aspettano che quel conto torni a girare |
| `pausedByOperator`, `entriesBlockedUntilUtc` | dalla 5.1: la pausa dell'operatore (`/pausa`) e il riscaldamento in corso sopravvivono a un riavvio |
| `killSwitched`, `equityStopped`, `haltReason`, `haltResidue` | i blocchi e il residuo del kill-switch (le posizioni del bot rimaste sul conto: `positionId`, `symbol`, `isBuy`, `units`, `openedUtc`, `origin`, `basket`, `reason`) |
| `baskets` | un elemento per basket aperto: `name`, `basketId`, `buyCross`, `openedUtc`, `entryZ`, `lastAddZ`, `adds`, `barsHeld`, `entryCostPips`, `tpPips`, `maxLossUsd`, `zStop` e `maxAdds` (dalla 5.1: quelli con cui è entrato), `preset` (dalla 5.1: il preset d'ingresso), `equityAtEntry`, `accruedFeesUsd`, `entryMotivazione`, le gambe `a` e `b` |
| `pendingEntries` | un elemento per basket in `PendingA`/`PendingB`: `name`, `state`, `basketId` e il piano `pending` con unità, TP, perdita massima, `zStop`, `maxAdds` e `preset` (5.1), costo e equity all'ingresso, motivazione, ora della decisione, riferimenti cliente, quotazioni viste e la gamba A eseguita |
## `data/state/heartbeat.json` e `data/state/instance.lock` (dalla 5.0)
`heartbeat.json`: `{utc, run_id, mode, openBaskets, pendingBaskets, pid, note}` scritto ogni `recovery.heartbeatSeconds` (30), all'avvio (`note = avvio`) e all'arresto (`arresto`), con `.tmp` + `File.Move`. Il tempo trascorso dall'ultimo `utc` è l'inattività che fa scattare il recupero; `/api/health` lo giudica vecchio oltre 3 × l'intervallo + 15 s. Il file è uno solo per i due conti: l'inattività di un conto rimasto fermo mentre il bot girava sull'altro si misura dal `savedUtc` del suo file di stato. `instance.lock`: `{pid, runId, sinceUtc, machine}`, tenuto aperto in esclusiva dal motore per tutta la sessione; non va cancellato a mano.
## `reports/recupero_<run_id>.csv` (dalla 5.0)
Una riga per posizione trovata dal recupero: `posizione;basket;decisione;motivo;z;rho;barsHeld;pnl;motivazione`, con `decisione` ∈ {`chiudi`, `tieni`, `rapporto`} e `motivo` = codice di uscita del decisore (`stop_z`, `stop_max_loss`, `time_stop`, `rho_break`, `spread_anomaly`…), `entro le soglie`, `orfana_bot`, `esterna`.
## `reports/bonifica_YYYYMMDD.csv` (dalla 5.0)
Una riga per orfana chiusa dalla bonifica: `ts;position_id;strumento;verso;unita;aperta_utc;pnl_realizzato;basket;motivazione`.
## `results/trials.csv`
Una riga per configurazione provata nel backtest; N del Sharpe deflazionato = numero di righe.
```
trial_id;preset;signalMode;exitMode;averaging;lot_multiplier;z_in;z_out;z_stop;TP;W;rho_min;cost_multiple;basket_stop;n_baskets;win_rate;pnl_net;sharpe;maxdd;break_even_cost;avg_cost_pips;p1_pnl;p5_pnl;psr;dsr;motivazione
```
`break_even_cost` = media per basket di (pip eseguiti + costo stimato), cioè i pip "mid-to-mid" catturati: il costo di giro che azzera il risultato. `p1_pnl`, `p5_pnl` = percentili 1 % e 5 % del P&L per basket (la coda che il win rate nasconde).
## `reports/falsificazione.csv`
```
test;variante;n_baskets;win_rate;pnl_net;sharpe;maxdd;p1_pnl;p5_pnl;break_even_cost;avg_cost_pips;psr;dsr;motivazione
```
## `knowledge/calibration.csv`
Win rate e P&L netto medio per bucket: `dimensione;bucket;n;win_rate;pnl_medio;pnl_totale;motivazione`, con nove dimensioni: `abs_z` (soglie 1,5 / 2 / 2,5 / 3), `rho_W` (−0,9 / −0,8 / −0,7 / −0,6 / 0), `ora_utc`, `giorno`, `minuti_evento` (60 / 180 / 720), `sentiment_4h` (±0,05 / ±0,2), `preset` (il preset d'ingresso, dalla 5.1), `basket`, `verso`. Solo i basket con il P&L dello storico eToro (lettore corretto); la colonna `motivazione` dice «campione piccolo» sotto 20 basket.
## `data/models/` (apprendimento, dalla 5.1 un solo scrittore: chi tiene `instance.lock`)
| File | Contenuto |
|---|---|
| `logreg_current.json`, `mlp_current.json`, `bandit.json` | stato corrente dei modelli (ripreso all'avvio); `mlp_current.json` esiste solo con `learning.enabled` e `learning.challenger` accesi |
| `logreg_vN.json`, `mlp_vN.json` | versioni dei cicli con `trained_on_until`, `trained_at`, righe, hash del dataset, `trigger` (`settimanale`, `manuale`, `offline`) e nomi delle feature |
| `last_cycle.json` | dalla 5.1: la valutazione completa dell'ultimo ciclo (AUC con intervallo, Brier, log-loss, calibrazione, P&L di tutti e filtrati, Sharpe, DSR, attivazione con la motivazione; logistica e challenger) e il riepilogo del dataset |
| `learning_state.json` | schema 2 (dalla 5.1; legge anche quello della 5.0): `schema`, `active`, `champion`, `version`, `lastCycleUtc`, `lastReport`, `labelsFixedUtc` (quando i modelli addestrati sui proceeds sono stati ritirati: il ritiro avviene una volta sola), `labelledRows` (i basket del dataset, cioè etichettati e con le feature d'ingresso, ricontati dal ledger all'avvio dopo la verifica del realizzato e a ogni ciclo), `recentPAt` = `entry`, `recent` (ultime 200 coppie `{p, label}` con la p **all'ingresso**), `aucHistory` (`{utc, auc100}`, al più 300 punti), `entries` (per `basket_id` dei basket aperti: `f` = le 28 feature, `p` = la p all'ingresso, `utc`, e dalla revisione della 5.1 `z`, `c`, `b` = valori standardizzati, contributi e intercetta del modello che ha dato quella p, così la pagina la spiega anche dopo un riavvio), `lastProposal` (ultima proposta del bandit: `utc`, `context`, `preset`, `explored`, `means`, `text`) |
| `ritirati/<utc>-etichette-proceeds/` | i modelli addestrati sulle etichette dei proceeds della 4.0.0-5.0.0, messi da parte una volta sola (tutto o niente) |
## `knowledge/preregistrazione.csv`
Una riga per forward test: `data;config_hash;modalita;durata_minima;n_minimo_basket;sharpe_atteso;win_rate_atteso;dd_stop;stop_basket_consecutivi;esito;motivazione`.
## `knowledge/proposals.csv`
`data;origine;parametro;valore_attuale;valore_proposto;evidenza;stato;motivazione` — le proposte del ciclo settimanale; `stato` ∈ {proposta, in forward, accettata, respinta}. Nessuna proposta cambia i parametri live da sola.
## `knowledge/models_registry.csv`, `knowledge/forward_registry.csv`
`versione;data;tipo;n_train;auc_wf;brier;logloss;stato;motivazione` (stato ∈ shadow, challenger, champion, ritirato, rifatta — la logistica riaddestrata da sola sulle etichette corrette dopo che un avvio sull'altro conto ha corretto righe della 4.0-5.0) e `data;config_hash;modalita;basket;pnl_net;sharpe;dd;stato;motivazione`.
+185
View File
@@ -0,0 +1,185 @@
# Apprendimento: livelli 0-3
Aggiornato: 2026-10-01 (5.1: pagina Apprendimento, ciclo in background con un solo scrittore, correzioni della revisione; ADR-0006 per lo stato in ombra, ADR-0014 per il ciclo). Tutto è costruito da zero nel Core (`src/Encelado.Core/Baskets/Learning/`), senza pacchetti: regressione logistica online, un MLP a 16 unità ReLU con Adam, un bandit di Thompson, due previsori di volatilità. Il codice del motore che li usa a runtime è `src/Encelado.Engine/Baskets/LearningState.cs` (stato e file), `LearningCycle.cs` (il ciclo), `LearningDataset.cs` (il dataset dal ledger), `LearningDiskReader.cs` (la pagina a motore fermo) e `BasketEngine.Learning.cs` (pubblicazione e comando); lo stesso ciclo gira offline con `backtest learn`.
**Regola che governa tutto**: nessun livello cambia un parametro live da solo. Il meta-modello può soltanto *rifiutare* un ingresso quando è attivo **e** l'operatore ha acceso `learning.enabled`; il bandit *propone* un preset e **non lo applica** (dalla 5.0; fino alla 4.0.0 lo applicava in Paper e Demo); tutto il resto finisce in `knowledge/proposals.csv` e passa dal forward test pre-registrato.
## Stato dalla 5.0 (ADR-0006): quasi tutto in ombra
`strategy.json` → `learning` è `{enabled: false, weeklyCycle: false, challenger: false}` di fabbrica. Con `enabled = false`:
| Componente | Runtime |
|---|---|
| Ledger, `orders.jsonl`, `baskets.csv` | scritti sempre: sono il dato |
| Livello 0 (calibrazione) | generato dal ciclo, quindi fermo finché il ciclo non gira («Esegui ciclo» nella pagina Apprendimento, o `backtest learn`) |
| Previsione di volatilità | attiva, deterministica, usata da `z_in` effettivo |
| Logistica (livello 1) | **in ombra**: `p_ML` a ogni chiusura di barra nel ledger, apprendimento a ogni chiusura di basket confermata dallo storico eToro; mai un cancello (`mlActive = false`) |
| MLP challenger (livello 2) | non addestrato né aggiornato (serve `enabled` **e** `challenger`) |
| Bandit (livello 3) | riceve i premi e **propone** nel log e nella pagina; non applica |
| Ciclo settimanale | non gira nel bot; «Esegui ciclo» o `backtest learn` |
**Criterio di riattivazione** (`learning.enabled = true`, scritto dall'operatore, mai dal bot): almeno **300 basket chiusi in Demo** *e* **P&L netto forward ≥ 0** sulla metrica pre-registrata in `knowledge/preregistrazione.csv` (il risultato del forward test va in `knowledge/forward_registry.csv`, che la pagina legge). Prima di allora qualunque «adattamento automatico» è rumore: il meta-modello può solo ridurre le perdite di una strategia che il backtest dice non reggere i costi, e a poche entrate al giorno i 300 basket sono mesi. Motivazione completa in `docs/adr/ADR-0006-apprendimento-in-ombra.md`.
Il cancello `ml_gate` filtra un ingresso solo se `learning.enabled` è acceso, l'attivazione dell'ultimo ciclo è superata e la `p_ML` esiste (`MlGate.IsActive`): dalla 5.1 vale anche nella seconda valutazione, quella che il motore rifà dopo aver riletto il conto prima di inviare l'ordine (nella 5.0 lì mancava il controllo di `enabled`).
## Il dataset
Una riga per basket **chiuso con il P&L stabilito dallo storico eToro** (`netProfit − fees`, lettore corretto di `baskets.csv`: le stime e le righe non verificabili non hanno etichetta; le gambe singole non sono basket): le 28 feature scritte nel ledger nel momento della decisione (`decisions.jsonl`, evento `ingresso`), unite per `basket_id` all'esito (`label` = 1 se il P&L netto è positivo). Le feature non vengono mai ricostruite a posteriori: il dataset è il ledger (`LearningDataset.Build`).
Dalla 5.1 una nota `ingresso` **senza feature** (un ingresso completato dopo una gamba in attesa, scritto dalla 5.0 come nota) **non è una riga di addestramento**: prima diventava un vettore di valori di default, cioè inventato. La pagina le conta (`entryRowsWithoutFeatures`). Le note `ingresso` della 5.1 portano il vettore della decisione che ha aperto il basket (array `features`) e la sua `p_ML`, quindi restano utilizzabili.
`lastNOutcomes` delle righe scritte prima della marca `feature_inaffidabile` (le etichette della 4.0-5.0 erano i proceeds della chiusura) vale 0,5, il valore neutro. La marca si scrive al primo avvio che trova righe della 4.0-5.0 corrette, e di nuovo, con un `fino_a` più recente, quando un avvio sull'altro conto ne corregge altre dopo il ritiro (le righe di quel conto si verificano solo quando gira; nel frattempo `lastNOutcomes` era calcolata anche con quelle etichette): quell'avvio rifà anche la sola logistica sulle etichette corrette (`LearningState.ReplayLogistic`, riga `rifatta` in `models_registry.csv`), lasciando bandit, sfidante e ritiro come sono; dopo la verifica del realizzato all'avvio il motore rilegge dal ledger corretto gli esiti su cui calcola `lastNOutcomes` (e il conteggio dei basket etichettati) **anche se il ritiro dei modelli fallisce** (`LearningState.Reseed`), così le righe di valutazione scritte da quel momento portano un valore giusto.
**Il ritiro dei modelli** addestrati sui proceeds (ADR-0011) è tutto o niente: prima si leggono il dataset e gli esiti e si spostano i file in `data/models/ritirati/<utc>-etichette-proceeds/`; un errore lì lascia i modelli come sono, in memoria e su disco, e il ritiro si ritenta al prossimo avvio. Solo dopo vengono sostituiti i modelli (logistica riaddestrata sulle etichette corrette, bandit dal prior) e salvato `labelsFixedUtc`: il ritiro non si ripete mai sopra le ricompense imparate dopo, anche se la riga di `models_registry.csv` non si è potuta scrivere (resta un avviso nel log).
**Basket etichettati**: in ogni posto (tick, pagina, `learning_state.json`) sono quelli del dataset, cioè etichettati **e** con le feature d'ingresso; si ricontano dal ledger all'avvio dopo la verifica del realizzato e a ogni ciclo, e crescono di uno a ogni chiusura il cui ingresso il motore ricordava.
Il vettore, nell'ordine di `LearningFeatures.Names` (le etichette italiane sono in `LearningFeatures.Labels` e la pagina le mostra):
| # | Feature | Etichetta | Origine |
|---|---|---|---|
| 0 | `z` | z-score del cross | valutazione |
| 1 | `abs_z` | \|z\| | valutazione |
| 2 | `rho_W` | correlazione ρ sulla finestra | valutazione (finestra W) |
| 3 | `rho_20` | correlazione ρ su 20 barre | valutazione |
| 4 | `halfLife` | emivita (barre) | OLS sul cross (96 se ignota) |
| 5-6 | `atrA`, `atrB` | ATR gamba A / B (pip) | barre delle gambe |
| 7 | `sigmaX` | deviazione standard del cross | valutazione |
| 8 | `ewmaVolX` | volatilità EWMA del cross | valutazione |
| 9 | `regimeTrend` | forza del trend (tipo ADX) | cross sintetico (20 se ignota) |
| 10 | `costPips` | costo stimato (pip) | cost gate |
| 11-12 | `spreadA`, `spreadB` | spread gamba A / B (pip) | quotazioni |
| 13-14 | `hourSin`, `hourCos` | ora del giorno (seno / coseno) | orologio UTC |
| 15 | `dow` | giorno della settimana | orologio UTC |
| 16 | `minutesToNextHigh` | minuti al prossimo evento ad alto impatto | calendario (troncati a 1440) |
| 17 | `minutesSinceLastHigh` | minuti dall'ultimo evento ad alto impatto | calendario (troncati a 1440) |
| 18 | `surpriseLast` | sorpresa dell'ultimo dato | calendario |
| 19-21 | `netSentDiff_1h`, `_4h`, `_24h` | differenza di sentiment 1 h / 4 h / 24 h | notizie (valuta lunga − corta del cross) |
| 22 | `hawkishDiff` | differenza hawkish | notizie |
| 23 | `riskOff` | risk-off | notizie |
| 24 | `newsCount` | notizie nelle ultime 24 h | notizie |
| 25 | `volRatio` | volatilità prevista / media 30 g | previsore di volatilità (1 se ignota) |
| 26 | `lastNOutcomes` | esito medio degli ultimi 10 basket | etichette (0,5 se ignoto o mascherato) |
| 27 | `buy_cross` | acquisto del cross | decisione |
Il test `LeakTests` verifica che nessun nome contenga l'esito e che un'etichetta presa dal futuro non sia apprendibile (AUC ≈ 0,5).
## Livello 0 — Calibrazione
`CalibrationTables.Build` raggruppa i basket del dataset per nove dimensioni — `abs_z` (soglie 1,5 / 2 / 2,5 / 3), `rho_W` (−0,9 / −0,8 / −0,7 / −0,6 / 0), `ora_utc`, `giorno`, `minuti_evento` (60 / 180 / 720), `sentiment_4h` (±0,05 / ±0,2), `preset`, `basket`, `verso` — e scrive conteggio, win rate, P&L medio e totale per bucket in `knowledge/calibration.csv` (colonna `motivazione`: «campione piccolo» sotto 20, «bucket in utile» o «in perdita»). Serve a leggere dove la strategia paga e dove no, e a niente altro: non cambia soglie.
## Livello 1 — Logistica online (il campione)
`OnlineLogistic`: pesi su 28 feature standardizzate con statistiche rolling (`RollingStandardizer`, emivita 200 righe, valori tagliati a ±5), SGD con L2 = 10⁻³ e tasso **lr₀ / (1 + n/1000)** con lr₀ = 0,01. Predice a ogni chiusura di barra a basket piatto (`p_ML`, "in ombra") e impara a ogni chiusura di basket confermata dallo storico. Stato in `data/models/logreg_current.json`; versioni datate `logreg_vN.json` con `trained_on_until`, righe, hash del dataset e origine del ciclo. I pesi agiscono su feature standardizzate: |w| ordina l'importanza e il contributo di una feature alla previsione è `w·z`. La pagina mostra i contributi **del modello che ha dato quella `p_ML`**: il motore li prende insieme alla p a ogni chiusura di barra a basket piatto (una sola lettura sotto il lock dello stato, `LearningState.Score`) e li conserva con l'ingresso, anche in `learning_state.json`, così sopravvivono a un riavvio; la loro somma più l'`intercept` della riga è il logit di `p_ML`. Una p senza una spiegazione conservata (la p all'ingresso di un basket aperto prima della 5.1 quando il modello nel frattempo è cambiato, o la p del campione MLP) è mostrata senza contributi: mai spiegata con un modello che non l'ha data.
**Valutazione walk-forward** (`ModelEvaluator.EvaluateLogistic`): sequenziale, predici-poi-aggiorna, con i primi 30 basket di burn-in esclusi dalle metriche. Metriche: AUC con intervallo bootstrap (1000 ricampionamenti), Brier, log-loss, curva di calibrazione in 10 bin, P&L di tutti i basket contro P&L dei soli basket con p ≥ `mlMinProbability`, Sharpe e DSR del filtrato.
**Attivazione** (§8.3 della specifica), tutte insieme:
1. almeno **300** basket nel dataset;
2. AUC walk-forward ≥ **0,55** con l'intervallo bootstrap che esclude 0,50;
3. P&L filtrato migliore del P&L non filtrato **e** DSR del filtrato ≥ **0,95**.
Quando è attivo (e `learning.enabled` è acceso), un ingresso con p < `mlMinProbability` (0,55) viene rifiutato (`ml_gate` nel ledger). **Disattivazione**: se l'AUC mobile sugli ultimi 100 basket scende sotto **0,52** il modello torna in ombra e lo scrive in `models_registry.csv`.
**AUC mobile (5.1)**: le coppie (p, esito) sono la probabilità data **all'ingresso** di ciascun basket — salvata con le sue feature quando il basket apre — e l'esito alla chiusura. Fino alla 5.0 la p veniva ricalcolata alla chiusura da un modello che nel frattempo aveva già imparato dai basket chiusi durante la vita di quello: un'AUC ottimista, non confrontabile con il walk-forward. Le coppie della 5.0 vengono scartate alla prima lettura. Dopo ogni ciclo le coppie ripartono dalle p all'ingresso del walk-forward (dopo il burn-in), le stesse su cui si calcola l'AUC del ciclo.
## Livello 2 — MLP challenger
`SmallMlp`: 28 → 16 ReLU → 1 sigmoide, inizializzazione Glorot con seme fisso, Adam (β 0,9/0,999), L2 = 10⁻⁴, mini-batch 8-64, tasso 0,003 nell'addestramento del ciclo e 0,001 nell'aggiornamento online. Addestrato dal ciclo **solo con `learning.enabled` e `learning.challenger` accesi** (dalla 5.1: prima veniva addestrato comunque) in **5 fold cronologici con purga ed embargo di 24 ore** attorno al fold di test, **5 semi** mediati, early stopping sull'ultimo 20 % (cronologico) dei dati di addestramento con pazienza 20 epoche; servono almeno 60 basket. Lo standardizzatore viene adattato all'intero insieme di addestramento prima del fit (le statistiche rolling partono da zero e distorcono le prime righe: scoperto e corretto con il test sul cerchio, vedi `ModelTests`). Con il challenger spento il ciclo non lo addestra, il motore non lo aggiorna e `mlp_current.json` viene tolto (le versioni `mlp_vN.json` restano).
Il **gradient check** (`SmallMlp.GradientCheck`, test `TheMlpGradientMatchesTheNumericalOne`) confronta il gradiente analitico di ogni peso vivo del primo strato con la differenza centrale numerica: scarto relativo < 10⁻⁴.
Promozione a campione: solo se batte la logistica di almeno 0,01 di AUC walk-forward **e** supera gli stessi cancelli di attivazione, e comunque solo dopo il forward test. Fino ad allora è registrato come `challenger` in `models_registry.csv`.
## Livello 3 — Bandit sui preset
`ThompsonBandit`: una Beta(α, β) per braccio = preset × terzile di volatilità prevista (3 × 3, prior Beta(1, 1)). Il terzile è quello della σ prevista alla chiusura rispetto alle σ delle chiusure precedenti (contesto «vol media» finché le chiusure sono meno di 9). A ogni chiusura confermata dallo storico il braccio **del preset con cui il basket è entrato** (salvato nel basket e nella sua riga di `baskets.csv`; fino alla prima 5.1 era il preset in vigore alla chiusura) riceve 1 se il basket è positivo; `byPreset` del dataset e la dimensione `preset` della calibrazione leggono la stessa colonna. La proposta è golosa sulla media a posteriori, salvo un **tetto del 10 %** di scelte campionate (esplorative; `ExplorationCap`, test `TheBanditKeepsExplorationUnderTheCap`). Dalla 5.0 la proposta viene scritta nel log e mostrata nella pagina e **non viene applicata** in nessuna modalità (D-30); dalla 5.1 l'ultima proposta (contesto, preset, medie, se esplorativa) viene salvata e sopravvive a un riavvio. La pagina mostra per ogni braccio α, β, vittorie, sconfitte, media e intervallo di credibilità al 95 % (quantili della Beta), e in oro il migliore del suo contesto: la media a posteriori più alta, **solo per un braccio provato almeno una volta** (n > 0). Un bandit nuovo non ha bracci migliori, e nemmeno un contesto i cui bracci provati non fanno meglio del prior; a pari media vince il primo nell'ordine Conservative, Moderate, Aggressive.
## Previsione della volatilità
`VolForecaster`, uno per basket: sui rendimenti logaritmici a 15 minuti del cross sintetico tiene la varianza realizzata di barra (ultime 20 000 barre) e due previsori per le prossime 8 barre (2 ore): **EWMA** (span 100) e **HAR-RV** (OLS della varianza della barra successiva sulle medie a **15 minuti, 4 ore e 24 ore**, cioè 1, 16 e 96 barre; rifittato una volta al giorno dopo 480 barre, su al più 5 760 righe e almeno 200). Ogni previsione viene confrontata con la volatilità realizzata nelle 8 barre successive; con almeno 50 confronti si usa il modello con l'errore quadratico minore (`ActiveModel`). Il rapporto σ prevista / σ media 30 giorni scala la soglia `z_in` (entro `volScaleMin`–`volScaleMax`, 0,8–1,5) ed è la feature `volRatio`.
Dalla 5.1 si mette in coda **al più una previsione per barra**: il motore chiede la previsione anche a ogni lettura delle quotazioni di un basket aperto (ogni pochi secondi) e la 5.0 le accodava tutte, con una coda che cresceva senza limite e confronti fatti su previsioni vecchie di ore. `Stats()` e `Describe()` sono letture pure: non accodano niente e non cambiano il modello in uso.
## Deriva
L'indice di stabilità (PSI) previsto dalla specifica non è collegato a niente: il codice è stato rimosso nella pulizia della 5.0 (era una classe mai chiamata). Quando il meta-modello sarà attivabile, il controllo della deriva va reintrodotto insieme al criterio di ritorno in ombra, non prima.
## Il ciclo
Il ciclo (§8.7) ricostruisce il dataset dal ledger, valuta e riaddestra la logistica (walk-forward) e — se acceso — il challenger (fold purgati), e scrive la base di conoscenza. Dalla 5.1 è una **funzione pura in background** (`LearningCycle.Train`): legge solo il ledger, in condivisione, senza esserne lo scrittore, e restituisce tutto senza toccare niente; il thread di decisione lo **applica** fra due tick in pochi millisecondi (`LearningState.Apply`): sostituisce i modelli, rigioca sui nuovi modelli i basket chiusi mentre il ciclo si addestrava, aumenta la versione, scrive ogni file intero. Il motore intanto continua a lavorare (nella 5.0 l'addestramento girava sul thread di decisione con il lock dell'apprendimento preso: quotazioni e uscite ferme per tutta la durata). Il ciclo si interrompe fra un fold, un seme o un'epoca e l'altro quando il motore si ferma.
Fasi mostrate nella pagina: `dataset`, `logistica`, `mlp`, `scrittura`.
**Quando gira**:
- **settimanale nel bot**: solo con `learning.enabled` e `learning.weeklyCycle` accesi, la domenica dalle 10:00 UTC, quando sono passati almeno sette giorni dal precedente (qualunque sia stato); stesso percorso in background; un ciclo fallito si ritenta non prima di un'ora;
- **«Esegui ciclo»** nella pagina Apprendimento (`POST /api/commands/learn`), in ogni stato:
- motore in esecuzione: il comando va al motore, che avvia il ciclo e risponde subito; l'avanzamento è in `schedule.running` / `runningPhase`;
- motore fermo o in errore: **manutenzione a motore fermo** — il server prende il lock di istanza della cartella dati (un solo scrittore di `data/models` e `knowledge` alla volta), addestra in background e applica; **AVVIA risponde 409** (`code: refused`) finché dura, di solito pochi secondi;
- un ciclo già in corso, un motore che si sta avviando o fermando, o un altro processo che tiene il lock: rifiutato (409, `code: refused`) con il motivo;
- **`backtest learn`** (strumento): prende anch'esso il lock di istanza della cartella dati, o si rifiuta con il nome di chi lo tiene: con il bot acceso si usa «Esegui ciclo».
```powershell
dotnet run --project tools/Encelado.Backtest -- learn --data <cartella data del bot> [--knowledge <cartella>] [--strategy config/strategy.json]
dotnet msbuild build/Release.proj -t:Backtest -p:Dati="%USERPROFILE%\Documents\Encelado\data" -p:Comando=learn
```
`--data` è la cartella che contiene `ledger/` (una copia di `/data/data` del container va benissimo); `--knowledge` è dove scrivere (default: `knowledge` accanto ai dati). Lo strumento stampa quante righe ha il dataset, la versione e lo stato del modello dopo il ciclo e i file che ha scritto (`logreg_current.json`, `logreg_vN.json`, `last_cycle.json`, `learning_state.json`; `calibration.csv`, `insights_AAAASS.md`, `models_registry.csv`, `proposals.csv`).
**Cosa scrive un ciclo**:
1. `data/models/logreg_vN.json` (e `mlp_vN.json` con il challenger) con `trained_on_until`, `trained_at`, righe, hash del dataset, origine e nomi delle feature;
2. `data/models/last_cycle.json`: la valutazione completa del ciclo (AUC con intervallo, Brier, log-loss, calibrazione, P&L di tutti e filtrati, Sharpe, DSR, attivazione e motivazione, per la logistica e il challenger) e il riepilogo del dataset — fino alla 5.0 tutto questo veniva calcolato e buttato via, restava solo una riga di testo;
3. `knowledge/calibration.csv`, `knowledge/insights_AAAASS.md` (con l'anno della **settimana ISO**: nei primi giorni di gennaio la settimana 52 o 53 appartiene all'anno prima, e la 5.0 sbagliava l'anno), righe in `knowledge/models_registry.csv` e `knowledge/proposals.csv` (una riga per proposta, con evidenza e stato `proposta`).
**Le proposte non toccano niente.** Il percorso per cambiare un parametro live è: proposta → `knowledge/preregistrazione.csv` (metrica, soglia, periodo, N minimo, scritti prima) → forward test in Demo → `forward_registry.csv` → decisione umana.
## La pagina Apprendimento (`GET /api/learning`, 5.1)
La pagina raccoglie tutto ciò che il sistema sa dell'apprendimento; la forma esatta dei campi è in `docs/API.md`. Sezioni:
- **stato**: modalità (`ombra-disabilitato`, `ombra`, `attivo`), interruttori, attivazione, versione, basket appresi, soglia `p`, perché è in questo stato, ingressi in attesa di esito;
- **dataset**: righe di `baskets.csv`, basket etichettati, senza riga d'ingresso, con l'ingresso senza feature, gambe singole, righe corrette e non verificate, vinti e persi, P&L netto (totale, medio, mediano, 5° percentile), per modalità, basket, preset e motivo d'uscita, avanzamento verso i 300, **etichette sospette** (win rate ≥ 90 % su 20 basket o più, un basket con P&L oltre il 5 % dell'equity all'ingresso, segno del P&L in contrasto con i pip netti in più di un quinto dei casi chiari: i sintomi dei proceeds della 4.0-5.0);
- **attivazione**: ogni condizione con valore attuale, richiesta ed esito (`null` = non valutabile): righe, AUC, estremo dell'intervallo, P&L filtrato, DSR, chiusi in Demo, P&L forward, interruttore dell'operatore, AUC mobile mentre è attivo;
- **logistica**: iperparametri, tasso attuale, pesi per |w| con media e deviazione standard dello standardizzatore; **challenger** (se c'è);
- **ultimo ciclo**: la valutazione di `last_cycle.json`;
- **AUC mobile**: AUC su 100 e 200, intervallo bootstrap, Brier, log-loss, win rate e p media degli ultimi 100, media degli ultimi 10 esiti, le coppie (p all'ingresso, esito), l'AUC nel tempo, la calibrazione;
- **basket**: per ciascuno `p_ML` con l'ora e il tipo — «ultima barra», «all'ingresso» (basket in posizione o in attesa di una gamba: le feature sono quelle dell'ingresso) o «ricalcolata con il modello di oggi» (motore fermo, basket piatto, e il modello salvato non ridà la p dell'ultima riga del ledger: la p mostrata è quella che il modello salvato dà ai valori di quella riga) —, se il filtro lo scarterebbe, i cinque contributi maggiori (`w·z`) con l'`intercept` del modello che ha dato la p, su richiesta (`?features=all`) il vettore completo, e il previsore di volatilità (modello in uso, σ EWMA / HAR / prevista / media 30 g, scala di `z_in`, errori, previsioni valutate e in coda, ultimo fit, terzile);
- **bandit**: bracci, quota esplorativa, preset in uso (fisso), ultima proposta; **volatilità**: storico delle σ alle chiusure e soglie dei terzili;
- **conoscenza**: calibrazione, ultime proposte (con `basedOnSuspectData` per quelle nate dalle etichette sbagliate) e righe del registro, l'insight più recente (al più 64 KB), i file dei modelli e di `knowledge/`;
- **pianificazione**: ultimo ciclo, prossimo, se gira nel bot, se sta girando (da quando, in che fase), durata, errore e origine dell'ultimo;
- **avvisi**: frasi per l'operatore.
**Da dove vengono i numeri**: a motore acceso il thread di decisione costruisce un rapporto immutabile e lo pubblica (a ogni chiusura di barra e di basket, dopo un ciclo e un comando, all'avvio e una volta al minuto): il web lo legge senza mai toccare lo stato del motore. A motore fermo lo stesso rapporto viene letto dai file in sola lettura (`LearningDiskReader`: nessuna cartella creata, file aperti in condivisione, righe a metà scartate, riletto solo quando i file cambiano). Un file dei modelli che non si riesce a leggere (modificato a mano, schema diverso, permessi) lascia **l'ultima lettura buona** di quella parte — logistica, MLP, bandit, stato, ultimo ciclo — e un avviso lo dice; se una lettura buona di quella parte non c'è mai stata, l'avviso dice che sono mostrati i valori iniziali, anche alle letture successive (una lettura buona di un'altra parte non conta). Un file assente vale i valori iniziali, senza avviso. La base di conoscenza e il dataset aggiornato si leggono sempre dal disco; il dataset si ricalcola quando cambia `baskets.csv`, quando compare un file delle decisioni, **appena il ledger riceve una correzione `pnl_realizzato` o la marca `feature_inaffidabile`** (lette in modo incrementale) e comunque al più ogni ora. La risposta ha un `ETag` (versione della sezione + impronta dei file letti, `strategy.json` compreso: da lì un motore fermo prende interruttori, soglia e basket); la pagina la rilegge quando cambia `versions.learning` nel tick — che avanza anche a ogni salvataggio di un campo della strategia — e riceve 304 se niente è cambiato. Il tick porta i numeri principali (`learning`: modalità, basket etichettati, AUC mobile, proposta del bandit, modello di volatilità, ciclo in corso, avvisi), presi dallo stesso rapporto: i basket etichettati del tick sono quelli del dataset della pagina.
## Correttezza dei file (5.1)
- **Un solo scrittore**: il motore costruisce lo stato dell'apprendimento solo dopo aver preso il lock di istanza e lo salva, sotto il suo lock, prima di rilasciarlo; un motore rifiutato dal lock non scrive niente. La manutenzione a motore fermo e `backtest learn` prendono lo stesso lock.
- **File interi**: ogni file dei modelli e della conoscenza si scrive su un `.tmp` con nome unico e si rinomina (`AtomicFile`); la 5.0 scriveva i modelli direttamente, e un file troncato azzerava tutto alla lettura successiva.
- **Ingressi salvati subito**: le feature e la p di un basket aperto finiscono in `learning_state.json` all'apertura, non alla chiusura successiva.
- **Chiusure del broker**: un basket chiuso dagli stop nativi o a mano (`closed_by_broker`) insegna come gli altri quando lo storico ne conferma il P&L; se resta una stima il suo ingresso viene dimenticato (nella 5.0 restava in memoria per sempre).
- **La p con la sua spiegazione** (revisione): con l'ingresso si salvano anche i valori standardizzati, i contributi e l'intercetta del modello che ha dato la p (`z`, `c`, `b` in `learning_state.json`); un basket aperto ripreso dopo un riavvio torna ad avere la sua p d'ingresso, nella pagina, nel tick e nelle righe nuove del ledger (`p_ML`, `p_ml_at_entry`). Questi dati servono a mostrare e a registrare: la p di un basket aperto non decide niente.
- **Ritiro tutto o niente** e **riletture dal ledger corretto** dopo la verifica del realizzato: vedi «Il dataset».
**Limiti noti** (in `docs/KNOWN_ISSUES.md`): il vettore che il modello vivo valuta alla chiusura di barra ha `costPips` a 0 (il costo dell'ingresso non è ancora calcolato a quel punto), mentre la riga d'ingresso su cui il ciclo addestra ha il costo vero; e un ingresso completato dopo un riavvio a metà (gamba in attesa) non ha il vettore, quindi non diventa una riga di addestramento.
## Cosa è stato escluso, e perché
- **LSTM / Transformer / RL profondo**: con qualche centinaio di basket l'anno per cinque coppie, un modello con migliaia di parametri impara il rumore del campione; la regressione logistica e un MLP minuscolo sono già al limite di ciò che il dataset può sostenere. Il costo (settimane di lavoro e di calcolo) non è giustificato da nessun indizio che un modello più ricco troverebbe struttura dove i test di falsificazione non ne trovano.
- **Feature ricostruite a posteriori**: il ledger scrive ciò che il bot sapeva; ricostruire feature dopo è il modo più facile di introdurre look-ahead.
- **Ottimizzazione automatica dei parametri**: la griglia del backtest serve a *sapere*, non a *scegliere*; ogni prova conta nel DSR.
## File
| File | Contenuto |
|---|---|
| `data/models/logreg_current.json`, `mlp_current.json`, `bandit.json` | stato corrente (ripreso all'avvio) |
| `data/models/logreg_vN.json`, `mlp_vN.json` | versioni dei cicli con `trained_on_until`, `trained_at`, righe, hash del dataset, origine, nomi delle feature |
| `data/models/last_cycle.json` | valutazione dell'ultimo ciclo e riepilogo del dataset (dalla 5.1) |
| `data/models/learning_state.json` | schema 2: attivo/ombra, campione, versione, ultimo ciclo e suo esito, quando i modelli dei proceeds sono stati ritirati, basket etichettati (il conteggio del dataset), ultime 200 coppie (p all'ingresso, esito), AUC mobile nel tempo (300 punti), ingressi in attesa con feature, p e ora e, dalla revisione, valori standardizzati, contributi e intercetta della p (`z`, `c`, `b`), ultima proposta del bandit. Schema completo in `docs/LEDGER_SCHEMA.md` |
| `data/models/ritirati/<utc>-etichette-proceeds/` | i modelli addestrati sulle etichette dei proceeds, messi da parte una volta sola dalla 5.1 (tutto o niente) |
| `knowledge/calibration.csv`, `insights_AAAASS.md`, `models_registry.csv`, `proposals.csv`, `forward_registry.csv`, `preregistrazione.csv` | vedi `docs/LEDGER_SCHEMA.md` |
Test: `tests/Encelado.Tests/LearningTests.cs` (gradient check, apprendimento walk-forward, MLP contro logistica su una regola non lineare, bandit, volatilità, leak, blocchi) e `LearningReportTests.cs` (5.1: letture pure dei modelli, coda della volatilità, cancello, note senza feature, AUC mobile, dataset ed etichette sospette, attivazione, pianificazione, nome degli insight, stato salvato, ciclo in background e applicazione, challenger, lettore del disco, comando «Esegui ciclo» in ogni stato, `/api/learning` con i dati d'esempio e a motore fermo, `ETag` e 304) e `LearningReviewTests.cs` (revisione: contributi che spiegano la p mostrata, anche dopo un riavvio; ritiro tutto o niente; rilettura dal ledger corretto; conteggio dal dataset; ultima lettura buona a motore fermo; bracci mai provati).
+74
View File
@@ -0,0 +1,74 @@
# Piano 5.0 — valutazione, ordine e stima
Scritto: 2026-09-23 (Fase 0 del prompt "Encelado 5.0"). **Stato al 2026-09-23 sera: tutte le fasi 0-9 sono eseguite e committate; resta il rilascio 5.0.0 (decisione dell'utente).** Ogni punto del prompt è valutato come **fattibile**, **da chiarire** (con la domanda in `docs/QUESTIONS.md`) o **da rifiutare** (con il motivo). Le stime sono in sessioni di lavoro; una sessione è mezza giornata con verifica verde e commit.
## 0. Verifica della diagnosi preliminare
Verificata il 2026-09-23 sul codice, sul conto demo via API (sola lettura) e sui file di questa macchina.
| Affermazione del prompt | Esito |
|---|---|
| `EtoroBroker.OpenAsync` legge `orderId` e non lo usa più; il polling passa solo da `orders:lookup?referenceId=` | **Confermato** (`src/Encelado.Etoro/EtoroBroker.cs`, metodo `OpenAsync` e `LookupOrderAsync`). |
| Il lookup per `referenceId` risponde 404 | **Confermato e spiegato**: `GET api/v1/trading/info/demo/orders/381739181` (uno degli ordini del bot) risponde `referenceID: 00000000-0000-0000-0000-000000000000`. Per gli ordini v2 il server **non ha registrato** l'`x-request-id` come riferimento, quindi la ricerca per riferimento non può trovarli. La ricerca per `orderId` funziona (verificata su due ordini, v1 e `orders:lookup?orderId=`). |
| `BasketExecutor.SendAsync` ripete il lookup e dichiara la gamba «non eseguita»; il basket è rifiutato e l'ordine resta sul server | **Confermato** nel codice. Dallo storico del conto demo: **21 posizioni forex del bot** fra il 16/9 19:00 e il 21/9 10:15 UTC (EURUSD 1, USDCAD 1, AUDUSD 4, NZDUSD 3, EURAUD 12), tutte gambe singole, tutte chiuse il **21/9 alle 13:26 UTC** in blocco (chiusura manuale, non del bot: il kill-switch non avrebbe trovato slot da chiudere). P&L netto complessivo di quelle 21 gambe: **+289,05 USD**, per fortuna e non per merito. |
| `ReconcileAsync` segnala le posizioni sconosciute una volta e non le tocca; il contatore conta gli slot | **Confermato**. |
| `KillAsync → CloseAllAsync` chiude solo gli slot con `Position` | **Confermato**. |
| Il ledger 16-22/9 ha 65 `segnale_ingresso` e 65 `rifiuto` | **Non verificabile qui**: su questa macchina `Documenti\Encelado\data\ledger\decisions.jsonl` ha 112 righe del solo 16/9 (mattina e pomeriggio, 110 `skip` e 3 `correzione`). Le sessioni dal 16/9 sera in poi hanno girato altrove (installazione 4.0.0 su un'altra macchina o un altro profilo). Chiesto in D-36. |
| «Depositi» = movimenti di cassa del conto virtuale, non operazioni del bot | **Confermato per esclusione**: nessuna rotta di deposito o trasferimento è chiamata dal codice; le rotte di trasferimento dell'API (`api/v1/money/transfers`) non compaiono nel client. La cifra tonda (+30 000) è coerente con un accredito demo. |
| Margine: un basket Aggressive ha impegnato tutto il margine | **Confermato e precisato**: i primi due ordini eseguiti (16/9 19:00:48 EURUSD short 547 214,68 unità, 62 792 USD di margine; 19:00:58 USDCAD long 464 358,5 unità, 46 436 USD) sommano 109 228 USD di margine = l'intera equity, cioè 1 092 281 USD di nozionale a leva 10. Sono due gambe A di due basket diversi (EURUSD/USDCHF e USDCAD/EURUSD), ciascuna sizata al tetto `maxEffectiveLeverage = 10` sul nozionale del basket. **Fatto nuovo**: dal terzo ordine in poi eToro ha eseguito ogni ordine a **esattamente 2 000 USD di margine** (`requestedAmount 2000`, `frozenAmount 2000`, unità con sei decimali ricalcolate dal server, mentre il bot manda unità a due decimali): il server ha ridotto gli ordini a un importo fisso perché il margine era esaurito. Conseguenze: (1) le unità eseguite possono differire molto da quelle richieste, quindi la riconciliazione per «unità ± 1 %» è solo un indizio, non la chiave: la chiave è l'`orderId`; (2) i limiti di margine di §10 sono indispensabili. |
## 1. Valutazione punto per punto
| § | Contenuto | Valutazione | Note |
|---|---|---|---|
| 1 | Scheda Storico (ordini, posizioni, profitti per periodo, export CSV) | **fattibile** | Modulo puro `Core/Baskets/History` + endpoint web. La vista dipende da §11 (web UI). Fonte del realizzato: `api/v1/trading/info/trade/{demo/}history` (già usato), da riconciliare con `baskets.csv` e `orders.jsonl`. |
| 2 | Navigation rail M3 a sinistra | **fattibile** in web (§11); in WPF sarebbe lavoro perso | Da fare dopo D-28. |
| 3 | Versione fuori dalla dashboard, Informazioni e Diagnostica | **fattibile** | Banale in web; in WPF vale la pena solo se D-28 è «no». |
| 4 | Valuta di visualizzazione | **fattibile** | Tassi dalle quote già in polling: EURUSD (1), USDCHF (6), AUDUSD (7), USDCAD (4), NZDUSD (3) ci sono; **GBP e JPY no**: servono GBPUSD e USDJPY nel polling (2 strumenti in più, stessa richiesta). Conversione solo in presentazione. |
| 5 | OrderTracker, lookup per orderId, stati Pending, orfane, contatori, picco netto dei movimenti di cassa, bonifica | **fattibile, prioritario** | Endpoint verificati (D-26, D-27). Il matching per posizioni usa strumento + verso + finestra temporale; le unità solo come conferma (vedi §0). Movimenti di cassa: il conto demo non compare in `api/v1/balances` (solo i conti reali), quindi si riconoscono dal salto del saldo non spiegato dalle chiusure (`CashFlowDetector`), in Demo e in Live allo stesso modo. |
| 6 | Recupero dopo inattività, heartbeat | **fattibile** | Riusa riconciliazione, riscaldamento e decisore già esistenti. |
| 7 | Telegram | **fattibile** | Solo `HttpClient`; token e chatId da ambiente (D-31). Un solo task di long polling. |
| 8 | Apprendimento: disattivare MLP, bandit, ciclo settimanale; spostarli nello strumento | **fattibile**, decisione D-30 | Il bandit oggi **applica** il preset in Demo (`ObserveOutcome`): va spento comunque, è un cambio di parametro automatico che contraddice la regola «nessun parametro cambiato dal bot». |
| 9 | Kill-switch reale e ripristino guidato | **fattibile, prioritario** | Endpoint di cancellazione esiste: `DELETE api/v2/trading/execution/{demo/}orders/{orderId}` (200 = richiesta accettata, esito da confermare con lookup: 7 o 9 annullato, 6 in corso). |
| 10 | Margine: soglie, buffer, sizing = min(rischio, margine), ordine per \|z\|, margin guard | **fattibile, prioritario** | In Demo `available` viene da `pnl` (`credit + bonusCredit`), in Live idem; `api/v1/balances` aggiunge `totalUsedMargin`/`currentPNL` solo per il reale. |
| 11 | UI web M3 servita dal bot, ritiro di WPF | **da chiarire (D-28)** | Tecnicamente fattibile senza NuGet (`Microsoft.AspNetCore.App` è un framework reference). È la scelta più impattante del prompt: cambia progetti, installer, test. Si fa dopo la conferma. |
| 12 | Engine/Server, Docker, IKeyStore | **da chiarire (D-28, D-29)** | Dipende da §11. Il `Dockerfile` multi-stage e l'`entrypoint` con PUID/PGID sono standard. |
| 13 | Template Unraid | **da chiarire (D-29)** | Serve il registry e l'URL dell'icona. |
| 14 | Documentazione, ADR, skill di progetto | **fattibile** | Le skill in `.claude/skills/` vanno bene; `encelado-diagnose` legge i file nuovi. |
| 15 | Domande | poste in `docs/QUESTIONS.md` (D-26…D-37) | D-26 e D-27 già risposte via API. |
### Punti da rifiutare o ridimensionare (con motivo)
- **§5.2 «polling per orderId e in parallelo per referenceId»**: il riferimento non è registrato dal server per gli ordini v2 (vedi §0). Si interroga **per `orderId`**, e per riferimento solo come ripiego quando la risposta al `POST` è andata persa (timeout di rete) — che è l'unico caso in cui l'`orderId` non c'è. Non «in parallelo»: la quota dei lookup è 60/min condivisa con l'esito delle chiusure, e due lookup ogni 400 ms per gamba la esaurirebbero in un minuto con tre basket.
- **§5.4 «unità ± 1 %» come criterio di adozione**: eToro può ridurre l'ordine (vedi §0), quindi le unità non sono affidabili. Criterio applicato: `orderId`/`positionId` nel registro (certo) → strumento + verso + orario ± 90 s coerenti con un ordine del registro o con una riga `segnale_ingresso`/`rifiuto`/`pending` del ledger (probabile; le unità ± 1 % alzano la confidenza ma non sono richieste). Le posizioni «probabili» sono comunque orfane-bot: sul conto demo non c'è altro che operi sul forex a leva 10 con quegli orari di chiusura di barra.
- **§8 bandit in Demo**: già oggi cambia il preset da solo (`ObserveOutcome` → `SetPreset`). Non è «da tenere in ombra»: è da spegnere del tutto a runtime, perché è un cambio automatico di parametro.
- **§11 test (aa) «UiRenderTests sostituiti»**: i test di rendering WPF restano finché esiste WPF; vengono rimossi con il progetto (Fase 6-7), non prima.
## 2. Ordine di esecuzione e criteri
Invariato rispetto a §16 del prompt, con una precisazione: le Fasi 1-3 non dipendono da nessuna domanda aperta (D-26/27 sono verificate, D-32/34/35 hanno default che sono parametri) e vengono eseguite subito; le Fasi 4-5 nemmeno; le Fasi 6-9 dipendono da D-28/D-29 e aspettano la risposta.
| Fase | Contenuto | Stima | Dipendenze |
|---|---|---|---|
| 0 | questo piano, post-mortem, domande | 0,5 | — |
| 1 | §5: `OrderTracker` + `pending_orders.json` + `orders.jsonl`; lookup per `orderId` con matching sulle posizioni; stati `PendingA/PendingB`; classificazione `basket / orfana-bot / esterna` e chiusura delle orfane; contatori e P&L del conto nello snapshot; picco al netto dei movimenti di cassa; comando `bonifica`; spezzare `BasketEngine.cs` in file parziali (riconciliazione, stato, comandi) | 2 | — |
| 2 | §10: sezione `risk` in `strategy.json`, sizing a margine, ricontrollo di `available` prima di B, ordine per \|z\|, margin guard, `sizing_bound` nel ledger | 1 | Fase 1 |
| 3 | §9: kill-switch con cancellazione, chiusura di basket + orfane, esterne opzionali, verifica di piattezza, `Halted-Residuo`; procedura di ripristino in cinque passi nel motore (la finestra WPF la usa come oggi, la web UI la mostrerà passo per passo) | 1 | Fasi 1-2 |
| 4 | §6: heartbeat, `recovery` in `strategy.json`, procedura di recupero, lock di istanza, rapporto `recupero_<run_id>.csv` | 1 | Fasi 1-3 |
| 5 | §7: `INotifier`, `TelegramNotifier`, stato orario, eventi, riepilogo, comandi | 1 | Fase 4 |
| 6 | §12: `Encelado.Engine`, `Encelado.Server`, Kestrel, SSE, API JSON, `IKeyStore` | 2 | **D-28** |
| 7 | §11 + §1-4 + §8: UI web M3, Storico, valuta, navigazione, Ricerca | 3 | Fase 6 |
| 8 | §12-13: Dockerfile, compose, template Unraid, docs | 1 | Fase 6, **D-29** |
| 9 | §14: documenti, ADR, skill, CHANGELOG, 5.0.0 | 0,5 | tutto |
Totale: circa 13 sessioni. Ogni fase termina con `dotnet build`, `dotnet test`, documenti aggiornati e un commit.
## 3. Decisioni di progetto prese in Fase 0 (vincolanti per le fasi seguenti)
1. **Un ordine non si abbandona mai.** Ogni invio viene registrato in `data/state/pending_orders.json` prima della chiamata HTTP; all'avvio i pendenti si risolvono prima di qualsiasi decisione; una posizione che porta la firma del bot è del bot.
2. **La chiave è l'`orderId`.** Il riferimento cliente resta nell'intestazione (idempotenza) e nel registro, ma non è il mezzo con cui si chiede l'esito.
3. **Nessun esito sintetico.** `OrderOutcome.Status` riporta ciò che il server ha detto; quando non ha detto niente lo stato è `Unknown` e l'ordine resta pendente nel registro.
4. **Le unità eseguite le dice il server.** Il sizing propone, l'esecuzione registra ciò che l'API riporta (`positionExecutions[].openingData.units`), e la gamba B si dimensiona sulle unità **eseguite** di A, non su quelle richieste.
5. **Il margine è un vincolo di primo livello**, non una conseguenza: nessun ordine parte se `available` non copre il margine con il buffer.
6. **Il picco di equity è al netto dei movimenti di cassa**: depositi e prelievi spostano il riferimento, non il drawdown.
7. **Il codice nuovo di logica pura va nel Core** (`OrderTracker`, `PositionClassifier`, `CashFlowDetector`, `History`, sizing a margine) così la migrazione a `Encelado.Engine` della Fase 6 sposta file, non riscrive niente.
@@ -0,0 +1,82 @@
# Post-mortem: ordini dall'esito ignoto e gambe orfane (16-21 settembre 2026)
Scritto: 2026-09-23. Riguarda il forward test in Demo della versione 4.0.0.
## Che cosa è successo
Dal 16 settembre (sera) al 21 settembre il bot ha inviato ordini di apertura della gamba A di vari basket, ha dichiarato ogni gamba «non eseguita» perché non riusciva a leggerne l'esito, ha rifiutato il basket e non ha inviato la gamba B. Gli ordini però erano stati eseguiti dal server: sul conto demo si sono accumulate **posizioni singole senza copertura**, con lo stop nativo ma senza take-profit né stop di basket, che il bot vedeva come «posizioni sconosciute» e non toccava. Nessun basket è mai passato in `Open`; il contatore in dashboard diceva `0/5` mentre il conto aveva fino a venti posizioni aperte.
## Evidenze
Dallo storico del conto demo (`api/v1/trading/info/trade/demo/history`, letto il 2026-09-23):
| Apertura (UTC) | Strumento | Verso | Unità | Margine USD | P&L netto |
|---|---|---|---|---|---|
| 16/9 19:00:48 | EURUSD | short | 547 214,68 | 62 792,33 | −355,69 |
| 16/9 19:00:58 | USDCAD | long | 464 358,50 | 46 435,84 | +414,56 |
| 16/9 20:00:14 | AUDUSD | long | 28 207,949 | 2 000,00 | +122,14 |
| 16/9 22:15:01 | AUDUSD | long | 28 226,660 | 1 999,99 | +135,49 |
| 16/9 23:01:22 | AUDUSD | long | 28 221,482 | 2 000,00 | +131,79 |
| 17/9 00:45:04 | EURAUD | long | 17 444,888 | 1 999,99 | −84,13 |
| 17/9 01:15:03 | EURAUD | long | 17 448,661 | 1 999,99 | −76,67 |
| 17/9 02:00:23 | EURAUD | long | 17 452,394 | 1 999,99 | −72,96 |
| 17/9 03:15:01 | EURAUD | long | 17 450,257 | 1 999,99 | −51,91 |
| 17/9 12:30:02 | AUDUSD | short | 28 073,722 | 2 000,00 | −26,39 |
| 18/9 04:00:03 | NZDUSD | short | 34 883,315 | 1 999,99 | +17,79 |
| 18/9 04:15:04 | NZDUSD | short | 34 843,813 | 2 000,00 | +40,42 |
| 18/9 07:00:32 | EURAUD | short | 17 418,146 | 1 999,99 | +18,89 |
| 18/9 08:15:04 | NZDUSD | short | 34 950,981 | 1 999,99 | −20,97 |
| 18/9 09:15:03 | EURAUD | short | 17 419,919 | 1 999,99 | +26,97 |
| 18/9 10:15:01 | EURAUD | short | 17 415,984 | 2 000,00 | +27,83 |
| 21/9 06:45:02 | EURAUD | short | 17 427,466 | 1 999,99 | +12,68 |
| 21/9 07:15:03 | EURAUD | short | 17 432,862 | 2 000,00 | +9,57 |
| 21/9 08:15:02 | EURAUD | short | 17 425,358 | 1 999,99 | −0,62 |
| 21/9 09:00:44 | EURAUD | short | 17 421,555 | 1 999,99 | +7,95 |
| 21/9 10:15:03 | EURAUD | short | 17 420,945 | 1 999,99 | +12,31 |
Tutte chiuse il 21/9 alle 13:26 UTC in blocco (chiusura manuale). Totale: 21 gambe, **+289,05 USD** netti, 0 commissioni. Il segno positivo è casuale: gambe singole senza copertura, nessuna regola di uscita applicata per cinque giorni.
Osservazioni:
1. Gli orari sono chiusure di barra M15 (`:00`, `:15`, `:30`, `:45` più pochi secondi): sono ordini del bot. Ogni volta che il segnale restava oltre `zIn` alla barra successiva, il basket — tornato `Idle` dopo il «rifiuto» — inviava **un'altra gamba A**. Le dodici EURAUD sono lo stesso segnale ripetuto per dodici barre.
2. `GET api/v1/trading/info/demo/orders/381739181` (l'ordine EURUSD) risponde `referenceID: 00000000-0000-0000-0000-000000000000`: il server **non ha associato** l'`x-request-id` all'ordine. La ricerca `orders:lookup?referenceId=<x-request-id>` non poteva che rispondere 404. La ricerca per `orderId` risponde 200 con `status.id = 3 (Filled)` e la posizione.
3. I primi due ordini hanno impegnato **109 228 USD di margine, cioè tutta l'equity** (1 092 281 USD di nozionale a leva 10): erano le gambe A di due basket diversi, ciascuna sizata fino al tetto `maxEffectiveLeverage = 10` calcolato sul nozionale del *basket* senza guardare il margine disponibile.
4. Dal terzo ordine in poi ogni esecuzione vale **esattamente 2 000 USD di margine**: `orders:lookup?orderId=382724150` mostra `requestedAmount 2000`, `frozenAmount 2000`, `requestType byUnits`, `requestedUnits 17420.945125`. Il bot manda unità arrotondate a due decimali; sei decimali significano che il server ha **ricalcolato le unità da un importo**: con il margine esaurito eToro ha ridotto l'ordine a un importo fisso invece di rifiutarlo. Le unità eseguite non erano quelle richieste.
5. Il saldo è passato da 109 228 a 149 517 USD fra il 16 e il 22/9. Dal ledger ricevuto il 23/9 (D-36) non è un accredito unico: l'equity registrata a ogni riga sale in **circa ventuno scatti di ≈ +2 000 USD**, in coincidenza con le ventuno esecuzioni che il server aveva ridotto a 2 000 USD di margine. Il conto demo ha cioè accreditato fondi virtuali per ogni ordine ridotto: una regola del demo, non un'operazione del bot né un deposito dell'utente. In dashboard gli accrediti hanno alzato il picco di equity e falsato drawdown e P&L del giorno; dalla 5.0 sono `movimento_di_cassa` e non contano.
## Causa
Tre difetti concatenati, nessuno dei quali da solo avrebbe prodotto il danno:
1. **Esito cercato con la chiave sbagliata** (`EtoroBroker.OpenAsync`): l'`orderId` restituito dal `POST` veniva letto e ignorato; l'esito era chiesto solo per `referenceId`, che il server non registra per gli ordini v2. Dopo `fillTimeoutSeconds` il metodo restituiva un esito **costruito a mano** (`"Received"`, «esito non ancora noto») invece di dire «non so».
2. **Ordine abbandonato** (`BasketExecutor.SendAsync`, `BasketEngine.ExecuteEntryAsync`): allo scadere di `legTimeoutSec` la gamba era «non eseguita», il basket rifiutato e riportato a `Idle`, e nessuno seguiva più l'ordine. Alla barra dopo si ripartiva da zero.
3. **Posizione sconosciuta = posizione intoccabile** (`BasketEngine.ReconcileAsync`): la regola di sicurezza «non toccare ciò che non è tuo» era corretta per le posizioni esterne, ma il bot non aveva alcun modo per riconoscere le proprie. Il contatore contava gli slot, non le posizioni; il kill-switch chiudeva gli slot, non le posizioni.
Aggravante: il **sizing non guardava il margine**. Con `orderLeverage = maxEffectiveLeverage = 10` un solo basket al tetto impegna il 100 % dell'equity.
## Correzione (Fase 1-3 del piano 5.0)
| Difetto | Correzione | Dove |
|---|---|---|
| esito per `referenceId` | esito per **`orderId`** (`orders:lookup?orderId=`, ripiego `api/v1/trading/info/{demo/}orders/{id}`); il riferimento solo se la risposta al `POST` è andata persa; matching sulle posizioni (strumento + verso + orario ± 90 s) come ultima risorsa | `EtoroBroker.OpenAsync`, `LookupOrderByIdAsync` |
| esito sintetico | `OrderOutcome` con stato `Unknown` e `Pending = true`; mai un nome di stato che il server non ha detto | `EtoroBroker`, `OrderOutcome` |
| ordine abbandonato | **`OrderTracker`** con registro persistente `data/state/pending_orders.json` scritto **prima** dell'HTTP; stati `PendingA` / `PendingB`; risoluzione a ogni ciclo e all'avvio; `orders.jsonl` append-only | `Core/Baskets/OrderTracker.cs`, `BasketExecutor`, `BasketEngine` |
| posizioni proprie non riconosciute | **`PositionClassifier`**: `basket` / `orfana-bot` / `esterna`; le orfane-bot vengono adottate e chiuse; contatori separati in dashboard; banner se equity − saldo non torna con le posizioni | `Core/Baskets/PositionClassifier.cs`, `BasketEngine.Reconcile.cs` |
| kill-switch che chiude gli slot | kill-switch che chiude **le posizioni** (basket + orfane), cancella i pendenti, verifica la piattezza, stato `Halted-Residuo` | `BasketEngine.Kill.cs` (Fase 3) |
| sizing senza margine | `risk.maxMarginUsePct`, `maxMarginPerBasketPct`, `marginBufferPct`, sizing = min(rischio, margine), ricontrollo di `available` prima di B, margin guard | `VolParitySizing`, `BasketDecider`, `BasketExecutor` (Fase 2) |
| accredito che gonfia il picco | `CashFlowDetector`: salto di saldo non spiegato dalle chiusure = movimento di cassa; picco e equity di inizio giornata al netto | `Core/Baskets/CashFlowDetector.cs`, `BasketEngine.State.cs` |
## Come si verifica che non si ripeta
- Test (m): lookup 404 persistente + posizione presente → `Filled` per matching (`EtoroBrokerTests`).
- Test (n): A eseguita, B rifiutata → A richiusa entro 5 s (`LegRiskTests`).
- Test (o): A pendente oltre il timeout poi eseguita → `PendingA → Open` con B, oppure unwind se il segnale è decaduto (`OrderTrackerTests`).
- Test (p): posizione con la firma del bot → `orfana-bot` e chiusa (`PositionClassifierTests`).
- Test (q): un deposito non muove il picco né il drawdown (`CashFlowTests`).
- In Demo: 24 ore con ordini eseguiti riconosciuti e **zero** orfane (contatore «Gambe orfane» a 0 per tutta la sessione; `orders.jsonl` senza stati `Unknown` non risolti).
- Skill `encelado-diagnose`: rapporto di riconciliazione fra `orders.jsonl`, `pending_orders.json` e le posizioni del conto.
## Che cosa resta aperto
- ~~Il ledger delle sessioni 16-21/9 non è su questa macchina~~ Ricevuto il 23/9 (D-36): 1 813 righe, 65 `segnale_ingresso` e 65 `rifiuto` «esito non ancora noto», preset AGGRESSIVE impostato dalla finestra, quattro run. Conferma la catena: lo stesso segnale ripetuto a ogni barra, ogni gamba A inviata e mai seguita, `unitsA` a due decimali contro le unità a sei decimali eseguite dal server. La chiusura in blocco del 21/9 13:26 UTC l'ha fatta l'utente dalla piattaforma (D-37): +289,05 USD realizzati, per fortuna.
- La regola con cui eToro riduce un ordine a margine esaurito non è documentata nell'OpenAPI; il bot non deve più trovarsi in quella condizione (Fase 2), ma la registra se accade (`units_eseguite ≠ units_richieste` in `orders.jsonl`).
+188
View File
@@ -0,0 +1,188 @@
# PROMPT PER CLAUDE CODE — Encelado 5.0: bonifica esecuzione, storico ordini, navigazione laterale, valuta, recupero dopo inattività, Telegram, apprendimento, kill-switch, margine, Material Design, Docker + Unraid
> Apri il repository `Encelado` e leggi, in quest'ordine: `CLAUDE.md`, `docs/STATE.md`, `docs/ARCHITECTURE.md`, `docs/RISK_RULES.md`, `docs/RUNBOOK.md`, `docs/KNOWN_ISSUES.md`, poi questo documento **per intero**. Questo prompt aggiorna la specifica precedente ("Correlation Baskets su eToro"): dove i due si contraddicono vale questo. Le regole di `CLAUDE.md` restano tutte (C#, nessun NuGet nell'applicazione, CSV `;` con `motivazione`, UTC, ledger append-only, mai un ordine reale senza flag e frase, un ADR per ogni scelta non ovvia, `docs/STATE.md` e `CHANGELOG.md` aggiornati a fine sessione).
>
> **Metodo di lavoro richiesto:** (1) rileggi questo prompt e produci `docs/PIANO_5.0.md` con la valutazione di ogni punto (fattibile / da chiarire / da rifiutare con motivo), l'ordine di esecuzione e la stima; (2) poni in blocco le domande di §15 e attendi; (3) implementa per fasi (§16), una fase per commit, con test verdi e documenti aggiornati; (4) **se hai un dubbio, chiedi**: `docs/QUESTIONS.md`, numerazione D-26 in poi, default prudente se non arriva risposta.
---
## 0. Diagnosi preliminare (già fatta leggendo codice e ledger: verificala, poi correggi)
Dal ledger `data/ledger/decisions.jsonl` (16-22 settembre): **65 `segnale_ingresso` e 65 `rifiuto`**, tutti con lo stesso testo: *«gamba A (…) non eseguita: Received → esito non ancora noto»*. Nessun basket è mai passato in `Open`, `data/ledger/baskets.csv` non esiste, `baskets_state.json` ha `baskets: []`, `learning_state.json` dice «ledger senza basket chiusi». Eppure il log di stato mostra `aperto −348,91` poi `−380,24` con `basket aperti 0/5`, e l'equity in dashboard (137 901) è sotto il saldo (139 228) mentre "P&L aperto" mostra 0,00.
Catena causale nel codice:
1. `EtoroBroker.OpenAsync` (`src/Encelado.Etoro/EtoroBroker.cs`): il `POST orders` risponde con un `orderId`, che viene letto e **mai più usato**. Il polling dell'esito passa solo da `LookupOrderAsync(clientRef)` = `GET orders:lookup?referenceId=<x-request-id>`, che restituisce **404 → `null`** per tutti i 10 s di `fillTimeoutSeconds`; il metodo torna `OrderOutcome("Received", "esito non ancora noto")` costruito a mano (riga `return last ?? new OrderOutcome(...)`).
2. `BasketExecutor.SendAsync` ripete lo stesso lookup per altri `legTimeoutSec` (5 s), sempre `null`, e dichiara la gamba A «non eseguita». Il basket viene rifiutato; **l'ordine A resta sul server e viene eseguito** (o lo è già stato): nasce una gamba orfana, senza copertura, con lo stop nativo ma senza TP né gestione.
3. `BasketEngine.ReconcileAsync` vede la posizione, non la trova in `_knownPositions`, la scrive una volta nel log come «non appartiene a nessun basket: la lascio com'è» e **non la tocca mai più**. Il contatore basket resta 0/5 perché conta gli slot con `Position`, non le posizioni del conto.
4. `KillAsync → CloseAllAsync` chiude solo gli slot con `Position` (zero): il kill-switch «riesce» senza chiudere nulla. È il punto 8 dell'utente.
Conseguenze da correggere: (a) l'esito ordine va cercato **per `orderId`** (endpoint da verificare sulla documentazione: `GET api/v2/trading/info/{demo/}orders/{orderId}` o equivalente) e, in subordine, per `referenceId`, e comunque **riconciliato con l'elenco posizioni** (strumento + verso + unità ± 1 % + orario ± 90 s); (b) un ordine dall'esito ignoto **non si abbandona mai**: entra in un registro persistente di ordini pendenti e viene seguito finché non è eseguito, rifiutato o annullato; (c) una gamba eseguita a basket abortito va **chiusa subito**, non lasciata; (d) le posizioni del conto che portano la firma del bot (clientRef/orderId nel registro, oppure strumento+unità+orario coerenti con un `segnale_ingresso` del ledger) sono **del bot**, non «sconosciute»; (e) il contatore in dashboard deve distinguere «basket del bot», «gambe orfane del bot», «posizioni esterne».
Sui **«depositi» nella cronologia eToro**: il codice non chiama alcun endpoint di deposito o trasferimento (verificato: rotte usate = instruments, rates, candles, eligibility, costs, pnl, orders, orders:lookup, market-close-orders, positions, history, me, balances). Il saldo è passato da 109 228 (16/9) a 139 228 (18/9): **+30 000 esatti**, cifra tonda tipica di un accredito di fondi virtuali sul portafoglio demo, non di un trade. Le voci «deposito» sono movimenti di cassa del conto virtuale (accrediti di eToro o richiesti dall'utente), non operazioni del bot. Nella nuova scheda Storico (§1) vanno mostrate a parte, come `movimento di cassa`, mai sommate al P&L. Se dopo l'analisi dello storico via API (`api/v1/trading/info/trade/{demo/}history` e `api/v1/balances`) risultasse un'altra origine, scrivila in `docs/KNOWN_ISSUES.md`.
Sul **margine**: il sizing attuale è solo `rischio % / distanza dello stop`. Un basket Aggressive ha prodotto 1 092 281 USD di nozionale (leva 10) su 109 228 USD di equity: **una sola** operazione impegnava tutto il margine del conto; con `maxBaskets = 5` il secondo basket non poteva esistere. È il punto 10 dell'utente e va risolto in §10.
---
## 1. Scheda «Storico ordini» (nuova)
Nuova sezione di navigazione `Storico` con tre viste:
- **Ordini** (ultimi N, filtro per basket/strumento/verso/esito/periodo): una riga per ordine inviato (apertura, aggiunta, chiusura, unwind), con `ts, basket_id, strumento, verso, unità, prezzo richiesto, prezzo eseguito, slippage (pip), stato (eseguito/rifiutato/annullato/pendente/ignoto→risolto), orderId, positionId, fee, motivazione`. Fonte: nuovo file `data/ledger/orders.jsonl` (append-only, §3) scritto dall'esecutore **a ogni invio e a ogni cambio di stato**, più riconciliazione con lo storico eToro.
- **Posizioni** (aperte e chiuse): una riga per posizione, con origine `basket | orfana-bot | esterna | movimento di cassa`, apertura/chiusura, P&L lordo/netto in USD e in valuta di visualizzazione, pip, durata, motivo di uscita, fee e overnight; le posizioni aperte in tempo reale con P&L corrente.
- **Profitti per periodo**: tabella `periodo; n_basket; n_posizioni; vinti; persi; win_rate; pnl_lordo; fee; pnl_netto; media_per_basket; max_dd; motivazione` per `oggi, ieri, 7 giorni, 30 giorni, mese corrente, mese precedente, anno, tutto, intervallo personalizzato`, con un piccolo grafico dell'equity (SVG generato lato server o canvas lato client, nessuna libreria). Fonte di verità del realizzato: lo **storico eToro** (`GetClosedTradesAsync`), riconciliato con `baskets.csv`; i movimenti di cassa restano fuori dal P&L e compaiono in una riga separata.
- Pulsante **Esporta CSV** (`;`, colonna `motivazione`) per ciascuna vista.
Modulo: `src/Encelado.Core/Baskets/History/` (`OrderRecord`, `PositionRecord`, `PeriodStats`, `HistoryBuilder` puro e testabile) + endpoint `GET /api/history/{orders|positions|periods}`.
## 2. Navigazione verticale a sinistra, espandibile e comprimibile
Sostituisci la barra in alto con le tre schede con una **Navigation rail** Material 3 a sinistra (80 px chiusa: icona + etichetta breve; 256-300 px aperta: icona + etichetta estesa), apribile/chiudibile dal pulsante menu in alto e con stato persistito (`ui.navExpanded`). Voci: `Dashboard`, `Storico`, `Log`, `Impostazioni`; in basso, nel rail, il chip ambiente (`PAPER/DEMO/LIVE`) e lo stato (`in esecuzione / fermo / bloccato`). Su schermi stretti (< 600 px) il rail diventa un drawer modale. La barra superiore resta sottile: titolo della pagina, orologio UTC + fuso scelto, `AVVIA/FERMA`, `KILL-SWITCH`.
## 3. Versione fuori dalla schermata principale
Rimuovi dalla dashboard `v4.0.0 · strategia <hash> · run <id>`. In `Impostazioni → Informazioni`: nome, **autore (Alberto Balbo)**, versione, data di build, commit, licenza, link alla documentazione. In `Impostazioni → Diagnostica` (sezione comprimibile): hash della strategia, `run_id`, percorsi dei file, versione .NET, uptime, quote API usate.
## 4. Valuta di visualizzazione selezionabile
`ui.displayCurrency` (default = valuta del conto, `USD`) selezionabile fra `USD, EUR, GBP, CHF, JPY, AUD, CAD, NZD` in Impostazioni e con un selettore rapido nella barra. Tassi: dalle quote eToro già in polling (EURUSD id 1, ecc.; per le coppie mancanti derivali via USD) aggiornati con le quote; in assenza di quota, l'ultimo tasso noto con etichetta «tasso di N minuti fa». Conversione **solo nel livello di presentazione** (snapshot → UI/Telegram/export); ledger, `baskets.csv`, `trials.csv` e tutte le decisioni restano in USD. Ogni importo convertito porta nel tooltip il valore in USD e il tasso usato. Formattazione con `CultureInfo` invariante e simbolo/decimali per valuta (JPY senza decimali).
## 5. Conteggio basket, posizioni aperte e «depositi» (correzione del bug di §0)
Implementa nell'ordine:
1. **`OrderTracker`** (`src/Encelado.Core/Baskets/OrderTracker.cs`) con registro persistente `data/state/pending_orders.json`: `clientRef, orderId, symbol, instrumentId, isBuy, units, basket_id, leg (A|B|add|close|unwind), sentUtc, lastStatus, resolvedUtc, positionId`. Ogni invio si registra **prima** della chiamata HTTP; ogni esito lo aggiorna; all'avvio il registro viene ricaricato e i pendenti risolti prima di qualunque decisione.
2. **`EtoroBroker.OpenAsync`**: dopo il `POST`, polling **per `orderId`** (endpoint da verificare, D-26) e, in parallelo, per `referenceId`; se entrambi rispondono 404, dopo 2 s interroga le posizioni e applica la regola di matching di §0(a); se il matching riesce l'ordine è `Filled` con quel `positionId`. Restituisce `Pending` solo se davvero non c'è traccia; **mai** un `"Received"` sintetico. Verifica la mappa degli stati (`filled = 3 or 5`, `rejected = 4,7,8,9,10`) sulla documentazione e scrivila in `docs/DATA_SOURCES.md`.
3. **`BasketExecutor`**: se la gamba A resta `Pending` allo scadere di `legTimeoutSec`, il basket passa in stato **`PendingA`** (nuovo) invece di essere rifiutato: nessun nuovo ingresso su quel basket, `OrderTracker` continua a seguire l'ordine; alla risoluzione: eseguito → invia B (se il segnale è ancora valido e il cost gate passa) oppure **chiudi A subito** (`leg_risk_unwind`) se non lo è; rifiutato → `Idle`. Stesso schema per B (`PendingB`). Registra tutto in `orders.jsonl` e in `decisions.jsonl` (`evento = pending`, `pending_risolto`).
4. **`ReconcileAsync`**: classifica ogni posizione del conto in `basket` (nota), `orfana-bot` (nel registro ordini o firma coerente con un `segnale_ingresso`/`rifiuto` del ledger entro ±90 s, stesso strumento, stesso verso, unità ± 1 %), `esterna`. Le orfane-bot vengono **adottate e chiuse** (§7 recupero decide se prima provare a ricomporre il basket con la gamba mancante: default **no**, chiudi). Le esterne restano intoccate salvo `risk.closeForeignOnKill`.
5. **Bonifica una tantum** all'avvio della 5.0 (`--bonifica` in headless / pulsante in Diagnostica): elenca le posizioni orfane-bot attualmente sul conto demo, le chiude una per una con conferma, scrive per ognuna una riga `baskets.csv` con `exit_reason = bonifica_orfana` e il P&L realizzato letto dallo storico, e produce `reports/bonifica_YYYYMMDD.csv`.
6. **Dashboard**: `Basket aperti a/b` resta, affiancato da `Gambe orfane: n` (rosso se > 0) e `Posizioni esterne: n`; `P&L aperto` mostra il valore **del conto** (`_account.UnrealizedPnl`) con sotto «di cui basket: x»; `Equity − Saldo` e `P&L aperto` devono coincidere a meno delle fee: se non coincidono per più di 60 s, banner giallo «posizioni non riconciliate».
7. **Movimenti di cassa**: `HistoryBuilder` legge saldi e storico, riconosce depositi/prelievi/accrediti virtuali e li espone in Storico come `movimento di cassa`, esclusi dal P&L e dal calcolo del drawdown (il picco di equity va **ricalcolato al netto dei movimenti di cassa**: oggi un accredito di 30 000 gonfia il picco e falsa il DD).
Test obbligatori: (m) lookup 404 persistente + posizione presente → `Filled` per matching; (n) A eseguita e B rifiutata → unwind entro 5 s; (o) A pendente oltre il timeout poi eseguita → `PendingA → Open` con B, oppure unwind se il segnale è decaduto; (p) posizione orfana con firma del bot → classificata `orfana-bot` e chiusa; (q) picco di equity insensibile a un deposito.
## 6. Recupero dopo inattività
Heartbeat `data/state/heartbeat.json` scritto ogni 30 s (`utc, run_id, mode, openBaskets`). All'avvio e a ogni iterazione del ciclo: `inattività = now − ultimo heartbeat`; se `> recovery.thresholdMinutes` (default 10; copre riavvii, sospensione del PC, aggiornamenti Windows, riavvio del container) entra la **procedura di recupero**, nell'ordine:
1. Blocca le nuove entrate; scrivi `evento = recupero_avviato` con la durata dell'inattività.
2. Risolvi il registro ordini pendenti (§5.1); riconcilia e classifica le posizioni (§5.4).
3. Riscalda le serie (ultime 1000 candele M15 via API) e ricalcola per ogni basket noto `z, ρ_W, ρ_20, HL, spread, costo, barsHeld` **includendo le barre trascorse durante l'inattività**.
4. Per ogni basket aperto applica le regole di uscita di §5.4 della specifica precedente come se fosse una valutazione ordinaria (`stop_z`, `stop_max_loss`, `time_stop` con le barre di inattività, `rho_break`, spread anomalo, fine settimana/blackout) e decide **`chiudi` o `tieni`**; per ogni gamba orfana-bot: `chiudi`; per le posizioni esterne: solo rapporto.
5. Esegui le chiusure decise; per i `tieni` ripristina TP/stop di basket e riprendi il monitoraggio tick-by-tick.
6. Se il mercato è chiuso (fine settimana) programma la valutazione alla riapertura e non fare nulla di irreversibile.
7. Scrivi `reports/recupero_<run_id>.csv` (una riga per posizione: `decisione; motivo; z; ρ; barsHeld; pnl; motivazione`), riga `recupero_concluso` nel ledger, notifica Telegram con il riepilogo; sblocca le entrate solo dopo `recovery.warmupMinutes` (default 15) di quote coerenti.
Parametri in `strategy.json` → `recovery`. Test: (r) simulazione di 6 h di inattività con un basket che nel frattempo ha superato `z_stop` → chiuso; con un basket ancora dentro le soglie → tenuto e riarmato; con una gamba orfana → chiusa.
## 7. Notifiche Telegram
Modulo `src/Encelado.Core/Notifications/TelegramNotifier.cs` (Bot API via `HttpClient`, `sendMessage` con `parse_mode=HTML`, coda in `Channel<T>`, 1 messaggio/s, retry con backoff, nessuna libreria) + `INotifier` con `NullNotifier`. Configurazione in `encelado.json` → `notifications.telegram`: `enabled, chatId, hourlyStatus, eventAlerts, dailySummaryUtcHour` (token e chatId anche da `TELEGRAM_BOT_TOKEN`/`TELEGRAM_CHAT_ID`; mai nel repo).
- **Stato ogni ora** (allo scoccare dell'ora UTC): attivo/fermo/bloccato, modalità e ambiente, uptime, equity/saldo/disponibile/margine usato (valuta di visualizzazione), P&L oggi e aperto, basket aperti (per ognuno: coppie, verso, z, pip, P&L, durata), gambe orfane, posizioni esterne, DD dal picco, prossimo evento ad alto impatto, stato API (latenza, quote usate), ultimo errore.
- **Eventi**: apertura basket, aggiunta, chiusura (con motivo e P&L), unwind, ordine pendente risolto, kill-switch, equity stop, perdita giornaliera raggiunta, recupero avviato/concluso, cambio preset, avvio/arresto del bot, errori API persistenti, scarto orologio, feed in errore per > 1 h.
- **Riepilogo giornaliero** alle `dailySummaryUtcHour` (default 21): P&L del giorno, n. basket, win rate, costi, DD.
- **Comandi in ingresso** (long polling `getUpdates`, solo dal `chatId` autorizzato, ogni comando loggato nel ledger): `/stato`, `/posizioni`, `/storico 7d`, `/pausa` (blocca entrate), `/riprendi`, `/chiudi <basket>`, `/kill CONFERMO` (kill-switch), `/reset <motivazione>`; qualunque altro testo → «comando non riconosciuto». Il polling usa un solo task e non compete con le quote eToro.
Test: (s) formattazione dei messaggi su snapshot fissi; (t) throttling e retry con `HttpMessageHandler` finto; (u) rifiuto dei comandi da chatId non autorizzato.
## 8. Valutazione del sistema di autoapprendimento (decisione richiesta)
Stato di fatto: `docs/STRATEGY.md` dà **verdetto negativo** (7,75 anni, nessuna configurazione con P&L netto positivo, segnale ≈ 2 pip contro 3 pip di costo, walk-forward Sharpe −0,91); il forward test in Demo ha **0 basket chiusi** in sei giorni per il bug di §0; il ciclo settimanale ha girato a vuoto («niente da addestrare»). Un meta-modello può solo filtrare i basket, non creare un edge che non c'è: con un segnale sotto i costi il massimo che può fare è ridurre le perdite. Serve inoltre un minimo di ~300 basket chiusi per attivarsi: con la frequenza osservata (poche entrate al giorno, quando entrano) sono mesi.
**Decisione da applicare (ADR-0006), salvo diversa risposta a D-30:**
- **Tenere**: il ledger (è il dato), il Livello 0 (calibrazione: tabelle per bucket di z/ρ/ora/evento, quasi gratis e utili a leggere il forward test), la previsione di volatilità (già usata dal decisore in modo deterministico), la logistica **in ombra** (costo nullo, produce `p_ML` nel ledger).
- **Disattivare a runtime** (codice conservato nel Core, `learning.enabled = false` di fabbrica, nessun task avviato): MLP challenger, bandit sui preset, ciclo settimanale. Spostare la loro esecuzione nello strumento `tools/Encelado.Backtest` (`learn` su un ledger esportato), così restano disponibili quando ci saranno dati.
- **UI**: rimuovere il riquadro «Apprendimento» dalla dashboard; in `Impostazioni → Ricerca` una sezione comprimibile con lo stato del modello in ombra (n. basket visti, AUC mobile, PSI) e il pulsante «esegui ciclo di apprendimento» manuale.
- **Criterio di riattivazione**, scritto in `docs/ML_AND_LEARNING.md`: ≥ 300 basket chiusi in Demo **e** P&L netto forward ≥ 0 sulla pre-registrazione; prima di allora qualunque «adattamento automatico» è rumore.
## 9. Kill-switch che chiude davvero e procedura di ripristino
**Kill-switch** (`KillAsync`), nuovo comportamento, idempotente e ripetibile:
1. `halt = true`, blocco immediato di ogni nuova entrata e aggiunta; riga `kill_switch_avviato`.
2. Annulla gli ordini pendenti nel registro (endpoint di cancellazione se esiste, D-27; altrimenti attende la risoluzione entro 30 s e chiude ciò che si è eseguito).
3. Chiude **tutte le posizioni del bot**: basket noti + gambe orfane-bot (§5.4), tre tentativi per gamba con backoff, verifica tra un tentativo e l'altro sull'elenco posizioni.
4. Posizioni **esterne**: chiuse solo se `risk.closeForeignOnKill = true` **oppure** se la finestra di conferma del kill-switch ha la spunta «chiudi anche le posizioni esterne» (default deselezionata, con l'elenco delle posizioni e il loro P&L).
5. **Verifica di piattezza**: rilegge le posizioni finché non restano solo esterne non incluse (timeout 120 s); se restano residui, banner rosso con l'elenco e stato `Halted-Residuo`; nessuna dichiarazione di «tutto chiuso» senza questa verifica.
6. Persiste `killSwitched`, scrive una riga `baskets.csv` per basket e una riga `orders.jsonl` per gamba, notifica Telegram (esito, residui).
Il file `STOP` e il comando `/kill CONFERMO` seguono lo stesso percorso.
**Ripristino** (`Impostazioni → Ripristino` e comando `reset <motivazione>`), procedura guidata in cinque passi mostrati uno per volta: (1) stato attuale: posizioni residue (con pulsante «chiudi ora»), ordini pendenti, ultimo errore; (2) rimozione del file `STOP` (automatica, con avviso se ricompare); (3) motivazione obbligatoria ≥ 10 caratteri → riga `correzione`; (4) riconciliazione completa + riscaldamento serie + ricalcolo del picco di equity (al netto dei movimenti di cassa); (5) ripartenza con entrate bloccate per `recovery.warmupMinutes`; notifica Telegram. Documenta in `docs/RUNBOOK.md` con una tabella «sintomo → passo». Test: (v) kill con 2 basket + 1 orfana + 1 esterna → chiude 5 gambe, lascia l'esterna, verifica la piattezza; (w) reset senza motivazione rifiutato; (x) reset con residui → stato `Halted-Residuo`.
## 10. Saldo disponibile e coerenza delle aperture
Leggi a ogni ciclo `AccountSnapshot` completo (`balance, equity, available, marginUsed, credit`) da `api/v1/balances` + `pnl` e mostra `Margine usato / disponibile` in dashboard. Nuove regole in `strategy.json → risk` (documentate in `docs/RISK_RULES.md`):
- `maxMarginUsePct` (default **40 %** dell'equity): margine totale impegnato dopo l'apertura ≤ soglia.
- `maxMarginPerBasketPct` (default **12 %**): margine delle due gambe di un basket ≤ soglia.
- `marginBufferPct` (default 25 %): `available ≥ (marginA + marginB) × 1,25` **prima** di inviare A, e ricontrollo di `available` (con la posizione A già aperta) prima di inviare B; se B non è più coperta, unwind di A.
- Sizing = **min**(sizing a rischio, sizing a margine); il ledger scrive quale vincolo ha deciso (`sizing_bound = risk | margin | min_exposure`) e il margine impegnato previsto; l'esposizione minima eToro (1000 USD per posizione) resta il floor: se il min non la raggiunge, niente ingresso (`reasonCodes: min_exposure`).
- Ordine dei basket quando più segnali arrivano insieme: per `|z|` decrescente, uno alla volta, ricalcolando `available` dopo ogni apertura.
- Margin call preventiva: se `equity / marginUsed < 1,5` blocca le entrate; `< 1,2` chiude il basket con il peggior P&L (riga `margin_guard`).
Test: (y) con equity 100 000 e Aggressive il nozionale per basket è limitato dal margine, non dal rischio; (z) il secondo basket viene rifiutato quando `available` non copre `1,25 ×` margine.
## 11. Interfaccia secondo Material Design 3 (web, senza librerie) — e conseguenza sul progetto WPF
Docker su Unraid è Linux: **WPF non può girare nel container**. Decisione proposta (**ADR-0007**, da confermare con D-28): l'interfaccia diventa una **web app servita dal bot stesso** (Kestrel, `Microsoft.AspNetCore.App` è un framework reference dell'SDK, non un pacchetto NuGet), usata sia su Windows (`http://localhost:8080`) sia nel container; il progetto WPF viene ritirato (resta nella storia git) e il vecchio eseguibile Windows diventa `Encelado.Server` avviabile come console/servizio. Nessun framework front-end, nessun font remoto: HTML + CSS + JavaScript vanilla incorporati come risorse (`EmbeddedResource`), aggiornamenti in tempo reale via **Server-Sent Events** (`/api/stream` con lo snapshot ogni secondo), comandi via `POST /api/commands/...`, autenticazione con **token locale** (`ENCELADO_WEB_TOKEN`, cookie HttpOnly; senza token il server ascolta solo su localhost).
Linee guida M3 da applicare (scrivile in `docs/UI_GUIDELINES.md` con i token scelti):
- **Colore**: ruoli M3 (`primary/on-primary/primary-container`, `surface`, `surface-container-lowest…highest`, `outline`, `error`), palette scura di default e chiara selezionabile, contrasto ≥ 4,5:1; una sola tinta d'accento; verde/rosso solo per P&L e stati.
- **Tipografia**: scala M3 (`display, headline, title, body, label`), `Roboto, "Segoe UI", system-ui` con fallback, cifre tabulari (`font-variant-numeric: tabular-nums`) per tutti i numeri.
- **Forma ed elevazione**: angoli 12-16 px, elevazione tramite superfici tonali (non ombre pesante), state layer su hover/focus/pressed.
- **Componenti** (in CSS/JS proprio): navigation rail + drawer (§2), top app bar, cards (elevated/filled/outlined), data table con densità compatta e intestazioni fisse, chips di stato (assist/filter), buttons (filled/tonal/outlined/text), switch, select/menu, dialog per conferme (kill-switch, chiusura basket, reset), snackbar per esiti, linear progress durante le operazioni, tooltip con formula/fonte su ogni numero, badge sui contatori.
- **Layout adattivo** per classi di finestra M3 (compact < 600, medium < 840, expanded ≥ 840): rail/drawer, griglia a 4/8/12 colonne, tabella dei basket che passa a cards sotto 600 px.
- **Accessibilità**: navigazione da tastiera completa, `aria-label`, focus visibile, preferenze `prefers-reduced-motion` e `prefers-color-scheme`.
Contenuti (stesse informazioni dello screenshot attuale, riorganizzate):
- **Dashboard**: KPI cards `Equity`, `P&L oggi`, `P&L aperto (conto) / di cui basket`, `Drawdown`, `Basket aperti a/b · orfane · esterne`, `Margine usato / disponibile`; tabella basket con `Basket (cross)`, `Stato`, `z`, `ρ`, `HL`, `Pips`, `TP`, `P&L`, `Costo`, `Prossimo evento`, pulsante `Chiudi` (la colonna `p ML` sparisce dalla tabella e va nel tooltip); cards `Prossimo evento`, `Collegamento eToro`, `Telegram` (ultimo invio, coda); striscia `Attività`.
- **Storico**: §1. **Log**: come oggi, con filtro e ricerca. **Impostazioni**: come oggi + `Notifiche`, `Valuta`, `Ripristino`, `Ricerca`, `Diagnostica`, `Informazioni`.
Test: (aa) `UiRenderTests` sostituiti da test sullo snapshot JSON dell'API e da un test che valida l'HTML incorporato (well-formed, nessun riferimento esterno, nessun `<script src=http…>`); (bb) SSE che emette uno snapshot al secondo con un client finto.
## 12. Docker (esecuzione fuori da Windows)
- Ristruttura i progetti: `Encelado.Core` (invariato), `Encelado.Etoro` (invariato), nuovo **`Encelado.Engine`** (net10.0, portabile: `Baskets/`, `Configuration/`, `Engine/`, `Logging/`, `Notifications/`, `History/` oggi dentro `Encelado.Bot`), nuovo **`Encelado.Server`** (`Microsoft.NET.Sdk.Web`, host Kestrel + UI incorporata + CLI headless con gli stessi comandi di oggi). `EtoroKeyStore` (DPAPI) diventa `IKeyStore` con tre implementazioni: DPAPI (solo Windows), file cifrato con AES da `ENCELADO_KEY_PASSPHRASE`, variabili d'ambiente (default nel container). `TreatWarningsAsErrors` e `Nullable` invariati; nessun NuGet.
- `Dockerfile` multi-stage: `mcr.microsoft.com/dotnet/sdk:10.0` per build/test/publish (`-c Release`, framework-dependent), `mcr.microsoft.com/dotnet/aspnet:10.0` per l'esecuzione; utente non root con `PUID/PGID` (default 99/100 per Unraid) applicati da un entrypoint che sistema i permessi di `/config` e `/data`; `TZ` rispettato dai log (il ledger resta UTC); `HEALTHCHECK` con `dotnet Encelado.Server.dll --health` (verifica API eToro raggiungibile, heartbeat recente, disco scrivibile); arresto pulito su `SIGTERM` (`closeOnShutdown` invariato, flush di ledger e stato, heartbeat finale); log su stdout **e** su file.
- Volumi: `/config` (`encelado.json`, `strategy.json`, `instruments.json`, chiavi cifrate), `/data` (`data/`, `knowledge/`, `reports/`, `results/`, `logs/`). Percorsi in `encelado.json` relativi a `/config`; su Windows restano `Documenti\Encelado`.
- Variabili: `ETORO_API_KEY`, `ETORO_USER_KEY`, `ETORO_ENVIRONMENT` (`demo|real`), `ENCELADO_EXECUTION_MODE` (`Paper|Demo|Live`), `ENCELADO_CONFIRM_LIVE` (deve valere `CONFERMO LIVE` per il Live), `ENCELADO_WEB_PORT` (8080), `ENCELADO_WEB_TOKEN`, `ENCELADO_DISPLAY_CURRENCY`, `TELEGRAM_BOT_TOKEN`, `TELEGRAM_CHAT_ID`, `TZ`, `PUID`, `PGID`.
- **Una sola istanza** per cartella dati: lock file `data/state/instance.lock` con PID e orario (risolve il problema noto).
- `docker-compose.yml`, `.dockerignore`, `docs/DOCKER.md` (build, avvio, aggiornamento, backup di `/config` e `/data`, rotazione chiavi, cosa succede ai basket aperti al riavvio → §6). La catena `build/Release.proj` acquisisce il target `Docker` (build + tag `encelado:<versione>`), senza toccare il resto (regola 5 di `CLAUDE.md`); l'installatore Windows resta per `Encelado.Server`.
## 13. Template XML per Unraid
Crea `deploy/unraid/encelado.xml` (formato Community Applications, `Container version="2"`), con: `Name` Encelado, `Repository` (registry e immagine da D-29, es. `gitea.<dominio>/alberto/encelado:latest`), `Registry`, `Network bridge`, `Privileged false`, `Support`, `Project`, `Overview` (descrizione in italiano), `Category` `Tools:`, `WebUI` `http://[IP]:[PORT:8080]/`, `Icon` (URL raw di `assets/encelado.png` 256×256, da aggiungere al repo insieme all'`.ico`), `ExtraParams --restart=unless-stopped`, `Config` per: porta 8080 (`Type=Port`), `/config` → `/mnt/user/appdata/encelado/config` e `/data` → `/mnt/user/appdata/encelado/data` (`Type=Path`, `Mode=rw`), tutte le variabili di §12 (`Type=Variable`, `Mask=true` su chiavi e token, `Display=always` per modalità/ambiente/valuta/TZ, `Display=advanced` per PUID/PGID/porta), con `Description` in italiano per ogni voce. Aggiungi `deploy/unraid/README.md` (come importare il template: «Add Container → Template repositories» o copia in `/boot/config/plugins/dockerMan/templates-user/`).
## 14. Documentazione-memoria per l'AI e base di conoscenza
Aggiorna: `CLAUDE.md` (nuova struttura dei progetti, comandi Docker/web, regole invariate), `docs/STATE.md`, `docs/ARCHITECTURE.md` (OrderTracker, stati `PendingA/PendingB/Halted-Residuo`, web/SSE, Engine/Server, notifiche, recupero), `docs/RISK_RULES.md` (margine, kill-switch, esterne), `docs/RUNBOOK.md` (ripristino guidato, Docker, Telegram, bonifica), `docs/LEDGER_SCHEMA.md` (`orders.jsonl`, `pending_orders.json`, `heartbeat.json`, nuovi `evento`), `docs/DATA_SOURCES.md` (rotte eToro verificate con stati ordine, Telegram), `docs/ML_AND_LEARNING.md` (§8), `docs/KNOWN_ISSUES.md` (rimuovi ciò che si chiude, aggiungi ciò che resta), `docs/UI_GUIDELINES.md`, `docs/DOCKER.md`, `docs/GLOSSARY.md`, `CHANGELOG.md`; ADR-0006 (apprendimento), ADR-0007 (UI web al posto di WPF), ADR-0008 (Docker/Engine/Server), ADR-0009 (OrderTracker e adozione delle orfane). Genera anche **`docs/POSTMORTEM_ordini_pendenti.md`**: cosa è successo, evidenze dal ledger, causa, correzione, come si verifica che non si ripeta.
Crea inoltre le **skill di progetto per Claude Code** in `.claude/skills/<nome>/SKILL.md` (frontmatter `name`, `description`), così che il lavoro futuro parta sempre dallo stesso posto:
- `encelado-start`: leggi `docs/STATE.md` e `CLAUDE.md`, esegui `dotnet build`, riassumi fase e problemi aperti, chiedi cosa fare.
- `encelado-verify`: `dotnet build`, `dotnet test`, verifica dell'HTML incorporato, `dotnet msbuild build/Release.proj -t:Verifica`, riepilogo esiti.
- `encelado-diagnose`: legge `decisions.jsonl`, `orders.jsonl`, `pending_orders.json`, `heartbeat.json` e l'elenco posizioni (se chiavi presenti) e produce un rapporto di riconciliazione in CSV `;`.
- `encelado-docs`: aggiorna `docs/STATE.md`, `CHANGELOG.md`, ADR e `docs/QUESTIONS.md` a fine sessione, poi propone il messaggio di commit.
- `encelado-release`: catena di rilascio + build Docker + aggiornamento del template Unraid.
- `encelado-ui`: applica i token e le regole di `docs/UI_GUIDELINES.md` quando si tocca la UI.
## 15. Domande da porre prima di iniziare (in blocco, con default)
| # | Domanda | Default |
|---|---|---|
| D-26 | Qual è l'endpoint corretto per leggere un ordine per `orderId` e quali sono gli stati (id/nome)? Fornisci la pagina della documentazione o l'esito di una chiamata reale. | verifica sul portale; se non esiste, riconciliazione per posizioni entro 2 s |
| D-27 | Esiste un endpoint di cancellazione ordini? | no: attesa risoluzione ≤ 30 s |
| D-28 | Confermi il ritiro del progetto WPF a favore della web UI servita dal bot (Windows e Docker)? | sì (ADR-0007) |
| D-29 | Registry per l'immagine (Gitea del tuo server, GHCR, Docker Hub) e URL raw per l'icona del template Unraid? | Gitea (`build/gitea.example.json`), icona nel repo |
| D-30 | Confermi la disattivazione a runtime di MLP, bandit e ciclo settimanale (§8)? | sì (ADR-0006) |
| D-31 | Chat ID e token Telegram verranno forniti via variabili d'ambiente? Vuoi i comandi in ingresso o solo le notifiche? | env; comandi attivi |
| D-32 | Le posizioni esterne vanno chiuse dal kill-switch di default? | no |
| D-33 | Valute da offrire nel selettore oltre a USD/EUR? | USD, EUR, GBP, CHF, JPY, AUD, CAD, NZD |
| D-34 | Soglie di margine (40 % totale, 12 % per basket, buffer 25 %) e soglia di inattività (10 min) vanno bene? | sì |
| D-35 | Le posizioni orfane oggi sul demo: le chiudo io con la bonifica (§5.5) o le chiudi tu a mano prima? | bonifica con conferma per posizione |
## 16. Fasi e criteri di accettazione
| Fase | Contenuto | Accettazione |
|---|---|---|
| 0 | `docs/PIANO_5.0.md`, domande D-26…D-35, `docs/POSTMORTEM_ordini_pendenti.md` | piano approvato, domande risposte o default registrati |
| 1 | §5 OrderTracker, lookup per orderId, stati Pending, adozione orfane, contatori, picco al netto dei movimenti di cassa, bonifica | test (m)-(q) verdi; 24 h di Demo con ordini eseguiti riconosciuti e **zero** orfane |
| 2 | §10 margine e coerenza aperture | test (y)(z); ledger con `sizing_bound` |
| 3 | §9 kill-switch reale + ripristino guidato | test (v)-(x); prova manuale in Demo con verifica di piattezza |
| 4 | §6 recupero dopo inattività, heartbeat, lock di istanza | test (r); prova: fermare 1 h con basket aperto |
| 5 | §7 Telegram (stato orario, eventi, riepilogo, comandi) | test (s)-(u); messaggi reali ricevuti |
| 6 | §12 Engine/Server, web host, SSE, API, key store portabile | avvio su Windows e in container con la stessa `/config` |
| 7 | §11 UI Material 3 + §2 navigazione + §3 versione + §4 valuta + §1 Storico + §8 pannello Ricerca | test (aa)(bb); revisione visiva con te; stesse informazioni dello screenshot presenti |
| 8 | §12 Dockerfile/compose/docs + §13 template Unraid | immagine avviata su Unraid con template importato, healthcheck verde |
| 9 | §14 documentazione, ADR, skill di progetto, `CHANGELOG`, versione **5.0.0**, rilascio | `encelado-verify` verde; commit a fine sessione |
**Regola finale: prima la correttezza dell'esecuzione (Fasi 1-3), poi tutto il resto. Finché un ordine dall'esito ignoto può restare sul conto senza padrone, nessuna nuova funzione va in Demo.**
+90
View File
@@ -0,0 +1,90 @@
# Domande e risposte
Ogni domanda è numerata per fase. Quando l'utente non ha risposto, è stato applicato il default più prudente e la scelta è segnata come **default applicato**: resta aperta finché non arriva una risposta.
## Fase 0 — 2026-09-16
| # | Domanda | Default proposto | Stato / risposta |
|---|---|---|---|
| D-01 | Il bot è già in C#? Quale target framework? | quello del repo | **Risposto dal repo**: C#, `net10.0` (Bot e test `net10.0-windows`), SDK 10.0.301. Nessuna proposta di cambio. |
| D-02 | UI attuale: console, WinForms o WPF? Posso aggiungere un progetto WPF? | nuovo progetto WPF + headless | **Risposto dal repo**: è già WPF (`Encelado.Bot`, tema scuro proprio). Non si aggiunge un progetto: si aggiungono pagine alla shell esistente e la modalità `--headless` nello stesso eseguibile. |
| D-03 | Valuta del conto eToro e disponibilità di chiavi demo? | USD, demo | **Verificato via API** (collegamento MCP dell'utente, sola lettura): conto in **USD**; `demoCid` e `realCid` esistono. Le chiavi long-lived (`x-api-key` + `x-user-key`) non sono ancora state fornite al bot: la finestra di accesso le chiede e le salva cifrate (DPAPI). **Default applicato: USD, demo.** |
| D-04 | Regola di approvazione: automatismo consentito già in demo? | `DemoApprove` | **Default applicato: `DemoApprove`**. `DemoAuto` richiede `etoro.allowDemoAuto = true` in `encelado.json` e la conferma all'avvio (finestra, o `--confirm-demo-auto` in headless). Le modalità Live richiedono `etoro.allowLive = true` e la frase `CONFERMO LIVE`. L'utente ha chiesto una lunga sessione di test "sperando di piazzare trade": senza risposta il test lungo gira in `Paper` (simulatore locale sopra le quote reali) o in `DemoApprove` con approvazione manuale. |
| D-05 | Gli 8 strumenti sono disponibili sul conto? Spread tipici? | verifica via API | **Verificato via API il 2026-09-16 07:23 UTC**: tutti e 8 disponibili (id: EURUSD 1, USDCHF 6, AUDUSD 7, USDCAD 4, NZDUSD 3, EURNZD 49, EURAUD 12, AUDCAD 47; anche EURCHF 9 ed EURCAD 13 per `PreferDirectCross`). Spread di mercato osservati senza markup: 0,1 pip sulle majors, 0,3-0,7 pip sui cross. Il markup di eToro si legge dall'endpoint dei costi e viene sommato nel cost gate. Esposizione minima 1000 USD per posizione, leva fino a 30 (majors) / 20 (minors). **Attenzione**: il conto reale vale 193,18 USD; con `RiskPerBasket` 0,5 % e esposizione minima 1000 USD il reale non è operabile senza leva alta: il passaggio a `LiveApprove` resta comunque subordinato ai cancelli di §9.4. |
| D-06 | Dove gira il bot (PC locale Windows, VPS Windows)? | PC locale + headless pronto per VPS | **Default applicato**: Windows 11 locale (questa macchina); `--headless` disponibile per un VPS Windows. |
| D-07 | Esiste già uno storage/log da riusare? | nuovi file in `data/` | **Default applicato con una precisazione**: il log applicativo (`Log`, file `;`) e `CsvTable` vengono riusati; il ledger, i dati di mercato, i modelli e la base di conoscenza vanno in file (`data/`, `knowledge/`, `reports/`, `results/`) sotto `Documenti\Encelado\`, come richiesto. Il database SQLite esistente resta per il motore `proba` e non viene usato dal modulo basket. |
| D-08 | Se una fonte news/calendario risulta irraggiungibile: sostituire o omettere? | omettere e annotare | **Verificato il 2026-09-16**: calendario FairEconomy (JSON e XML), FXStreet, ForexLive, Fed, ECB (`https://www.ecb.europa.eu/rss/press.html`), BoE (`https://www.bankofengland.co.uk/rss/news`), RBA (`https://www.rba.gov.au/rss/rss-cb-media-releases.xml`), BoC (`https://www.bankofcanada.ca/content_type/press-releases/feed/`) e Google News rispondono 200. **SNB** (`/en/rss/press-releases` → 404) e **RBNZ** (403 "website unavailable") no: **default applicato: omesse**, coperte da Google News con query mirate (`SNB`, `RBNZ`). Annotato in `docs/DATA_SOURCES.md`. |
| D-09 | Che fare del motore cTrader/ProbaBot trovato a metà e non committato? | mantenerlo selezionabile | **Default applicato**: resta nel repo, rimesso in compilazione (riferimento di progetto e piccoli fix) e selezionabile con `engine.strategy = "proba"`; il predefinito diventa `"baskets"`. Nessun comportamento esistente viene cambiato. Se l'utente preferisce eliminarlo, basta rimuovere `src/Encelado.CTrader` e `Engine/ProbaEngine.cs`. |
| D-10 | Dove stanno i parametri della strategia: in `encelado.json` o in un file separato? | `config/strategy.json` come da specifica | **Default applicato**: `strategy.json` separato (copia di fabbrica in `config/`, copia dell'utente in `Documenti\Encelado\`), letto con `JsonDocument`; `instruments.json` scritto dal bot all'avvio nella stessa cartella. `encelado.json` riceve solo le sezioni `etoro` e `engine.strategy`. |
| D-11 | Fuso orario dei tick MT5 in `A:\Download\Trading`? | verificare sul fine settimana | **Verificato**: la chiusura del venerdì cade alle 20:53-20:57 in estate e alle 21:53-21:57 in inverno, la riapertura alle 21:05 (estate) / 22:05 (inverno) della domenica: è **UTC**. Nessuna conversione. Formato: tab-separato `<DATE> <TIME> <BID> <ASK> <LAST> <VOLUME> <FLAGS>`; le righe con solo bid o solo ask (flag 2/4) aggiornano un solo lato. |
| D-12 | Lo storico M15 via API eToro si può scaricare paginando? | sì, 1000 barre per richiesta | **Verificato: no.** L'endpoint delle candele accetta solo `count ≤ 1000` e la direzione, senza data di partenza: fornisce al massimo ~10 giorni di M15. Il backtest usa i tick forniti dall'utente; l'API serve per riscaldamento (ultime 1000 barre) e riconciliazione. |
| D-13 | Il TP di basket "in pip" con lotti diversi fra le gambe: pip lordi sommati come Titany, o P&L netto? | come da specifica | **Default applicato**: `Pips` di basket = somma dei pip delle due gambe (UI e `ExitMode = FixedPips`); ogni decisione di stop usa il P&L netto in USD; entrambi finiscono nel ledger. |
| D-14 | Le credenziali eToro per il bot: quando? | attendere | L'utente ha scritto: «Aspetta l'input per le credenziali per la prima volta e poi potrai aprirlo in autonomia quando memorizzerò la password». La finestra di accesso chiede `x-api-key` e `x-user-key` e li salva in `%LOCALAPPDATA%\Encelado\etoro.dat` (DPAPI). Finché non ci sono, il bot in headless resta in sola lettura e lo dice. |
## Fase 1 — 2026-09-16
| # | Domanda | Default proposto | Stato / risposta |
|---|---|---|---|
| D-15 | Leva da usare su ogni gamba (l'API la richiede per ordine)? | 10 | **Default applicato**: `orderLeverage = 10` (ammessa su tutte le 8 coppie); l'esposizione complessiva resta comunque ≤ 10:1 sul nozionale (`MaxEffectiveLeverage`) e lo stop nativo di eToro viene messo alla distanza coerente con `MaxLossPerBasket%`, dentro i limiti di eligibility. |
| D-16 | Overnight: usare il valore dell'endpoint dei costi o una tabella? | endpoint | **Default applicato**: l'endpoint dei costi (`overnightFee`, `overWeekendFee`) quando disponibile; in backtest una tabella configurabile per coppia (`overnightPipsPerDay`, default 0,3 pip/gamba/giorno, ×3 nel fine settimana). |
## Fasi 2-7 — 2026-09-16
| # | Domanda | Default proposto | Stato / risposta |
|---|---|---|---|
| D-17 | Lo spread anomalo (> 3 × mediana) deve chiudere il basket alla prima barra o dopo una persistenza? | persistenza | **Default applicato**: chiusura forzata solo dopo **3 barre chiuse consecutive** sopra la soglia. Nel backtest la chiusura immediata scattava sui picchi di spread e perdeva sistematicamente (`BasketPosition.BarsWithSpreadAnomaly`). |
| D-18 | Nel backtest l'equity stop blocca tutto per sempre o riparte? | riparte | **Default applicato**: dopo lo stop il picco riparte dall'equity corrente e il numero di stop viene contato (`EquityStops` nel riepilogo); altrimenti il primo stop del 2019 avrebbe fermato sette anni di prova. Dal vivo lo stop richiede il reset manuale. |
| D-19 | Fed risponde 404 e RBA "Access Denied" con lo User-Agent minimale: cambiare UA? | UA esplicito del bot | **Applicato**: `Encelado/4.0 (+correlation baskets; contact: operator)`. La Fed risponde; RBA (Akamai) a intermittenza. Dopo due errori consecutivi il feed logga solo a debug e ritenta con attese crescenti. |
| D-20 | Per il test lungo in demo: `DemoAuto` (bot autonomo) o `DemoApprove`? | DemoAuto | **Risposta dell'utente (2026-09-16 15:00)**: «tutti gli Approve devono sparire, almeno per il momento. Il bot deve girare in completa autonomia aprendo e chiudendo le posizioni senza il mio consenso». Modalità ridotte a `Paper`, `Demo`, `Live`; coda delle approvazioni rimossa (ADR-0005). Il Live conserva flag e frase `CONFERMO LIVE`. |
| D-21 | La pulizia delle «vecchie gestioni» deve includere anche cTrader/proba e la pipeline di ricerca? | sì, tutto | **Risposta dell'utente**: «Tutto: resta solo eToro + basket». Rimossi `Encelado.CTrader`, `Encelado.Storage`, ricerca, indicatori, RL, TA-Lib e i test relativi (ADR-0004). |
| D-22 | Versione del rilascio su Gitea? | 4.0.0 | **Risposta dell'utente**: 4.0.0 (nuovo broker, nuova strategia, configurazione incompatibile). |
| D-23 | Fuso orario della finestra: quello del computer o selezionabile? | computer, selezionabile | **Applicato**: `ui.timeZone` = `computer` di fabbrica; elenco dei fusi di Windows in Impostazioni; `ENCELADO_TIME_ZONE` da ambiente. Solo la finestra cambia: il log porta l'offset, il ledger è UTC. **Superata in parte dalla 5.1** (D-49): gli orari a schermo sono nel fuso del browser, con gli orologi delle valute; `ui.timeZone` resta nel file solo per gli orari scritti dal server (riga di stato) e non compare più in Impostazioni; `ENCELADO_TIME_ZONE` viene ignorata. |
| D-24 | L'endpoint dei costi restituiva markup e overnight a zero: era davvero zero? | verificare | **Verificato via API il 2026-09-16 12:45 UTC**: il campo si chiama `value`, non `amount`. EURUSD 10 000 unità leva 10: markup 0,0, spread di mercato 0,1 USD (0,1 pip), overnight 0,91 USD/giorno (≈ 0,9 pip/gamba/giorno). Parser corretto; aggiunto lo scenario di costi `api` al backtest. |
| D-25 | Google News vieta `/rss/search` nel robots.txt: forzare, sostituire o omettere? | omettere | **Default applicato: omettere** (il bot rispetta il robots.txt). SNB e RBNZ restano senza fonte; documentato in `KNOWN_ISSUES.md`. |
## Fase 0 della 5.0 — 2026-09-23
Domande del prompt «Encelado 5.0» (§15) più quelle emerse dalla verifica. D-26 e D-27 sono state verificate via API (sola lettura, collegamento MCP dell'utente) e non aspettano risposta. Le Fasi 1-5 hanno usato i default; D-28, D-29, D-36 e D-37 hanno avuto risposta il 2026-09-23 e le Fasi 6-9 sono state eseguite.
| # | Domanda | Default proposto | Stato / risposta |
|---|---|---|---|
| D-26 | Endpoint per leggere un ordine per `orderId` e mappa degli stati? | verifica sul portale | **Verificato via API il 2026-09-23**: `GET api/v2/trading/info/{demo/}orders:lookup?orderId=<id>` (stessa risposta del lookup per riferimento) e `GET api/v1/trading/info/{demo/}orders/{orderId}` (risposta v1: `statusID`, `positions[]`). Stati: 1 Received, 2 Placed, 3 Filled, 4 Rejected, 5 PartiallyFilled, 6 PendingCancel, 7 Canceled, 8 Expired, 9 CanceledPartiallyFilled, 10 RejectedPartiallyFilled, 11 WaitingForMarket, 12 PendingTriggeredRate. Eseguito = 3 o 5; rifiutato = 4, 7, 8, 9, 10; in corso = 1, 2, 6, 11, 12. **Il lookup per `referenceId` non funziona per gli ordini v2**: il server ha registrato `referenceID = 00000000-…` per gli ordini del bot (verificato su 381739181). Scritto in `docs/DATA_SOURCES.md`. |
| D-27 | Esiste un endpoint di cancellazione ordini? | no | **Sì, verificato**: `DELETE api/v2/trading/execution/{demo/}orders/{orderId}` (quota 20/min condivisa con gli ordini). Il 200 conferma solo la richiesta; l'esito si legge con il lookup: 7 o 9 = annullato, 6 = in corso. Il kill-switch lo usa e poi attende la risoluzione (≤ 30 s). |
| D-28 | Confermi il ritiro del progetto WPF a favore della web UI servita dal bot? | sì (ADR-0007) | **Risposta dell'utente (2026-09-23)**: «Sì, confermo: il bot deve essere eseguito SOLO tramite container. Elimina tutta la parte della grafica Windows». Applicata: progetto WPF rimosso, `Encelado.Engine` + `Encelado.Server`, interfaccia web Material 3, chiavi in file cifrato al posto di DPAPI, VS Code con F5 sul server (ADR-0007, ADR-0008). |
| D-29 | Registry per l'immagine e URL dell'icona del template Unraid? | Gitea (`build/gitea.example.json`), icona nel repo | **Risposta dell'utente (2026-09-23)**: «Per il registro useremo Gitea per il momento. L'icona non si può pubblicare da qualche parte su Gitea?». Applicata: immagine `192.168.30.23:3000/alby96/encelado:<versione>` sul registro dei container di Gitea (stesso token della release); icona `assets/encelado.png` servita da Gitea come file raw del repository (`Icon` del template). |
| D-30 | Confermi la disattivazione a runtime di MLP, bandit e ciclo settimanale? | sì (ADR-0006) | **Default applicato** (ADR-0006, 2026-09-23): il bandit propone e non applica (Fase 1); `learning.enabled = false` di fabbrica spegne ciclo settimanale e challenger e impedisce al cancello ML di attivarsi; la logistica resta in ombra. Il comando `learn` dello strumento arriva con la Fase 6. Resta aperta solo se vuoi il contrario. |
| D-31 | Token e chat ID Telegram via variabili d'ambiente? Comandi in ingresso o solo notifiche? | env; comandi attivi | **Default applicato** (Fase 5). **Superata dalla 5.1** (2026-09-30, D-48, ADR-0010): il token del bot si inserisce da Impostazioni ▸ Notifiche Telegram, viene verificato con `getMe` e vive cifrato in `secrets.enc`; la chat (`notifications.telegram.chatId`) si imposta nella stessa pagina. `TELEGRAM_BOT_TOKEN` e `TELEGRAM_CHAT_ID` di un container 5.0 vengono importati una volta al primo avvio della 5.1 e poi ignorati. I comandi in ingresso restano attivi (`notifications.telegram.commands`). |
| D-32 | Le posizioni esterne vanno chiuse dal kill-switch di default? | no | **Default applicato**: `risk.closeForeignOnKill = false`; la conferma del kill-switch ha la spunta «chiudi anche le esterne», deselezionata. Dalla 5.1 la spunta parte uguale all'impostazione e la scelta fatta nel dialogo vale per quel kill-switch (D-55). |
| D-33 | Valute del selettore oltre USD/EUR? | USD, EUR, GBP, CHF, JPY, AUD, CAD, NZD | **Default applicato** (Fase 7). Per GBP e JPY il polling aggiunge GBPUSD e USDJPY. Dalla 5.1 il selettore sta solo in Impostazioni ▸ Interfaccia (richiesta dell'utente), non nella barra in alto. |
| D-34 | Soglie di margine (40 % totale, 12 % per basket, buffer 25 %) e soglia di inattività (10 min)? | sì | **Default applicato** (Fasi 2 e 4), tutte in `strategy.json` e cambiabili dall'operatore. |
| D-35 | Le orfane sul demo: bonifica con conferma o chiusura manuale? | bonifica con conferma | **Superata dai fatti**: il 2026-09-23 il conto demo ha 0 posizioni e 0 ordini; le 21 gambe del bot sono state chiuse in blocco il 21/9 alle 13:26 UTC (chiusura manuale, non del bot). La bonifica resta come comando (`--bonifica`, e pulsante in Diagnostica) per il futuro e non ha niente da chiudere oggi. |
| D-36 | Il ledger delle sessioni 16-21/9 (65 `segnale_ingresso`/`rifiuto`) non è su questa macchina: `Documenti\Encelado\data\ledger\decisions.jsonl` ha solo il 16/9. Su quale macchina o profilo ha girato il bot? Puoi copiare qui `decisions.jsonl`, `baskets_state.json` e `learning_state.json` di quella sessione? | procedere con le evidenze dell'API | **Risposta dell'utente (2026-09-23)**: allegato il bundle della cartella dati dell'installazione 4.0.0. Letto: 1 813 righe dal 16/9 15:55 al 22/9 08:01, 65 `segnale_ingresso` e 65 `rifiuto` con motivazione «esito non ancora noto», preset AGGRESSIVE impostato dalla finestra, quattro run; `baskets_state.json` con `killSwitched = true` («kill-switch dalla finestra») e picco 149 552. L'equity registrata sale da 109 228 a 149 517 USD in circa ventuno scatti di ≈ +2 000 USD, uno per ogni esecuzione ridotta dal server: gli «accrediti» erano crediti virtuali del demo per ordine, non depositi. Post-mortem aggiornato. |
| D-37 | Confermi che la chiusura in blocco del 21/9 alle 13:26 UTC l'hai fatta tu dalla piattaforma? | sì | **Risposta dell'utente (2026-09-23)**: «Sì, l'ho fatta io». Chiuso. |
## 5.1 — 2026-09-30
Domande nate dalle modifiche chieste in `Modifiche.txt` del 2026-09-30 (D-38…D-52) e dalla revisione della 5.1 del 2026-09-30/10-01 (D-53…D-58). L'utente ha scritto «fai domande se hai dei dubbi»: nessuna scelta era bloccante, quindi è stato applicato il default più prudente, e ognuna resta **in attesa di conferma del proprietario** finché non arriva una risposta.
| # | Domanda | Default proposto | Stato / risposta |
|---|---|---|---|
| D-38 | «P&L oggi» deve essere il realizzato delle posizioni chiuse oggi o la variazione dell'equity dalla mezzanotte (realizzato più aperto)? | realizzato | **Default applicato** (2026-09-30): il valore grande è il realizzato netto (`netProfit − fees`) delle posizioni del bot chiuse nella giornata UTC, dallo storico eToro (uguale al periodo «oggi» della pagina Storico; le posizioni esterne non contano); accanto c'è la variazione dell'equity netta da mezzanotte. La giornata è quella UTC, come il ledger. In attesa di conferma del proprietario. |
| D-39 | Il nome della variabile della password: `ENCELADO_PASSWORD` va bene? | sì | **Default applicato** (2026-09-30), con `ENCELADO_WEB_TOKEN` accettato come alias perché il container 5.0.0 resti raggiungibile dopo l'aggiornamento (con valori diversi vince `ENCELADO_PASSWORD`). In attesa di conferma del proprietario. |
| D-40 | I segreti (chiavi eToro, token Telegram) sono cifrati con una chiave ricavata dalla password: cambiare la password obbliga a sbloccarli con quella vecchia o a reinserirli. Va bene? | sì | **Default applicato** (2026-09-30, ADR-0010). Alternativa scartata: una chiave salvata su `/config`, che equivale al chiaro per chi legge la share. In attesa di conferma del proprietario. |
| D-41 | Nel template restano la porta e le due cartelle `/config` e `/data`? | sì | **Default applicato** (2026-09-30): non sono impostazioni ma collegamenti del container; senza, configurazione e ledger si perderebbero a ogni aggiornamento. PUID/PGID (99/100) e TZ (lo aggiunge Unraid) tolti. In attesa di conferma del proprietario. |
| D-42 | Passare da Demo a Live (o viceversa) con basket o ordini aperti? | rifiutato | **Default applicato** (2026-09-30): rifiutato finché il conto in uso non è piatto (si chiude, anche con il kill-switch, o si aspetta lo storico). Dalla revisione il controllo lo fa il motore sul suo thread e lo stato è per conto (D-53). In attesa di conferma del proprietario. |
| D-43 | Un cambio di preset o di strategia con basket aperti? | vale per i nuovi | **Default applicato** (2026-09-30): i basket aperti conservano z di stop, aggiunte massime, TP, perdita massima e preset con cui sono entrati. In attesa di conferma del proprietario. |
| D-44 | Avvio automatico del motore all'avvio del container? | sì, disattivabile | **Default applicato** (2026-09-30): impostazione `run.autostart` (attiva). In modalità Live il motore non parte mai da solo. In attesa di conferma del proprietario. |
| D-45 | Il Live si conferma anche da riga di comando (`--confirm-live`)? | no | **Default applicato** (2026-09-30): la frase si scrive solo nell'interfaccia; `--confirm-live` ed `ENCELADO_CONFIRM_LIVE` non esistono più. In attesa di conferma del proprietario. |
| D-46 | Le righe storiche del ledger con `mode = Paper`? | restano | **Default applicato** (2026-09-30): il ledger non si modifica; non contano per i 300 basket in Demo di ADR-0006. In attesa di conferma del proprietario. |
| D-47 | Quali parametri di `strategy.json` mostrare in Impostazioni? | tutti, a gruppi | **Default applicato** (2026-09-30): preset, basket attivi, rischio e sicurezza, cancelli, apprendimento, recupero; indicatori e sovrascritture del preset nel gruppo «Avanzate», chiuso. In attesa di conferma del proprietario. |
| D-48 | Le variabili della 5.0.0 già presenti nel container? | importate una volta, poi ignorate | **Default applicato** (2026-09-30): al primo avvio chiavi, token e chat vanno nel deposito cifrato e nel file (le chiavi nell'ordine della 5.0: ambiente, poi file, poi `etoro.keys.enc`); le impostazioni solo se diverse dal valore di fabbrica. Poi vengono ignorate e segnalate in Sistema: si possono togliere dal container. In attesa di conferma del proprietario. |
| D-49 | Orologi: quali fusi? | uno per paese delle valute | **Default applicato** (2026-09-30): Nuova Zelanda, Australia, Europa centrale/Svizzera, USA/Canada orientale, con le bandiere; il fuso del PC compare solo se diverso da tutti (Europe/Rome coincide con l'Europa centrale). L'ora UTC resta nei tooltip. In attesa di conferma del proprietario. |
| D-50 | Versione del rilascio? | 5.1.0 | **Default applicato** (2026-09-30): la minor successiva (regola della catena); la configurazione vecchia viene letta e migrata. `Directory.Build.props` porta 5.1.0. In attesa di conferma del proprietario. |
| D-51 | Dati sbagliati scritti dalla 4.0.0/5.0.0 (P&L delle chiusure): correggerli? | sì, con righe di correzione | **Default applicato** (2026-09-30, ADR-0011): righe `correzione` in `decisions.jsonl`, modelli ritirati e riaddestrati sulle etichette corrette, bandit dal prior. I messaggi Telegram già inviati non si possono correggere. In attesa di conferma del proprietario. |
| D-52 | Raggiunta la perdita giornaliera, le entrate restano bloccate fino a mezzanotte UTC anche se l'equity risale? | sì | **Default applicato** (2026-09-30, il più prudente, ed è la regola scritta in `RISK_RULES.md`): il blocco di nuove entrate e aggiunte resta fino alle 00:00 UTC, nel motore e nel backtest; il giorno del blocco è nello stato del conto e sopravvive a un riavvio. Sostituisce il comportamento della prima 5.1, che rivalutava la regola a ogni decisione. In attesa di conferma del proprietario. |
| D-53 | Lo stato del motore (basket, chiusure in attesa del P&L, picco, flussi di cassa, blocchi, residui, pausa, giornata della perdita giornaliera) è uno solo o uno per conto? | uno per conto | **Default applicato** (2026-09-30, decisione della revisione): `data/state/baskets_state.demo.json` e `baskets_state.live.json` al posto di `baskets_state.json`. Un cambio di conto non sovrascrive né scarta niente dell'altro conto: tornando lo si ritrova com'era. Il file unico della versione precedente va una volta sola al suo conto e resta come `.migrato`: per la prima 5.1 il conto del suo `mode`; per la 5.0, dove `mode` era la modalità, il conto su cui operava la configurazione della 5.0, registrato dall'importazione (seconda revisione, 2026-10-01: un `Live` accanto a `demo` finiva al conto reale); Paper o una modalità diversa non vengono ripresi. `pending_orders.json` resta un file solo e ogni ordine porta il suo conto (`mode`): un motore non risolve, non fa fallire e non pota quelli dell'altro conto. La guardia del cambio è un comando sul thread di decisione (blocca le entrate, riconcilia con il conto, poi conta basket occupati, ordini, orfane e residui, chiusure in attesa), rifiutata mentre il motore si avvia o si ferma e ricontrollata sul disco dopo l'arresto: se fallisce i file delle impostazioni tornano come prima e niente parte. A motore fermo decide il file del conto in uso. In attesa di conferma del proprietario. |
| D-54 | Un calo del saldo che lo storico eToro non spiega ancora (forse un prelievo) conta come perdita giornaliera? | blocca senza chiudere la giornata | **Default applicato** (2026-10-01): sospende subito nuove entrate e aggiunte (`dailyLossHit` senza `dailyLossLatched`, con un testo proprio in dashboard, Telegram e console), ma la giornata si blocca fino alle 00:00 UTC solo sulla perdita che resta anche se tutto quel calo fosse un prelievo; la lettura che lo spiega blocca il resto. La sospensione resta finché lo storico non spiega il calo, anche se intanto l'equity recupera, e quella lettura giudica la giornata sull'equity più bassa vista nel frattempo: una perdita la blocca anche se l'equity è risalita, un movimento di cassa (prelievo o deposito) mai (seconda revisione, 2026-10-01). Così un prelievo non blocca la giornata e una perdita non sfugge. In attesa di conferma del proprietario. |
| D-55 | Kill-switch con posizioni esterne: vale la casella del dialogo o l'impostazione `risk.closeForeignOnKill`? | la scelta esplicita | **Default applicato** (2026-10-01): la casella del dialogo parte uguale all'impostazione e la scelta fatta lì vince (l'interfaccia manda sempre `foreign` esplicito); senza scelta (Telegram `/kill`, file `STOP`) vale l'impostazione; la console chiede solo se ci sono posizioni esterne e propone l'impostazione come risposta di partenza. La nota `kill_switch_avviato` dice chi ha deciso (`esterne_da`). In attesa di conferma del proprietario. |
| D-56 | Dopo una password errata: un'attesa per tutto il server o per indirizzo? Il cookie conta come tentativo? | per indirizzo; no | **Default applicato** (2026-10-01): ogni password errata (form, `Authorization: Bearer`) costa al suo indirizzo (IPv6: il /64) un'attesa di 1, 2, 4, 8, 16, poi 30 s; il cookie non è un tentativo (seconda revisione: contato come tale, una scheda rimasta aperta dopo un cambio di password teneva l'indirizzo in attesa e la password giusta riceveva 429): contiene un segreto del server (`/config/session.key`), quindi non si calcola da una password indovinata; valido entra anche durante l'attesa, sbagliato riceve 401 subito; durante l'attesa nessuna password di quell'indirizzo viene controllata, nemmeno quella giusta (429), così i tentativi in parallelo non danno informazioni. Non globale: un altro computer della rete non deve poter tenere fuori l'operatore dal kill-switch. Una password giusta azzera il conto, dieci minuti senza errori lo dimenticano. Dietro un reverse proxy l'attesa vale per tutti i client che il proxy fa sembrare uno. In attesa di conferma del proprietario. |
| D-57 | Fuori dal container (F5, `run-dev`) con la password impostata, il server si apre alla rete? | no | **Default applicato** (2026-10-01): la password di F5 e degli script (`sviluppo`) serve ai segreti della sandbox, non ad aprire il PC alla rete; il server ascolta su tutte le interfacce solo nel container o con l'argomento `--listen-all`. In attesa di conferma del proprietario. |
| D-58 | FERMA (o un salvataggio che riavvia il motore) mentre è in corso un kill-switch, una chiusura o la chiusura dei residui? | rifiutato | **Default applicato** (2026-10-01): 409 con il motivo, da ripetere quando è concluso; un kill-switch tagliato a metà lascerebbe posizioni senza nessuno che le guardi. AVVIA subito dopo FERMA aspetta che il motore precedente abbia lasciato la cartella dati. Solo l'arresto del processo (`docker stop`) interrompe un kill-switch in corso, dopo 30 s, e registra il residuo (Halted-Residuo). In attesa di conferma del proprietario. |
+57
View File
@@ -0,0 +1,57 @@
# Regole di sicurezza e approvazione
Aggiornato: 2026-10-01 (5.1). Tutte le regole di §10 della specifica, con il valore di fabbrica, dove sta e chi può cambiarlo. «Operatore» è chi usa Impostazioni nell'interfaccia (o, a mano, i file in `/config`); «codice» vuol dire che non esiste una chiave di configurazione. Dalla 5.1 ogni impostazione si cambia dall'interfaccia e il bot la applica subito quando può (ADR-0010).
| Regola | Default | Dove | Chi la cambia |
|---|---|---|---|
| Modalità di esecuzione = conto | `Demo` (conto demo di eToro: ordini veri, denaro virtuale) | `encelado.json` → `run.executionMode` (`Demo`, `Live`; Impostazioni ▸ Conto). La modalità sceglie anche il conto: `Demo` = conto demo, `Live` = conto reale. `Paper` non esiste più (un file che la nomina si legge come `Demo` con un avviso) | operatore; `Live` richiede `run.allowLive = true` **e** la frase `CONFERMO LIVE` scritta nell'interfaccia a **ogni** avvio (dialogo di AVVIA) e prima di ogni cambio che riavvia il motore in Live. Nessuna variabile d'ambiente e nessun argomento da riga di comando la sostituiscono. **Il Live non parte mai da solo**: né all'avvio del container né dopo un riavvio automatico (allarme «LIVE: premi AVVIA» e avviso Telegram «Live: motore fermo»; le posizioni aperte hanno nel frattempo solo gli stop nativi) |
| Cambio di conto (Demo ↔ Live) | rifiutato finché il conto in uso non è piatto | codice (guardia C8, D-42, D-53) | nessuno. Conta come «non piatto»: basket aperti o in attesa di una gamba, ingressi, aggiunte o uscite in corso, basket in errore con una gamba sul conto, ordini senza esito, gambe orfane del bot o residui del kill-switch, chiusure in attesa dello storico eToro (al più 30 minuti). A motore acceso il controllo lo fa il motore sul suo thread di decisione: prima blocca nuove entrate e aggiunte, poi riconcilia con il conto (una gamba del bot che nessuno slot tiene conta come orfana; posizioni non lette: rifiutato), poi conta; se il conto è libero le entrate restano bloccate fino al riavvio sull'altro conto, altrimenti il blocco si toglie. Rifiutato anche mentre il motore si avvia (finché il ciclo di decisione non è partito), mentre si ferma o se non risponde entro 30 s. Dopo l'arresto il file del conto lasciato viene giudicato di nuovo: se non è piatto (o nel frattempo è partito un kill-switch) `encelado.json` e `strategy.json` tornano byte per byte come prima e niente riparte. A motore fermo decide il file di stato del conto in uso. Lo stesso controllo vale per un cambio delle coppie dei basket |
| Stato per conto | uno per conto | `data/state/baskets_state.demo.json`, `baskets_state.live.json` (D-53) | nessuno. Basket aperti, ingressi in sospeso, chiusure in attesa del P&L, picco di equity, flussi di cassa, equity stop, kill-switch e residuo, pausa dell'operatore e giornata della perdita giornaliera sono **del conto**: un cambio non li sovrascrive né li scarta, e tornando sull'altro conto li si ritrova. Un conto i cui basket nessuno ha seguito oltre `recovery.thresholdMinutes` (il bot girava sull'altro) riceve il recupero dopo inattività |
| Approvazione dei singoli ordini | nessuna, in nessuna modalità (D-20, ADR-0005) | codice | nessuno. Il bot apre, aggiunge e chiude da solo; i gate umani sono l'avvio del reale, il kill-switch e il reset dopo un kill-switch o un equity stop |
| Preset | `Moderate` | `strategy.json` → `preset` (Impostazioni ▸ Strategia) | operatore. Fa parte della strategia e resta fisso: non esiste più un comando per cambiarlo a caldo (né dall'interfaccia, né dalla console, né da Telegram). Un cambio vale per i basket **nuovi**: quelli aperti conservano z di stop, aggiunte massime, TP, perdita massima e preset con cui sono entrati (D-43). Il bandit lo propone soltanto |
| Equity stop | 9 % dal picco di equity | `strategy.json` → `equityStopPct` | operatore; scatta → chiude tutto, blocca, richiede il reset con motivazione scritta (Sblocca… nell'interfaccia, `reset <motivo>` da console, `/reset <motivo>` da Telegram), che finisce nel ledger; il picco riparte dall'equity del reset |
| Perdita giornaliera massima | 3 % dell'equity netta di inizio giornata (UTC). Formula (la stessa nel motore e nel backtest, `DailyLoss.IsHit`): `E₀ − E ≥ E₀ × dailyLossPct / 100`, dove `E = equity − cassa cumulata` è l'**equity netta** attuale (realizzato e aperto insieme, depositi e prelievi esclusi) ed `E₀` l'equity netta alla prima lettura del conto dopo le 00:00 UTC. Un deposito non nasconde una perdita, un prelievo non la inventa. «P&L oggi» è un'altra cosa: il realizzato netto (`netProfit − fees`) delle posizioni del bot chiuse oggi, dallo storico eToro; accanto c'è la «variazione dell'equity netta da mezzanotte» `E − E₀`, che è ciò che la regola guarda. Fino alla 5.0.0 la regola sommava i proceeds delle chiusure e non scattava mai dopo la prima chiusura del giorno | `strategy.json` → `dailyLossPct` | operatore. **Raggiunta una volta, niente nuove entrate né aggiunte fino alle 00:00 UTC, anche se l'equity recupera** (D-52; `DailyLossLatch` nel motore, `ReplayDailyLoss` nel backtest, stessa regola); non chiude niente e non richiede reset. Si giudica a ogni lettura del conto e a ogni decisione. Il giorno del blocco è nello stato del conto (`dailyLossDay`): un riavvio nello stesso giorno lo mantiene, il nuovo giorno UTC lo toglie. Un calo del saldo che lo storico eToro non spiega ancora (forse un prelievo) sospende subito le entrate finché non si chiarisce, anche se intanto l'equity recupera, ma blocca la giornata solo quando risulta una perdita: la lettura che lo spiega la giudica sull'equity più bassa vista nel frattempo (D-54) |
| Rischio per basket | 0,25 / 0,50 / 1,00 % (preset) | `strategy.json` → preset o `riskPerBasketPct` (Impostazioni ▸ Strategia ▸ avanzate) | operatore; vale per i basket nuovi |
| Perdita massima per basket | 1,5 % dell'equity all'ingresso | `strategy.json` → `maxLossPerBasketPct` | operatore; mai disattivabile; fissata in USD all'ingresso (un basket aperto tiene il limite con cui è entrato) |
| Stop di basket su z | 3,0 / 3,5 / 4,0 (preset) | `strategy.json` → preset o `zStop` | operatore; mai disattivabile (solo il backtest lo spegne, nel test di falsificazione 3); un basket aperto tiene lo z di stop con cui è entrato |
| Basket aperti | 2 / 3 / 5 (preset) | `strategy.json` → preset o `maxBaskets` | operatore |
| Un solo basket per cross sintetico | `Exclusive` | `strategy.json` → `sameCrossPolicy` | operatore (`Half` dimezza la size di entrambi) |
| Leva effettiva massima | 10:1 sul nozionale complessivo | `strategy.json` → `maxEffectiveLeverage` | operatore, tetto 30 |
| Margine per basket | il margine delle due gambe (nozionale / leva dell'ordine) ≤ **12 %** dell'equity; la size è il **minimo** fra la size a rischio e quella a margine e il ledger scrive quale vincolo ha deciso (`sizing_bound`) e il margine previsto (`marginUsd`) | `strategy.json` → `risk.maxMarginPerBasketPct` | operatore |
| Margine totale | margine impegnato dopo l'apertura ≤ **40 %** dell'equity | `strategy.json` → `risk.maxMarginUsePct` | operatore |
| Buffer di cassa | `available ≥ (marginA + marginB) × 1,25` prima di inviare A (entra nel calcolo della size); `available ≥ marginB × 1,25` ricontrollato con A già sul conto prima di inviare B, altrimenti A viene richiusa (`leg_risk_unwind`) | `strategy.json` → `risk.marginBufferPct` | operatore |
| Esposizione minima | se la size a margine scende sotto i 1000 USD di esposizione minima di eToro su una gamba, niente ingresso (`min_exposure`) | codice + eligibility | nessuno |
| Ordine dei segnali | più segnali sulla stessa barra vengono eseguiti uno alla volta per \|z\| decrescente, rileggendo il conto prima di ciascuno: il secondo basket vede il margine impegnato dal primo | codice | nessuno |
| Margin guard | `equity / margine usato < 1,5` → niente nuove entrate (`margin_guard`); `< 1,2` → chiusura del basket con il P&L peggiore (riga `margin_guard` nel ledger) | `strategy.json` → `risk.marginCallBlockRatio`, `risk.marginCallCloseRatio` | operatore |
| Leva dichiarata per gamba | 10 | `strategy.json` → `orderLeverage` | operatore; la leva effettiva resta governata dal sizing |
| Stop nativo su ogni gamba | sì, sempre (eToro lo richiede su short e leva > 1) | codice (`BasketExecutor.Request`) | nessuno; la distanza deriva da `maxLossPerBasketPct` entro i limiti di eligibility |
| Cost gate | TP ≥ 3 × costo; spread ≤ 2 × mediana 24 h | `strategy.json` → `costMultiple`, `spreadMedianMultiple` | operatore |
| Spread anomalo | > 3 × mediana per 3 barre chiuse consecutive → chiusura forzata | `strategy.json` → `spreadAnomalyMultiple` (persistenza: codice) | operatore (moltiplicatore) |
| Blackout eventi | 45 min prima, 30 dopo, eventi High sulle valute del basket | `strategy.json` → `blackoutBeforeMin`, `blackoutAfterMin` | operatore |
| Fine settimana | niente entrate dal venerdì 20:00 UTC alla riapertura, né nei primi 30 min | `strategy.json` → `fridayCutoffUtcHour`, `openDelayMinutes` | operatore |
| Scarto orologio | > 5 s → banner e niente nuove entrate | `strategy.json` → `clockSkewMaxSeconds` | operatore; misurato sull'header `Date` di ogni risposta |
| API in errore | 5 letture consecutive fallite → niente nuove entrate finché non risponde | codice | nessuno |
| Quotazione vecchia | > 15 s → niente nuove entrate | codice (`BasketEngine.MaxQuoteAgeSeconds`) | nessuno |
| Qualità dati | buco > 2 h feriale o salto > 8 σ → decisioni sospese su quella barra | codice | nessuno |
| Leg-risk | seconda gamba **rifiutata** → chiudi subito la prima (`leg_risk_unwind`), basket in pausa 1 h. Seconda gamba **senza esito** entro `legTimeoutSec` (5 s) → basket in `PendingB`: il registro degli ordini continua a chiedere; eseguita → basket aperto; rifiutata → prima gamba richiusa | `strategy.json` → `legTimeoutSec` (pausa: codice) | operatore (timeout) |
| Ordine dall'esito ignoto | mai abbandonato: registrato in `data/state/pending_orders.json` **prima** dell'invio, con il suo conto (`mode`); esito chiesto per `orderId` (ogni 2 s nel primo minuto, poi ogni 10 s, poi ogni minuto) e riconosciuto anche dalla posizione comparsa sul conto (stesso strumento e verso, entro 90 s); una gamba A senza esito porta il basket in `PendingA` (nessun nuovo ordine su quel basket); all'avvio i pendenti del conto si risolvono prima di qualsiasi decisione; un motore non tocca gli ordini dell'altro conto | codice (ADR-0009) | nessuno |
| Gamba A eseguita in ritardo | segnale ancora valido e nessun blocco → gamba B (ridimensionata sulle unità eseguite di A); altrimenti chiusura immediata di A (`leg_risk_unwind`) | codice | nessuno |
| Gamba orfana del bot | una gamba di un basket sparisce dal conto → l'altra viene chiusa alla riconciliazione successiva. Una posizione che porta la firma del bot (id nel registro, oppure strumento + verso + orario entro 90 s da una riga `segnale_ingresso`/`rifiuto`/`ingresso`/`pending` del ledger) ma non appartiene a nessun basket è `orfana-bot`: **adottata e chiusa** (tre tentativi, poi entrate bloccate con avviso). Contatore «orfane» in dashboard, rosso se > 0 | codice; `--bonifica` all'avvio la elenca e chiede conferma per ognuna | operatore (bonifica) |
| Una posizione, una riga | ogni posizione chiusa finisce in `baskets.csv` una volta sola, da qualunque percorso la veda chiudersi (uscita del basket, residuo del kill-switch, riconciliazione, orfana richiusa); le gambe di un basket rimaste nel residuo di un kill-switch diventano una riga sola, come basket (`exit_reason = kill_switch`), quando sono tutte chiuse | codice | nessuno |
| Movimenti di cassa | un salto del saldo non spiegato dalle chiusure (oltre 10 USD e 0,25 %) è un deposito o un prelievo: scritto nel ledger come `movimento_di_cassa`, escluso dal P&L, dal picco di equity e dal drawdown. Finché lo storico eToro non mostra una chiusura, il saldo non viene giudicato; dopo un'ora una posizione sparita che lo storico ancora non mostra non trattiene più il giudizio | codice (`EquityTracker`) | nessuno |
| Saldo all'avvio | il saldo salvato si confronta con quello nuovo (chiusure contro movimenti di cassa) solo quando lo storico eToro mostra **ogni** posizione chiusa da allora (sparite dal conto, sparite senza verdetto, chiusure in attesa); altrimenti il saldo salvato resta il riferimento e giudica la riconciliazione che le vede (limite di un'ora): una chiusura non ancora nello storico non viene mai scritta come prelievo | codice (`StartupCash`) | nessuno |
| Posizioni non riconciliate | se il P&L aperto del conto e la somma delle posizioni non tornano (oltre 5 USD e 1 %) per più di 60 s, o un basket ha una gamba che il conto non mostra: avviso «posizioni non riconciliate» (striscia degli allarmi, riga di stato) | codice | nessuno |
| Chiusura incompleta | una gamba non chiude dopo 3 tentativi → stato `Error`, entrate bloccate, allarme | codice | nessuno; si risolve a mano sul conto e con la riconciliazione |
| Kill-switch | pulsante KILL con conferma, `kill` da console, `/kill CONFERMO` da Telegram, file `STOP` nella cartella della configurazione (`/config` nel container; controllato ogni 5 s): blocco delle entrate, annullamento degli ordini senza esito (attesa ≤ 30 s), chiusura di **tutte le posizioni del bot** (basket, gambe in attesa, orfane; tre tentativi per gamba), **verifica di piattezza** sul conto (≤ 120 s); ciò che resta è `Halted-Residuo` con l'elenco, e nessuna dichiarazione di «tutto chiuso» senza la verifica. Posizioni esterne: la scelta **esplicita** vince (la casella del dialogo, che parte uguale a `risk.closeForeignOnKill`; la risposta della console, che chiede solo se ce ne sono); senza scelta (Telegram `/kill`, file `STOP`) vale l'impostazione (D-55). Un kill-switch in corso **non viene mai interrotto** da FERMA o da un riavvio automatico (409, D-58); solo l'arresto del processo lo interrompe, dopo 30 s, e registra il residuo (riga `kill_switch_interrotto`, stato `Halted-Residuo`) | codice (ADR-0009, ADR-0012) | operatore |
| Chiusura all'arresto | spenta: FERMA e lo spegnimento del container lasciano i basket sul conto con gli stop nativi (nessuno applica TP e stop di basket finché il bot non riparte) | `encelado.json` → `run.closeOnShutdown` (Impostazioni ▸ Esecuzione) | operatore. Accesa: il motore, sul suo thread di decisione, blocca prima nuove entrate e aggiunte, poi chiude basket, gambe in attesa e orfane, al più in 30 s; poi si ferma comunque. Un riavvio automatico dopo un cambio delle impostazioni non chiude mai niente |
| Comandi critici | un kill-switch, una chiusura (`close`), la chiusura dei residui o una chiusura della bonifica in coda o in corso non vengono interrotti da FERMA, né da un salvataggio delle impostazioni o delle chiavi che riavvierebbe il motore: rispondono 409 prima di scrivere niente. Contano finché il motore li ha in mano, anche se chi li ha chiesti ha smesso di aspettare (scheda chiusa, 504 dopo 120 s, Telegram spento) | codice (ADR-0012) | nessuno |
| Recupero dopo inattività | oltre `recovery.thresholdMinutes` (10) senza heartbeat o senza cicli: entrate bloccate, ordini pendenti risolti, riconciliazione, riscaldamento con le barre perse, ogni basket aperto rivalutato con le regole di uscita ordinarie (con le barre di inattività nel time-stop) → chiudi o tieni; orfane chiuse, esterne riportate; rapporto `reports/recupero_<run_id>.csv`; entrate riaperte dopo `recovery.warmupMinutes` (15); a mercato chiuso niente di irreversibile | `strategy.json` → `recovery` | operatore |
| Una sola istanza | `data/state/instance.lock` tenuto in esclusiva: un secondo bot sulla stessa cartella dati non parte; lo prendono anche il ciclo di apprendimento a motore fermo e `backtest learn` | codice | nessuno |
| Ripristino | procedura in cinque passi: stato, rimozione del file `STOP`, motivazione ≥ 10 caratteri (`correzione`), riconciliazione + riscaldamento + picco di equity al netto dei movimenti di cassa, ripartenza con entrate bloccate per `recovery.warmupMinutes`; rifiutato (`reset_rifiutato`) finché una posizione del bot resta sul conto | codice | operatore |
| Posizioni esterne | posizioni senza la firma del bot: segnalate una volta nel log, contate in dashboard, **mai toccate**, salvo dal kill-switch con la scelta esplicita o con `risk.closeForeignOnKill` (vedi sopra) | codice | operatore |
| Chiavi API e token Telegram | solo in `/config/secrets.enc` (AES-256-GCM, chiave PBKDF2-SHA256 600 000 iterazioni dalla password dell'interfaccia), inserite e verificate da Impostazioni (Conto, Notifiche Telegram); mai nel repo, nel log, in `encelado.json` o nell'ambiente. Un'intestazione con meno di 100 000 o più di 10 000 000 iterazioni è un file danneggiato, bloccato senza derivare la chiave. Password cambiata → deposito bloccato: sblocco con la precedente o ripartenza con un `.bak`. L'importazione una tantum dalla 5.0 prende le chiavi nell'ordine ambiente, chiavi scritte nel file, vecchio `etoro.keys.enc` | codice (ADR-0010) | operatore |
| Accesso all'interfaccia | password `ENCELADO_PASSWORD` (alias deprecato `ENCELADO_WEB_TOKEN`); cookie `encelado_session`, un HMAC della password e di un segreto del server (`/config/session.key`), Bearer per gli script. Ogni password errata (form o Bearer) costa al suo indirizzo un'attesa di 1, 2, 4, 8, 16, poi 30 s; durante l'attesa le richieste di quell'indirizzo con una password ricevono 429 (D-56); un cookie valido entra comunque, uno sbagliato riceve 401 subito. Le richieste che cambiano qualcosa sotto `/api/` devono dire `Content-Type: application/json` (415) e venire dalla stessa origine (`Origin`, `Sec-Fetch-Site`: 403); senza password il server risponde solo a un `Host` locale (403 altrimenti). Rete: su tutte le interfacce solo con la password, nel container o con `--listen-all` (D-57); altrimenti solo localhost | codice (ADR-0010) | operatore (la password, nel template del container) |
| Ambiente visibile | pill del motore `DEMO`/`LIVE` nella barra in alto (LIVE su fondo rosso), nel log e nel ledger (`mode`) | codice | nessuno |
| Controlli all'avvio | segreti leggibili e chiavi del conto della modalità, profilo, orologio, strumenti e limiti, conto, verifica del realizzato sullo storico, riconciliazione, calendario | codice | nessuno; se falliscono il bot resta in sola lettura o non parte, e l'interfaccia dice perché |
| Averaging | `Off` di fabbrica; `AddOnce` e `Grid` ammessi; moltiplicatore di lotto 1,0 (niente martingala) | `strategy.json` → `averagingMode`, `lotMultiplier` (in sola lettura in Impostazioni; fino a 1,5 solo nel backtest) | operatore |
| Parametri cambiati dal bot | mai. Le proposte vanno in `knowledge/proposals.csv` e passano dal forward test. Dalla 5.0 anche il bandit **propone soltanto**: fino alla 4.0.0 applicava il preset da solo (D-30) | codice | operatore |
+217
View File
@@ -0,0 +1,217 @@
# Runbook
Aggiornato: 2026-10-01 (5.1). Come si avvia, si ferma, si sblocca e si ripara il bot. Il bot gira nel container (`docs/DOCKER.md`, `deploy/unraid/`): i file dell'operatore stanno in `/config` (configurazione, segreti cifrati, file `STOP`) e `/data` (ledger, stato, log). Dalla 5.1 **tutto si imposta dall'interfaccia** (ADR-0010): nel container c'è solo la password. Fuori dal container, solo per lo sviluppo, valgono la sandbox `deploy/local/` (o `Documenti\Encelado`) e le stesse regole.
## Prima volta
1. Avvia il container (template Unraid o `docker run`, vedi `docs/DOCKER.md`) con la sola variabile `ENCELADO_PASSWORD` («Password interfaccia»: una frase lunga a piacere). Al primo avvio vengono creati `encelado.json` e `strategy.json` in `/config` dalle copie di fabbrica.
2. Apri `http://<ip>:8080/` e scrivi la password (resta in un cookie per trenta giorni).
3. **Impostazioni ▸ Conto**: il conto è `Demo` di fabbrica. Nella scheda delle chiavi del conto demo incolla `x-api-key` e `x-user-key` (dal portale sviluppatori eToro; demo e reale hanno chiavi diverse) e premi **Verifica e salva**: il server le prova con due letture (profilo e saldo) su quel conto e le salva cifrate in `/config/secrets.enc` con la password dell'interfaccia. Le chiavi del conto reale si inseriscono nella loro scheda, quando servono.
4. Controlla il resto quando vuoi: valuta e tema in Impostazioni ▸ Interfaccia, preset e rischio in Strategia, Telegram in Notifiche Telegram (vedi sotto). Ogni cambio si applica subito.
5. Premi **AVVIA** (⏻ in alto a destra). Con «Avvio automatico» acceso (Impostazioni ▸ Esecuzione, di fabbrica) dal riavvio successivo del container il motore parte da solo; al primo avvio, senza chiavi, non può partire e la striscia degli allarmi dice «SENZA CHIAVI: Nessuna chiave eToro salvata».
## Aggiornare un container 5.0 alla 5.1
Passo per passo in `deploy/unraid/README.md`. In breve:
1. Al **primo avvio della 5.1** tieni le variabili della 5.0 come sono: chiavi eToro (`ETORO_API_KEY`/`ETORO_USER_KEY`, o il vecchio `/config/etoro.keys.enc` con `ENCELADO_KEY_PASSPHRASE`), token e chat Telegram e le impostazioni diverse dal valore di fabbrica vengono importati **una volta** nel deposito cifrato e in `encelado.json` (il log dice «importazione una tantum dalla 5.0: …»; `/config/import-5.1.json` lo ricorda). Il vecchio `etoro.keys.enc` diventa `etoro.keys.enc.migrato`.
2. **Rinomina `ENCELADO_WEB_TOKEN` in `ENCELADO_PASSWORD` con lo stesso valore**: la password resta quella, e i segreti cifrati con lei restano leggibili. `ENCELADO_WEB_TOKEN` funziona ancora come alias, con un avviso.
3. Dopo il primo avvio togli le altre variabili dal container: da lì in poi sono **ignorate** e la striscia degli allarmi e Sistema ▸ Segreti le elencano («puoi toglierla dal container»).
4. Il primo avvio sposta lo stato del motore nel file del suo conto (`data/state/baskets_state.json` → `baskets_state.demo.json` o `.live.json`, l'originale resta come `.migrato`): il conto è quello su cui operava la configurazione della 5.0 (un `Live` con `etoro.environment` demo era il conto demo); lo stato della modalità Paper, o scritto con un'altra modalità, non viene ripreso e il log lo dice («non ripreso: …»): le posizioni si riconciliano dal conto, verifica sullo storico eToro il realizzato delle righe della 4.0.0-5.0.0 (righe `correzione`, «verifica del realizzato» nel log) e, se ne ha corrette, ritira una volta i modelli addestrati sui proceeds (`data/models/ritirati/…`). Poi: **Esegui ciclo** nella pagina Apprendimento, per rigenerare calibrazione e intuizioni sulle etichette corrette, e in `knowledge/proposals.csv` segna `respinta` le proposte nate dalle etichette sbagliate (la pagina le segnala con «basato su dati sospetti»).
5. Se la password cambia (anche per sbaglio), i segreti risultano **bloccati**: vedi «Segreti».
## Sviluppo sul PC
Per vedere e provare il bot senza Unraid: **F5** in VS Code (`Encelado (server)`), `scripts\run-dev.ps1` o `scripts\run-docker.ps1` (il container dalla compose). Tutti usano la sandbox `deploy/local/` come `/config` e `/data` e la password `sviluppo`, così i segreti salvati da Impostazioni valgono in tutti e tre i modi (dettagli in `docs/DOCKER.md`). F5 e `run-dev` restano **su localhost** anche con la password (la password serve ai segreti della sandbox); per raggiungerli da un altro PC serve l'argomento `--listen-all`. Con `--sample` (o `Encelado (campione)`, `run-dev -Sample`) il server mostra dati d'esempio in cartelle temporanee: non tocca la sandbox, i segreti, Telegram né `Documenti\Encelado`, e ogni comando o salvataggio risponde «modalità dimostrativa».
## Modalità e conto
| Modalità | Conto e ordini | Avvio |
|---|---|---|
| `Demo` (default) | conto demo eToro: ordini veri, denaro virtuale | AVVIA, o da solo con «Avvio automatico» |
| `Live` | conto reale | `run.allowLive` («Consenti il conto reale», Impostazioni ▸ Conto) **e** la frase `CONFERMO LIVE` scritta nel dialogo di AVVIA, a **ogni** avvio. Il Live **non parte mai da solo**: dopo un riavvio del container il motore resta fermo, la striscia degli allarmi dice «LIVE: premi AVVIA» e Telegram manda «Live: motore fermo»; nel frattempo i basket aperti hanno solo gli stop nativi |
`Paper` non esiste più (un file della 5.0 che la nomina si legge come `Demo`, con un avviso). La modalità è anche il conto: `Demo` lavora sul conto demo con le sue chiavi, `Live` sul reale con le sue. In ogni modalità il bot apre e chiude da solo (D-20). La pill del motore nella barra in alto dice sempre su che conto sei: `DEMO` con il bordo accento, `LIVE` su fondo rosso; il pallino dice lo stato (verde in esecuzione, grigio fermo, ambra in avvio o arresto, pausa, entrate bloccate, recupero, perdita giornaliera, heartbeat in ritardo; rosso in errore o bloccato).
### Cambiare conto (Demo ↔ Live)
Da Impostazioni ▸ Conto. Il cambio è **rifiutato** (409, niente salvato) finché sul conto in uso c'è qualcosa in sospeso, e il messaggio dice cosa e cosa fare:
| Cosa blocca | Cosa fare |
|---|---|
| basket aperti o in attesa di una gamba, ingressi, aggiunte o uscite in corso, basket in errore con una gamba sul conto | chiudili (chiudi basket, o il kill-switch), oppure aspetta che l'ingresso finisca |
| ordini senza esito | aspetta che il registro li risolva (Storico ▸ Ordini) |
| gambe orfane del bot o residui del kill-switch | «Chiudi residui» / bonifica, poi riprova |
| chiusure in attesa dello storico eToro | con il motore acceso aspetta (al più 30 minuti); con il motore fermo avvialo su quel conto perché le regoli |
| il motore si sta avviando (finché il ciclo di decisione non è partito: verifica, riscaldamento, riconciliazione), si sta fermando, o non risponde entro 30 s | riprova fra poco |
Con il motore acceso è il motore stesso a controllare, dopo aver bloccato le nuove entrate (nella striscia «cambio di conto verso … in corso» per qualche secondo) e riletto le posizioni del conto (una gamba del bot rimasta sola conta come orfana; se eToro non risponde il cambio è rifiutato: riprova); poi si ferma senza chiudere niente e riparte sull'altro conto (in Live con la frase). Se dopo l'arresto il conto lasciato risulta non piatto (un ingresso finito all'ultimo, un kill-switch partito nel frattempo, FERMA), il salvataggio viene **annullato** — `encelado.json` e `strategy.json` tornano come prima — e il messaggio lo dice: il motore resta fermo (premi AVVIA) o acceso sul conto di prima. **Ogni conto ha il suo stato** (`baskets_state.demo.json`, `baskets_state.live.json`): basket, blocchi, residui, pausa, picco, chiusure in attesa e giornata della perdita giornaliera dell'altro conto non vengono toccati, e tornando lo si ritrova com'era. Se i basket di un conto sono rimasti senza nessuno che li seguisse oltre `recovery.thresholdMinutes`, al ritorno parte il recupero dopo inattività.
## Impostazioni
Ogni campo ha un'icona che dice quando vale: ⚡ subito (log, interfaccia, Telegram), ⚙ nel motore in esecuzione, senza riavvio (strategia, intervalli, timeout; riga `configurazione` nel ledger), ↻ con un riavvio automatico del motore, che **non chiude** i basket (conto, chiavi del conto in uso, coppie dei basket, «Legge anche i cross diretti»). «Salva (n)» manda solo i campi cambiati e l'esito di ognuno compare accanto. In Live un cambio che riavvia il motore chiede prima la frase `CONFERMO LIVE`. Un salvataggio che riavvierebbe il motore mentre è in corso un kill-switch, una chiusura o la chiusura dei residui è rifiutato (409): ripeti quando è concluso. Se nel frattempo hai premuto FERMA, i valori vengono salvati e valgono al prossimo avvio. Il preset si sceglie in Strategia e vale per i basket nuovi: quelli aperti tengono z di stop, aggiunte, TP, perdita massima e preset con cui sono entrati. **Valori predefiniti ▸ Ripristina** (a motore fermo) rimette `encelado.json` di fabbrica, con un backup datato accanto.
## Segreti
Le chiavi eToro dei due conti e il token Telegram stanno solo in `/config/secrets.enc`, cifrati con la password dell'interfaccia; mai nel log, nel file di configurazione o nell'ambiente.
- **Chiavi**: Impostazioni ▸ Conto, una scheda per conto, «Verifica e salva» (le prova su quel conto) e «Rimuovi» (a motore fermo, o del conto non in uso). Nuove chiavi del conto in uso con il motore acceso lo riavviano (Live: con la frase). La verifica dura fino a 25 s: se intanto il conto è cambiato, le chiavi vengono salvate e riavviano il motore solo se sono del conto su cui lavora ora (in Live solo con la frase; senza, il messaggio dice di premere FERMA e poi AVVIA).
- **Token Telegram**: Impostazioni ▸ Notifiche Telegram, verificato con `getMe`; «Invia messaggio di prova».
- **Segreti bloccati** (la password del container è cambiata, o il file è danneggiato): striscia rossa «SEGRETI BLOCCATI», il motore non parte. In Impostazioni ▸ Conto: **Sblocca con la password precedente** (decifra con la vecchia e ricifra con quella attuale), oppure **Ricomincia** (deposito vuoto; il vecchio file resta come `secrets.enc.<data>.bak`) e reinserisci chiavi e token.
- Senza password (solo sviluppo su localhost) la chiave è un file casuale `secrets.key`; quando una password compare, i segreti vengono ricifrati con lei e il file sparisce.
## Accesso all'interfaccia
- La password si scrive una volta nella pagina di accesso; «Esci» (Impostazioni ▸ Interfaccia o Sistema) toglie il cookie. Cambiare la password del container chiude tutte le sessioni (e blocca i segreti: vedi sopra); anche cancellare `/config/session.key` (il segreto del server nel cookie) le chiude. Dopo l'aggiornamento alla 5.1 serve un nuovo accesso.
- Dopo una password errata (pagina di accesso o `Authorization: Bearer`) l'indirizzo che l'ha mandata aspetta 1 s, poi 2, 4, 8, 16, fino a 30 s per ogni errore di fila; nel frattempo un'altra password da lì riceve «Troppi tentativi… riprova fra N secondi» (429), anche quella giusta. Una pagina già entrata non aspetta, e una scheda rimasta aperta dopo un cambio di password torna da sola alla pagina di accesso senza far aspettare nessuno.
- Dagli script: `Authorization: Bearer <password>` e, per ogni POST o DELETE sotto `/api/`, `Content-Type: application/json` anche senza corpo (altrimenti 415), per esempio `curl -X POST -H "Authorization: Bearer $PASSWORD" -H "Content-Type: application/json" http://<ip>:8080/api/commands/pause`.
- Dietro un reverse proxy il proxy deve passare l'`Host` originale o `X-Forwarded-Host`, altrimenti ogni comando riceve 403 (`docs/DOCKER.md`, «Rete»).
## Console e comandi
Il processo stampa il log su stdout (`docker logs -f encelado`) e una riga di stato ogni `run.statusSeconds`. Con un terminale collegato (`docker attach`, o il processo lanciato a mano) accetta comandi da tastiera: `status`, `close <basket>`, `kill` (chiede delle posizioni esterne solo se ce ne sono, con l'impostazione come risposta di partenza), `residuo [id]`, `bonifica`, `reset <motivazione>`, `stop`. Gli stessi comandi esistono nell'interfaccia (pulsanti e dialoghi) e in Telegram. Il preset non è un comando: si sceglie in Impostazioni ▸ Strategia. Argomenti: `--no-autostart`, `--minutes N` (arresto automatico), `--bonifica`, `--port N`, `--listen-all` (fuori dal container, la rete con la password), `--sample`, `--health`.
**Una sola istanza per cartella dati**, imposta dal lock `data/state/instance.lock`: un secondo processo sulla stessa cartella viene rifiutato con il pid del primo; lo stesso lock lo prendono il ciclo di apprendimento a motore fermo e `backtest learn`.
## Fermare
- **FERMA** (⏻ verde, con conferma), `stop` da console, `docker stop` (SIGTERM, 45 s di grazia), Ctrl+C. I basket aperti **restano sul conto** con gli stop nativi (`run.closeOnShutdown = false`): nessuno applica TP e stop di basket finché il bot non riparte, che li riprende dallo stato del conto e dalla riconciliazione (e, se è passato più di dieci minuti, con il recupero dopo inattività).
- Con «Chiudi i basket all'arresto» (`run.closeOnShutdown = true`) il motore, sul suo thread, blocca prima nuove entrate e aggiunte e poi chiude basket, gambe in attesa e orfane, al più in 30 s; poi si ferma comunque.
- **FERMA durante un kill-switch, una chiusura o la chiusura dei residui** risponde 409 («kill-switch in corso…»): ripeti quando è concluso. Vale anche se la scheda che l'ha lanciato è stata chiusa, se la risposta è stata 504 dopo 120 s o se Telegram è stato spento nel frattempo: il motore lo porta a termine comunque. `docker stop` invece non aspetta oltre 30 s: un kill-switch ancora in corso viene interrotto, le posizioni del bot rimaste diventano il residuo (Halted-Residuo, riga `kill_switch_interrotto`) e al riavvio si chiudono con «Chiudi residui» o un nuovo kill-switch, poi il reset.
- **AVVIA subito dopo FERMA** aspetta che il motore precedente abbia lasciato la cartella dati (lo stato resta «in arresto» per qualche secondo).
## Kill-switch
Quattro modi: il pulsante **KILL** nella barra in alto (attivo con il motore in esecuzione; chiede conferma, con il fuoco su «Annulla», e la casella «Chiudi anche le posizioni esterne»), `kill` da console, `/kill CONFERMO` da Telegram, oppure un file chiamato `STOP` nella cartella `/config` (controllato ogni 5 s; utile da remoto: `touch /mnt/user/appdata/encelado/config/STOP`). **Posizioni esterne**: la casella del dialogo parte uguale a «Il kill-switch chiude anche le posizioni esterne» (Impostazioni ▸ Strategia, spenta di fabbrica) e la scelta fatta lì è quella che succede; Telegram e il file `STOP` usano l'impostazione; la console chiede solo se ce ne sono. La procedura è la stessa per tutti e **non dichiara niente chiuso senza averlo riletto dal conto**:
1. blocco immediato di ogni nuova entrata, riga `kill_switch_avviato` nel ledger (con chi ha deciso sulle esterne);
2. annullamento degli ordini nel registro senza esito (`DELETE …/orders/{id}`), poi attesa della loro risoluzione fino a 30 s: un ordine eseguito nel frattempo diventa una posizione da chiudere;
3. chiusura di **tutte le posizioni del bot**: gambe dei basket (tre tentativi per gamba con verifica sul conto), gambe in attesa, orfane-bot; le esterne secondo la scelta;
4. verifica di piattezza: il conto viene riletto finché le posizioni del bot non sono sparite (fino a 120 s);
5. riga `kill_switch_concluso` con l'esito, stato salvato, notifica.
Se qualcosa resta sul conto lo stato è **`Halted-Residuo`**: striscia rossa «Kill-switch con residuo» con **Chiudi residui**, il reset è rifiutato finché non è piatto. Per riprovare: «Chiudi residui», `residuo` da console (`residuo <id>` per una sola posizione), oppure chiusura a mano su eToro; la riconciliazione se ne accorge e un residuo che il conto non mostra più esce dall'elenco. Le gambe di un basket rimaste nel residuo diventano una riga sola di `baskets.csv`, come basket, quando sono tutte chiuse. Il blocco resta finché non fai un **reset**. Un kill-switch in corso non viene interrotto da FERMA né da un salvataggio delle impostazioni.
## Equity stop e perdita giornaliera
Quando l'equity (al netto dei movimenti di cassa) scende del 9 % dal picco (`equityStopPct`) il bot chiude tutto e si blocca: striscia rossa, riga `equity_stop` nel ledger. Per ripartire serve il reset.
La **perdita giornaliera** del 3 % (`dailyLossPct`, sull'equity netta dalla mezzanotte UTC) blocca solo le nuove entrate e le aggiunte, **fino alle 00:00 UTC anche se l'equity recupera, anche dopo un riavvio**; non chiude niente e non richiede reset (D-52). La tessera della dashboard diventa rossa con l'ora di sblocco nel tuo fuso, la striscia degli allarmi lo dice e Telegram manda un avviso. Se il saldo cala per qualcosa che lo storico eToro non spiega ancora (forse un prelievo) le entrate restano sospese finché non si chiarisce, anche se nel frattempo l'equity recupera; quando lo storico lo spiega, se era una perdita e al minimo toccato nel frattempo l'equity netta era oltre la soglia la giornata si blocca fino alle 00:00 UTC, se era un movimento di cassa (prelievo o deposito) no.
## Ripristino (reset) in cinque passi
**Sblocca…** nella striscia degli allarmi o **Ripristino…** in Sistema, `reset <motivazione>` da console, `/reset <motivazione>` da Telegram. Il reset è una procedura, non un interruttore; il dialogo mostra i cinque passi e l'esito di ciascuno, che finisce anche nel ledger:
| Passo | Che cosa fa | Se fallisce |
|---|---|---|
| 1. stato | riporta il motivo del blocco, i residui, gli ordini senza esito, le entrate bloccate | — |
| 2. file STOP | lo rimuove da solo; se ricompare il kill-switch riparte | «file STOP non rimovibile»: permessi della cartella `/config` (PUID/PGID) |
| 3. motivazione | almeno dieci caratteri, scritta nel ledger come `correzione` | «motivazione mancante»: riscrivila |
| 4. riconciliazione | rilegge il conto, verifica che nessuna posizione del bot sia rimasta, riscalda le serie dall'API, riporta il picco di equity all'equity corrente (al netto dei movimenti di cassa) | «residui ancora sul conto» → resta `Halted-Residuo` (riga `reset_rifiutato`): chiudili con «Chiudi residui» / `residuo` / a mano e ripeti |
| 5. ripartenza | toglie il blocco; **entrate bloccate per 15 minuti** di riscaldamento (`riscaldamento dopo il reset` nella striscia), poi il bot riprende da solo | — |
Sintomo → passo:
| Sintomo | Passo da guardare |
|---|---|
| «Kill-switch con residuo» nella striscia | 4: chiudi i residui, poi ripeti il reset |
| «rimuovi prima il file STOP» / «file STOP non rimovibile» | 2: `/config` non è scrivibile dall'utente del container o il file viene ricreato da un altro processo |
| «motivazione mancante» | 3 |
| dopo il reset il bot non apre per un quarto d'ora | 5: è il riscaldamento voluto |
| dopo il reset compare «posizioni non riconciliate» | 4 non è andato a buon fine sul conto: confronta `pending_orders.json` e le posizioni su eToro (pagina Posizioni) |
## Ordini senza esito
eToro lavora gli ordini in modo asincrono e a volte non risponde al lookup. Il bot non dimentica mai un ordine: ogni invio è scritto in `data/state/pending_orders.json` **prima** della chiamata, con il suo conto; l'esito viene chiesto per `orderId` e, se il server non lo trova, ricostruito dalla posizione comparsa sul conto. Un basket con una gamba senza esito compare in dashboard come «Attesa A/B» e nel contatore «in attesa»: non manda altri ordini finché il registro non lo risolve. Alla risoluzione: gamba A eseguita e segnale ancora valido → parte la gamba B; segnale decaduto → la gamba A viene richiusa subito (`leg_risk_unwind`); rifiutata → il basket torna libero. Se un ordine resta senza esito per più di dieci minuti il log lo ripete ogni dieci minuti: guarda Storico ▸ Ordini (esito `Pending`) o Posizioni ▸ ordini in attesa e, se serve, la posizione su eToro; non c'è niente da fare a mano finché la gamba non compare sul conto, e quando compare il bot la gestisce. All'avvio i pendenti del conto vengono risolti prima di qualsiasi decisione; quelli dell'altro conto aspettano il suo motore.
## Riconciliazione
Ogni 20 secondi il bot rilegge conto e posizioni e **classifica ogni posizione**: `basket` (gamba nota), `orfana-bot` (aperta dal bot ma senza basket: id nel registro degli ordini, oppure strumento, verso e orario coerenti con una decisione del ledger entro 90 s), `esterna` (tutto il resto). Una gamba di basket sparita dal conto (chiusa a mano, stop nativo) fa chiudere l'altra; un'orfana-bot viene **adottata e chiusa** (righe `orfana_adottata` e `orfana_chiusa` nel ledger, riga in `baskets.csv` con `exit_reason = orphan_closed`; dopo tre tentativi falliti le entrate si bloccano e la striscia lo dice: chiudila a mano su eToro); un'esterna viene segnalata una volta, contata e mai toccata. Una chiusura incompleta dopo tre tentativi mette il basket in stato `Error` e blocca le nuove entrate finché non è risolta sul conto. Se il P&L aperto del conto e quello delle posizioni non tornano per più di un minuto compare «posizioni non riconciliate»: di solito è un'esecuzione in corso; se persiste, confronta `pending_orders.json` con le posizioni su eToro (pagina Posizioni).
Un deposito o un prelievo sul conto (anche l'accredito di fondi virtuali del demo) viene riconosciuto dal salto del saldo non spiegato dalle chiusure e scritto nel ledger come `movimento_di_cassa`: non è P&L, non muove il picco di equity né il drawdown; nello Storico compare come riga «movimento di cassa» e nei periodi è una colonna a parte. Finché lo storico eToro non mostra una chiusura il saldo non viene giudicato, e all'avvio il saldo salvato si confronta solo quando lo storico mostra ogni posizione chiusa da allora: una chiusura in ritardo non diventa mai un prelievo.
## P&L oggi e realizzato
«P&L oggi» (dashboard, barra in alto, Telegram, console) è il **realizzato netto** (`netProfit − fees`) delle posizioni del bot chiuse nella giornata UTC, letto dallo storico di eToro: è lo stesso numero del periodo «oggi» della pagina Storico. Finché lo storico non conferma una chiusura il numero porta la sua **stima** (segnata «stima»); se lo storico non è ancora stato letto si vede «—», mai 0. Accanto c'è la variazione dell'equity netta da mezzanotte, che è ciò che guarda la perdita giornaliera. Ogni riga di `baskets.csv` porta il realizzato dello storico (motivazione «P&L: storico eToro»), oppure, se dopo 30 minuti lo storico non lo mostra ancora, la stima («P&L: stima…», che non addestra niente e viene ricontrollata a ogni avvio). Fino alla 5.0.0 il bot registrava come P&L i `proceeds` della chiusura (margine restituito più profitto): da lì il «P&L oggi» di circa 47 000 USD su 139 000; il ledger è corretto con righe nuove, i messaggi Telegram e i log di allora no (`docs/KNOWN_ISSUES.md`).
## Recupero dopo inattività (riavvio, aggiornamento dell'immagine, container fermo)
Il bot scrive `data/state/heartbeat.json` ogni 30 s (`recovery.heartbeatSeconds`). All'avvio legge quello precedente e a ogni ciclo misura il tempo dall'ultimo giro: oltre `recovery.thresholdMinutes` (10) parte il **recupero**, nell'ordine: entrate bloccate e riga `recupero_avviato`; ordini senza esito risolti; riconciliazione con classificazione (le orfane si chiudono, le esterne si riportano); serie riscaldate dall'API con le barre perse e `barsHeld` di ogni basket aperto aumentato delle barre trascorse; ogni basket aperto rivalutato come a una chiusura di barra ordinaria (stop di z, perdita massima, time-stop con le barre di inattività, correlazione rotta, spread anomalo): **chiudi** o **tieni**; rapporto `reports/recupero_<run_id>.csv` (una riga per posizione: `posizione;basket;decisione;motivo;z;rho;barsHeld;pnl;motivazione`), riga `recupero_concluso`, notifica; entrate riaperte dopo `recovery.warmupMinutes` (15) di quotazioni. Lo stesso recupero parte per un conto i cui basket nessuno ha seguito oltre la soglia mentre il bot girava sull'altro. Se il mercato è chiuso (fine settimana) il recupero aspetta le prime quotazioni fresche e lo dice ogni dieci minuti: niente di irreversibile a mercato chiuso. Un recupero fallito lascia le entrate bloccate con il motivo: guarda il log e fai un reset.
## Telegram
Tutto da **Impostazioni ▸ Notifiche Telegram**: «Telegram attivo», il token del bot (verificato con `getMe` e cifrato in `secrets.enc`), la chat (`chatId`, la sola che riceve i messaggi e può dare comandi), «Stato ogni ora», «Eventi», l'ora del riepilogo giornaliero (UTC, negativo = spento), «Comandi dalla chat», e **Invia messaggio di prova**. Ogni cambio vale subito (il canale e il poller dei comandi si accendono, si spengono o cambiano senza riavvio). Per creare il bot: `@BotFather` → `/newbot` → token; per il chat id: scrivi al bot e leggi `chat.id` da `https://api.telegram.org/bot<token>/getUpdates`, oppure `@userinfobot`. Cosa arriva:
- **stato ogni ora** (allo scoccare dell'ora UTC): attivo/fermo/bloccato, modalità, preset, uptime, equity/saldo/disponibile/margine, P&L di oggi (dallo storico, «—» se sconosciuto) e aperto (conto e basket), drawdown dal picco, basket aperti con z/pip/P&L/durata, in attesa, ordini pendenti, orfane, esterne, blocchi, prossimo evento, stato API e quote, stato del canale;
- **eventi**: avvio e arresto del bot, basket aperto e chiuso (il messaggio di chiusura arriva quando lo storico eToro conferma il P&L, o con la stima dopo 30 minuti), gamba in attesa, ordine pendente risolto, unwind, gamba orfana, kill-switch (con esito e residui), equity stop, perdita giornaliera («niente nuove entrate fino alle 00:00 UTC»), margin guard, recupero dopo inattività, reset, cambio delle impostazioni, Live da confermare, API in errore persistente, scarto orologio;
- **riepilogo giornaliero** all'ora impostata (21 UTC): basket chiusi, vinti, lordo, costi, netto, drawdown, motivi di uscita (le righe non verificate sono escluse e contate a parte).
Comandi accettati **solo dalla chat autorizzata** (ogni altro mittente viene ignorato e annotato nel log; ogni comando eseguito finisce nel ledger come `comando`): `/stato`, `/posizioni`, `/storico 7d` (anche `1d`, `30d`), `/pausa` (blocca le entrate, le uscite restano attive; sopravvive a un riavvio), `/riprendi`, `/chiudi <basket>`, `/kill CONFERMO` (senza la parola non fa niente; le esterne secondo l'impostazione), `/reset <motivazione>` (almeno dieci caratteri); tutto il resto risponde «comando non riconosciuto». Il polling usa un solo task con `getUpdates` e non tocca le quote di eToro; gli invii sono al massimo uno al secondo con tre tentativi (2, 5, 15 s; su 429 rispetta `retry_after`). Sistema ▸ Telegram riporta lo stato del canale (configurato, inviati, in coda, falliti, ultimo invio, ultimo errore).
## Bonifica delle gambe orfane
Una tantum, dopo un'anomalia: la pagina **Posizioni** mostra ogni posizione del conto con origine, P&L e motivo della classificazione e, quando ci sono orfane del bot, **Bonifica orfane** (una conferma per posizione); **Sistema ▸ Diagnostica ▸ Elenca le orfane** fa lo stesso elenco; oppure `--bonifica` all'avvio (il motore parte senza chiudere le orfane da solo e chiede `chiudere? [s/N]` da console) o `bonifica` da console. Ogni chiusura confermata scrive una riga in `baskets.csv` (`exit_reason = bonifica_orfana`, P&L dallo storico) e in `reports/bonifica_YYYYMMDD.csv`. Alla fine il bot torna a chiudere le orfane da solo.
## Apprendimento
La pagina **Apprendimento** mostra tutto ciò che il sistema sa (dataset, criteri di attivazione, pesi, bandit, ultimo ciclo, calibrazione, proposte; `docs/ML_AND_LEARNING.md`). **Esegui ciclo**:
- motore acceso: il ciclo parte in background e la pagina ne mostra la fase; il motore continua a lavorare e applica il risultato fra due tick;
- motore fermo o in errore: manutenzione che prende il lock della cartella dati; **AVVIA risponde 409** finché dura, di solito pochi secondi;
- rifiutato (409, con il motivo) con un ciclo già in corso, con il motore che si avvia (finché il ciclo di decisione non è partito) o si ferma, o con il lock tenuto da un altro processo.
`backtest learn` sulla cartella dati del bot prende lo stesso lock o si rifiuta con il nome di chi lo tiene: con il bot acceso si usa «Esegui ciclo». Niente di ciò che il ciclo propone cambia i parametri: le proposte vanno in `knowledge/proposals.csv` e passano dal forward test.
## Errori API
| Sintomo | Cosa fa il bot | Cosa fare |
|---|---|---|
| 401/403 da eToro | avvio fallito, «eToro ha rifiutato le chiavi» | rigenera le chiavi sul portale e reinseriscile da Impostazioni ▸ Conto |
| «nessuna chiave eToro per il conto …» | il motore non parte | inserisci le chiavi di quel conto in Impostazioni ▸ Conto |
| «segreti bloccati» | il motore non parte | Impostazioni ▸ Conto: sblocca con la password precedente o ricomincia |
| 429 | rispetta `Retry-After`, rallenta | niente; se persiste alza «Lettura quotazioni ogni» (`run.pollSeconds`) |
| 5 letture consecutive fallite | entrate bloccate, uscite attive | aspetta; controlla rete e stato di eToro |
| scarto orologio > 5 s | allarme, entrate bloccate | sincronizza l'ora dell'host (il container eredita l'orologio) |
| quotazioni più vecchie di 15 s | niente nuove entrate | come sopra |
| storico eToro illeggibile | «P&L oggi» resta «—» o con le stime; le chiusure aspettano in coda; nessun saldo giudicato | niente; se dura ore controlla la quota Default in Sistema |
| `/api/health` rosso (`docker inspect`) | il container viene riavviato da `--restart` se il processo muore; un healthcheck rosso con processo vivo dice cosa manca (heartbeat più vecchio di 3 × `recovery.heartbeatSeconds` + 15 s, 105 s di fabbrica; disco non scrivibile) | `docker logs`, poi `docker restart`; un kill-switch lungo può far risultare il container non sano per qualche minuto |
Sistema mostra il dettaglio: stato del motore, collegamento eToro con latenza, scarto e quote (con i 429 e l'ultimo errore), feed, Telegram, segreti, processo, disco, log.
## Feed
Calendario e notizie sono in cache su disco (`data/cache`) e vengono riletti **in background** ogni 10 minuti, con attese crescenti dopo un errore; il ciclo di decisione non li aspetta mai, e il processo li tiene aggiornati anche a motore fermo. Un feed che non risponde non ferma il bot: senza calendario non c'è blackout, senza notizie il sentiment è 0, e il log lo dice. Sistema ▸ Feed mostra lo stato di ogni fonte. Google News blocca via `robots.txt` le ricerche RSS: quelle fonti vivono solo di cache (vedi `docs/DATA_SOURCES.md`).
## Storico
Pagina **Storico**: *Ordini* da `orders.jsonl` (unità richieste ed eseguite — se differiscono il server ha ridotto l'ordine —, prezzi, slippage, stato, esito, id di ordine e posizione), *Posizioni* dallo storico eToro classificate per origine, *Profitti per periodo* con la curva del realizzato. Ogni vista si esporta in CSV (`;`, colonna `motivazione`). Senza chiavi la pagina mostra solo i dati del ledger e lo dice.
## File utili
| Cosa | Dove (container) |
|---|---|
| log | `/data/logs/encelado.log` (CSV `;`) e `docker logs` |
| ledger | `/data/data/ledger/decisions.jsonl` (e i mesi ruotati `decisions_YYYYMM.jsonl`), `baskets.csv`, `orders.jsonl` |
| stato | `/data/data/state/baskets_state.demo.json` e `baskets_state.live.json` (uno per conto, ripreso all'avvio; il vecchio `baskets_state.json` resta come `.migrato`), `pending_orders.json` (registro degli ordini dei due conti), `heartbeat.json`, `instance.lock` |
| barre | `/data/data/market/candles_<SYMBOL>_M15.csv` |
| modelli | `/data/data/models/` (con `last_cycle.json`, `learning_state.json`, `ritirati/`) |
| conoscenza | `/data/knowledge/` |
| rapporti | `/data/reports/` (qualità dati, bonifica, recupero) |
| configurazione, strumenti, segreti, STOP | `/config/encelado.json`, `strategy.json`, `instruments.json`, `secrets.enc`, `import-5.1.json`, `STOP` |
Fuori dal container gli stessi percorsi stanno sotto la sandbox `deploy/local/` (`config/`, `data/`) o `Documenti\Encelado`.
## Checklist prima del Live (§9.4 della specifica)
Tutte vere, altrimenti no:
- [ ] il forward test in Demo ha almeno 60 basket chiusi e 90 giorni;
- [ ] il P&L netto del forward test (realizzato dello storico eToro) è positivo con PSR ≥ 0,95 sulla metrica pre-registrata in `knowledge/preregistrazione.csv`;
- [ ] nessun test di falsificazione contraddice il risultato (oggi `reports/falsificazione.csv` dice il contrario: vedi `docs/STRATEGY.md`);
- [ ] chiavi del conto reale inserite e verificate in Impostazioni ▸ Conto, «Consenti il conto reale» acceso, conto `Live` (il cambio richiede il conto demo piatto);
- [ ] conto reale capiente rispetto a `riskPerBasketPct` e all'esposizione minima di 1000 USD per gamba (con 224,90 USD non lo è);
- [ ] la frase `CONFERMO LIVE` scritta nel dialogo di AVVIA, ogni volta: il Live non riparte mai da solo dopo un riavvio.
## Aggiornare
`docker pull` dell'immagine nuova e riavvio del container (su Unraid: *Controlla aggiornamenti*). `/config` e `/data` restano; il riavvio è un'inattività come le altre e passa dal recupero (in Live il motore resta fermo fino ad AVVIA con la frase). Dalla 5.0 alla 5.1 vedi «Aggiornare un container 5.0 alla 5.1» qui sopra e `deploy/unraid/README.md`. Se dopo un aggiornamento il log segnala una configurazione di una versione precedente, da Impostazioni ▸ Valori predefiniti **Ripristina** (backup automatico con la data accanto al file, a motore fermo) e poi rimetti i valori tuoi.
+44
View File
@@ -0,0 +1,44 @@
# Stato del lavoro
Aggiornato: 2026-10-01 (5.1.0 completata nel codice e nei documenti; da spingere, rilasciare e provare sul conto demo).
## Fase in corso
**5.1 conclusa nel repository.** Le richieste dell'utente di `Modifiche.txt` del 2026-09-30 sono implementate (solo la password nel container, tutto dall'interfaccia e applicato a caldo, Paper eliminata, «P&L oggi» corretto dallo storico eToro, nuova interfaccia in stile Mimante con la pagina Apprendimento, orologi con le bandiere, log su una riga), poi una revisione completa del codice ha trovato 51 problemi e i confermati sono corretti. Versione di sviluppo **5.1.0** (`Directory.Build.props`). Una seconda verifica indipendente delle correzioni ha trovato nove punti ancora aperti, corretti anche loro; la verifica finale prima del rilascio è passata. Build 0 avvisi, 0 errori; **561 test verdi**. Decisioni in ADR-0010…ADR-0014; scelte fatte senza risposta in `docs/QUESTIONS.md` D-38…D-58, **in attesa di conferma del proprietario**.
**Non ancora fatto**: push del ramo, immagine 5.1.0 sul registro di Gitea e release (l'utente l'ha chiesto: «pusha il codice, crea l'immagine e caricala nella repository»), installazione su Unraid e prova sul conto demo. L'ultimo rilascio pubblicato resta la 5.0.0 (2026-09-23).
## Fatto nell'ultima sessione (2026-09-30 / 2026-10-01)
Commit in ordine (tutti su `main`, non spinti):
- `9cb5882` — **realizzato dallo storico eToro**: `proceeds` mai P&L, coda di regolamento persistente, «P&L oggi» dallo storico con le stime provvisorie, perdita giornaliera sull'equity netta, verifica del realizzato all'avvio con righe `correzione`, `lastNOutcomes` neutralizzata, modelli ritirati e logistica riaddestrata (ADR-0011).
- `9875ab6` — **configurazione dall'interfaccia**: `ENCELADO_PASSWORD` e cookie HMAC, `secrets.enc` cifrato con la password, importazione una tantum dalla 5.0, Paper eliminata e modalità = conto, cancello Live senza variabili e mai automatico, preset fisso, applicazione a caldo (`SettingsRuntime`, comando `ApplySettings`, riavvio automatico senza chiudere i basket), template/compose/Dockerfile con la sola password (ADR-0010).
- `58d5ea7` — **viste pubblicate e tick condiviso**: `EngineView` immutabile, `SnapshotHub` (un tick v2 al secondo per tutti), sezioni a richiesta con `ETag`, feed in background, dati d'esempio per ogni rotta (ADR-0012).
- `50eb330` — **pagina Apprendimento** (`/api/learning`) e ciclo in background con un solo scrittore dei file, correzioni dell'apprendimento (ADR-0014).
- `fef00c5` — **nuova interfaccia in stile Mimante**, verificata sul server vero; screenshot rifatti (ADR-0013).
- Revisione: `07a00cd` (ciclo di vita: un lucchetto, nessun comando senza risposta, chiusura all'arresto sul thread di decisione), `b80638d` (interfaccia: kill-switch che fa ciò che si sceglie, impostazioni, stati dei basket spenti, `labels.js`), `c618f9f` (conti: stato per conto, guardia del cambio di conto nel motore, saldo all'avvio), `28db770` (rotazione del ledger solo in avanti), `7e3ace4` (soldi: perdita giornaliera fino a mezzanotte, una posizione una riga, verifica per conto, preset d'ingresso, scelta esplicita sulle esterne), `2d59c4e` (segreti e web: Live+demo resta demo, attesa dopo password errata anche per Bearer e cookie, richieste da altri siti rifiutate, `--sample` isolato, rete solo nel container), `54504ab` (apprendimento: contributi che spiegano la p, ritiro tutto o niente, conteggio dal dataset, ultima lettura buona, bracci mai provati).
- `dcb274e` — **Documenti**: versione 5.1.0; ADR-0010…ADR-0014 e ADR-0005/0006/0007/0008 segnati come superati in parte; QUESTIONS D-38…D-58 (D-31 superata); README, CLAUDE.md, RUNBOOK, DOCKER, guida Unraid (installazione e aggiornamento dalla 5.0 passo per passo), ARCHITECTURE, GLOSSARY, KNOWN_ISSUES, LEDGER_SCHEMA, DATA_SOURCES, RISK_RULES, STRATEGY, ML_AND_LEARNING, UI_GUIDELINES, API (quotazioni nullable, risposte 400/500 dopo un riavvio fallito), skill di progetto; CHANGELOG 5.1.0.
- `1cbd5a8` — **Seconda revisione**: lo stato della 5.0 va al conto su cui operava la 5.0 (`legacyState` registrato dall'importazione; Paper non ripreso); i comandi critici tengono fermi FERMA e i riavvii finché il motore li ha in mano, non finché il chiamante aspetta; le chiavi salvate mentre il conto cambia decidono il riavvio sul conto in uso dopo la verifica; la guardia del cambio di conto riconcilia prima di contare; la perdita giornaliera con lo storico in ritardo resta sospesa fino alla spiegazione e si blocca sul minimo se era una perdita; il secondo conto che corregge righe della 4.0-5.0 rimaschera `lastNOutcomes` e rifà la logistica; la pagina Apprendimento a motore fermo non chiama più «ultima lettura buona» i valori iniziali; il cookie di sessione contiene un segreto del server (`/config/session.key`) e non è più un tentativo di password (una scheda vecchia non tiene fuori la password giusta); test del preset d'ingresso rafforzati. Documenti, API e CHANGELOG aggiornati.
- **Verifica finale prima del rilascio** (questo commit): build 0 avvisi, 0 errori; 561 test verdi, anche nella cartella di `Verifica` della catena; le classi di concorrenza e web ripetute due volte. Server vero su una sandbox con password: login con il cookie, `/api/settings` 401 senza sessione, scrittura in `text/plain` 415 e da un'altra origine 403 con il file intatto, in JSON accettata e subito nel tick, AVVIA senza chiavi rifiutato in italiano, arresto pulito (codice 0). Server `--sample`: 50 rotte GET a 200, le 12 scritture 400 «modalità dimostrativa», cartella temporanea cancellata all'uscita. Le nove pagine in Edge senza errori, eccezioni né scorrimento orizzontale a 1440 e 420 px; screenshot rifatti. `docs/API.md` confrontato campo per campo con il JSON vero; aggiunto `/logout` fra le rotte libere (anche in UI_GUIDELINES). Due controlli nuovi in `EmbeddedUiTests`: ogni icona usata esiste, e solo `api()` chiama il server e manda JSON a ogni scrittura.
## Prossimi passi
1. **Rilascio 5.1.0** (richiesta dell'utente): push di `main`, poi `dotnet msbuild build/Release.proj -t:Rilascia -p:Versione=5.1.0` (immagine `192.168.30.23:3000/alby96/encelado:5.1.0` e `:latest` sul registro di Gitea, tag `v5.1.0`, release con lo zip e il template). Serve Docker con qualche GB libero sul disco C:.
2. **Aggiornare il container su Unraid** seguendo `deploy/unraid/README.md` §5: variabili tenute al primo avvio, `ENCELADO_WEB_TOKEN` rinominata `ENCELADO_PASSWORD` con lo stesso valore, poi variabili tolte; controllare nel log l'importazione, la migrazione dello stato, la verifica del realizzato e il ritiro dei modelli; «Esegui ciclo»; proposte nate dai proceeds segnate `respinta`.
3. **Il proprietario conferma o corregge D-38…D-58** (`docs/QUESTIONS.md`), in particolare D-52 (blocco della perdita giornaliera fino a mezzanotte), D-53 (stato per conto), D-55 (scelta esplicita sulle esterne), D-56/D-57 (accesso e rete).
4. **Prova sul conto demo** (24 ore): «P&L oggi» uguale al periodo «oggi» dello Storico e alla somma `netProfit − fees` dello storico eToro; righe di `baskets.csv` con «P&L: storico eToro»; contatore «orfane» a 0; `orders.jsonl` senza `Unknown` irrisolti; `sizing_bound = margin` sui primi ingressi; kill-switch a mano con verifica di piattezza; FERMA durante un kill-switch (409); cambio Demo → Live rifiutato con un basket aperto; container fermato un'ora con un basket aperto per il recupero; messaggi Telegram reali; revisione visiva dell'interfaccia con l'utente.
5. **Runner di Gitea Actions** (act_runner su Unraid) e segreto `REGISTRY_TOKEN`, se si vuole che `ci.yml` e `release.yml` girino da soli (`docs/DOCKER.md`).
6. Rifare il backtest (`backtest baskets`, `backtest falsify`) con i limiti di margine e il blocco della perdita giornaliera, e aggiornare §3 di `docs/STRATEGY.md`.
7. Dai problemi aperti della revisione (`docs/KNOWN_ISSUES.md`): gamba aperta e chiusa fra due riconciliazioni giudicata movimento di cassa; kill-switch interni (file STOP, equity stop) non protetti da FERMA; heartbeat fermo durante comandi lunghi; `costPips` a 0 nel vettore valutato dal modello vivo; ingresso completato dopo un riavvio senza vettore; `exit_reason` delle chiusure all'arresto; compressione dei file statici.
## Problemi aperti
- Backtest negativo: la strategia non regge i costi (`docs/STRATEGY.md`); i numeri vanno rifatti con le regole della 5.0-5.1.
- Il conto reale vale 224,90 USD: il Live non è praticabile.
- Google News blocca le ricerche RSS; RBA 403 a intermittenza; Fed 404 a tratti.
- Il server non ha TLS e il registro di Gitea è in HTTP (rete locale); Gitea Actions senza runner.
- I messaggi Telegram e i log della 4.0.0-5.0.0 con i proceeds come P&L non si possono correggere (il ledger sì).
- Le righe del ledger della 5.0 scritte in `Live` con `etoro.environment` demo (o `Demo` con `real`) portano la modalità, non il conto: la verifica del realizzato le cerca sul conto sbagliato (`docs/KNOWN_ISSUES.md`). Con la configurazione di fabbrica della 5.0 non succede.
- Il disco C: del PC di sviluppo è quasi pieno: le immagini e la cache di build di Docker pesano (`docker system prune` prima del rilascio).
- `Modifiche.txt` nella radice è un appunto dell'utente, modificato e non committato: decidere se tenerlo nel repository.
+130
View File
@@ -0,0 +1,130 @@
# Strategia: Correlation Baskets
Aggiornato: 2026-10-01 (5.1: preset fisso in Impostazioni, perdita giornaliera bloccata fino alla mezzanotte UTC anche nel backtest; i numeri di §3 sono quelli del 2026-09-16 e vanno rifatti, vedi sotto). Questo documento dice come funziona la strategia e, con i numeri, **se regge**. La risposta sui dati disponibili è **no**: nessuna configurazione è profittevole al netto dei costi di eToro. Il modulo resta uno strumento di forward test in Demo; non c'è nessun risultato che giustifichi il reale.
## 1. Logica
Cinque basket di due coppie forex con una valuta in comune:
| Basket | Comune | Cross sintetico | Gambe |
|---|---|---|---|
| EURUSD / USDCHF | USD | EURCHF | stesso verso |
| AUDUSD / USDCAD | USD | AUDCAD | stesso verso |
| NZDUSD / EURNZD | NZD | EURUSD | stesso verso |
| USDCAD / EURUSD | USD | EURCAD | stesso verso |
| EURAUD / AUDCAD | AUD | EURCAD | stesso verso |
In tutti e cinque la valuta comune ha ruoli opposti nelle due coppie, quindi `X = ln A + ln B` è il logaritmo del cross e le due gambe si comprano (o si vendono) insieme; la correlazione attesa dei rendimenti è negativa.
**Segnale** (`ZScoreSynthetic`): `z = (X − media_W) / σ_W` su W = 100 barre M15. Ingresso quando `|z| ≥ z_in` (2,0 nel preset Moderate), venduto il cross se z > 0, comprato se z < 0. Modalità alternativa `PipDivergence`: divergenza in pip fra le due gambe dall'ultimo punto di allineamento.
**Cancelli all'ingresso** (§5.3): correlazione rolling `ρ_W ≤ −0,6`, semiperiodo fra 5 e 120 barre, forza di trend sotto soglia, blackout del calendario, fine settimana, cost gate (`TP ≥ 3 × costo`, spread ≤ 2 × mediana 24 h), massimo di basket aperti, un solo basket per cross sintetico, quote fresche, orologio allineato, nessun blocco attivo. Fra i blocchi, la **perdita giornaliera** (3 % dell'equity netta di inizio giornata): raggiunta una volta, niente nuove entrate né aggiunte fino alle 00:00 UTC anche se l'equity recupera, dal vivo e nel backtest (D-52, `docs/RISK_RULES.md`).
**Sizing** (vol-parity): unità inversamente proporzionali all'ATR di ogni gamba, rischio totale alla distanza dello stop = `riskPerBasketPct` dell'equity (0,5 % Moderate), esposizione minima di eToro 1000 USD per gamba, leva effettiva ≤ 10. **Dalla 5.0** la size è il minimo fra quella a rischio e quella a margine (`risk` in `strategy.json`: 12 % dell'equity per basket, 40 % in totale, disponibile con buffer del 25 %): il 16/9 un solo basket sizato a rischio aveva impegnato il 100 % del margine. Il backtest applica gli stessi limiti dalla 5.0; i numeri di §3 sono della 4.0.0 (senza limite di margine) e vanno rifatti prima di trarne altre conclusioni: con meno nozionale il P&L per basket si riduce in valore assoluto, il segno del verdetto no.
**Uscite** (§5.4): take-profit di basket in pip (10 nel Moderate) **oppure** rientro dello z sotto `z_out` (0,25), a seconda di `exitMode`; stop di basket a `|z| ≥ z_stop` (3,5) o perdita ≥ 1,5 % dell'equity; time-stop dopo 4 giorni; spread anomalo per 3 barre consecutive; correlazione rotta; kill-switch ed equity stop.
**Averaging** (§5.5): spento di fabbrica; `AddOnce` e `Grid` esistono solo per il test di falsificazione 2.
I preset (`strategy.json` → `preset`, scelto in Impostazioni ▸ Strategia; dalla 5.1 è fisso: non si cambia a caldo, e un cambio vale per i basket nuovi, mentre quelli aperti tengono z di stop, aggiunte, TP e perdita massima con cui sono entrati; le sovrascritture dei singoli numeri stanno in Strategia ▸ avanzate):
| Preset | z_in | rischio/basket | basket max | TP pip | aggiunte | z_stop |
|---|---|---|---|---|---|---|
| Conservative | 2,5 | 0,25 % | 2 | 8 | 0 | 3,0 |
| Moderate | 2,0 | 0,50 % | 3 | 10 | 1 | 3,5 |
| Aggressive | 1,5 | 1,00 % | 5 | 12 | 2 | 4,0 |
## 2. Dati e costi del backtest
- Tick MetaTrader 5 (UTC) dal 2018-12-12 al 2026-09-15, convertiti in barre M15 bid/ask (`backtest ticks`); ~192 000 barre per coppia, EURAUD solo 39 700 (parti del 2018, 2021, 2026).
- Decisione alla chiusura della barra, esecuzione all'apertura della successiva sul lato giusto del book più 0,3 pip di slippage per gamba.
- Due scenari di costo, entrambi assunzioni:
- **etoro**: spread minimo per coppia = spread tipico pubblicato da eToro (EURUSD 1,0, USDCHF 1,5, AUDUSD 1,0, USDCAD 1,5, NZDUSD 2,5, EURNZD 5,0, EURAUD 3,0, AUDCAD 3,0 pip), overnight 0,3 pip/gamba/giorno;
- **api**: spread dei tick senza pavimento (0,1-0,7 pip, come mostra l'API demo), overnight **0,9 pip/gamba/giorno** (0,91 USD/giorno per 10 000 EURUSD letti dall'endpoint dei costi il 2026-09-16).
- Capitale iniziale 10 000 USD; equity stop al 9 % con ripartenza del picco (D-18), contando gli stop. Dalla 5.1 la perdita giornaliera del backtest è la stessa del motore: raggiunta, blocca le entrate fino alla mezzanotte UTC (`ReplayDailyLoss`; prima si rivalutava a ogni decisione). I numeri di §3, fatti prima di questo blocco e dei limiti di margine della 5.0, vanno rifatti con `backtest baskets` e `backtest falsify`.
- Niente calendario né notizie nel backtest: blackout e sentiment agiscono solo dal vivo.
## 3. Risultati
### 3.1 Baseline (strategy.json di fabbrica), costi etoro
| Preset | Basket | Win rate | Netto | Sharpe | Max DD | Costo medio | Break-even | Equity stop |
|---|---|---|---|---|---|---|---|---|
| Conservative | 0 | — | 0 | — | — | — | — | 0 |
| Moderate | 2 224 | 50 % | **−9 608 USD** | −3,38 | 96 % | 3,1 pip | −0,4 pip | 37 |
| Aggressive | 2 219 | 53 % | **−9 802 USD** | −3,61 | 98 % | 3,4 pip | −0,2 pip | — |
Il Conservative non apre mai: con TP 8 pip il cost gate a 3× non passa mai (3 × 3,1 > 8). Il Moderate perde quasi tutto il capitale in 7,75 anni: 2 224 basket × ~4 USD di costo = il conto. Il break-even (il costo per basket che azzererebbe il P&L medio) è **−0,4 pip**: il segnale non produce nemmeno un pip lordo per basket.
### 3.2 Griglia (§9.1): 57 configurazioni, costi etoro
3 preset × W ∈ {60, 100, 150} × ρ_min ∈ {−0,5, −0,6, −0,7} × z_out ∈ {0,25, 0,5}, più le tre baseline. Risultato in `results/trials.csv` e `results/riepilogo_baskets.csv`:
- **nessuna configurazione con P&L netto positivo**;
- la "migliore" per Sharpe è quella che non apre nulla (Sharpe 0);
- PBO (CSCV, 16 blocchi) = 0,000 solo perché la selezione in-sample sceglie sempre la configurazione vuota: un numero degenere, non una prova di robustezza;
- walk-forward "scegli il migliore degli ultimi 6 mesi, applicalo un mese" su 88 mesi: Sharpe −0,75, drawdown 13 %, PSR 0,005;
- DSR di ogni prova: 0.
Motivi di non ingresso, in ordine: `no_signal`, `cost_gate`, `rho_low`, `half_life`. Il cancello ρ ≤ −0,6 è raro sulle barre M15: dal vivo il 2026-09-16 ρ_W è rimasta fra −0,13 e −0,42 per tutta la sessione.
### 3.3 Falsificazione (§9.2), entrambi gli scenari
`reports/falsificazione.csv` (etoro) e `reports/falsificazione_costi_api.csv` (api), preset Moderate:
| Test | Variante | Basket (etoro / api) | Win rate | Netto etoro | Netto api | Break-even etoro / api |
|---|---|---|---|---|---|---|
| 1 segnale | ZScoreSynthetic | 2 224 / 2 076 | 50 % / 48 % | −9 608 | −9 802 | −0,4 / −0,5 pip |
| 1 segnale | PipDivergence | 3 124 / 2 877 | 42 % / 43 % | −9 406 | −9 784 | −0,6 / −0,4 pip |
| 2 averaging | AddOnce ×1,0 | 2 123 / 1 821 | 51 % / 48 % | −9 689 | −9 800 | +0,3 / +0,4 pip |
| 2 averaging | AddOnce ×1,5 | 1 980 / 1 673 | 51 % / 47 % | −9 741 | −9 802 | +0,2 / +0,3 pip |
| 3 stop | senza stop | 1 844 / 1 949 | 55 % / 54 % | −9 228 | −9 796 | −0,2 / −0,4 pip |
| 4 cost gate | 2× | 2 135 / 2 052 | 48 % / 48 % | −9 800 | −9 800 | −0,7 / −0,6 pip |
| 4 cost gate | 4× | 0 / 3 | — / 33 % | 0 | −81 | — / +3,8 pip |
| 5 inverso | segnale invertito | 1 824 / 1 537 | 43 % / 39 % | −9 735 | −9 801 | **−2,5 / −2,9 pip** |
Letture:
- **Il segnale ha un contenuto, ma piccolo.** Invertirlo peggiora il break-even di circa 2-2,5 pip per basket (da −0,4 a −2,5). Quindi il verso del segnale vale ~2 pip; il costo medio di un basket è 3,1-3,2 pip. Non basta, in nessuno dei due scenari.
- **L'averaging alza il break-even di ~0,7 pip** (compra i rientri) ma allunga la coda: il percentile 1 % delle perdite passa da −98 a −115 USD e il drawdown sale. Non cambia il segno del risultato.
- **Senza stop** il win rate sale al 55 % e il netto migliora di 380 USD nello scenario etoro, ma la coda (1 %: −136 USD) e il drawdown restano quelli di un sistema che tiene le perdite aperte. Lo stop resta obbligatorio.
- **Il cost gate non salva la strategia**: a 4× non apre quasi nulla, a 2× apre di più e perde di più. Il costo è il problema, ma non è l'unico: anche con lo spread a 0,1 pip (scenario api) l'overnight riporta il costo a 3,2 pip.
- **PipDivergence** apre di più e perde di più (win rate 42 %).
### 3.4 Griglia con costi api
`results/trials_costi_api.csv` e `results/riepilogo_baskets_costi_api.csv` (57 prove):
- baseline Moderate: 2 076 basket, win rate 48 %, netto **−9 802 USD**, Sharpe −3,88, costo medio 3,2 pip;
- **nessuna prova con P&L netto positivo**; la migliore per Sharpe (T013: Conservative, W 150, ρ_min −0,5) apre 8 basket in 7,75 anni e perde 45 USD (Sharpe −0,10, DSR 0);
- PBO 0,001, di nuovo degenere (la selezione in-sample sceglie configurazioni quasi vuote);
- walk-forward 6 m / 1 m: Sharpe −0,91, drawdown 13,5 %, PSR 0,000.
Lo scenario api sposta il costo dallo spread all'overnight senza cambiarne l'ordine di grandezza, perché un basket resta aperto in media più di un giorno (0,9 pip/gamba/giorno × 2 gambe × ~1,5 giorni ≈ 2,7 pip).
## 4. Verdetto
**Negativo.** Sui 7,75 anni disponibili la strategia perde in ogni configurazione provata, con entrambi i modelli di costo, e i test di falsificazione non trovano una variante che inverta il segno. Il segnale contiene circa 2 pip di informazione per basket contro 3 pip di costo.
Cosa ne segue:
1. Il bot **non va sul reale**. `run.allowLive` resta `false`; i cancelli di §9.4 non sono raggiungibili con questi numeri.
2. Il Demo serve a **misurare** (spread reale in esecuzione, slippage, overnight effettivo, quanto spesso i cancelli si aprono), non a guadagnare. Ogni basket chiuso finisce nel ledger e nel dataset del meta-modello.
3. Se qualcuno vuole cambiare un parametro, lo fa attraverso `knowledge/proposals.csv` e un forward test pre-registrato (`knowledge/preregistrazione.csv`), non ritoccando `strategy.json` dopo aver guardato i risultati: ogni prova in più abbassa il DSR di tutte le altre.
## 5. Cosa non è stato misurato
- L'effetto del blackout del calendario e del sentiment (assenti nel backtest).
- Lo spread effettivo di esecuzione su eToro: l'API demo mostra 0,1 pip di mercato e markup 0; il ledger del Demo dirà se le esecuzioni lo confermano (slippage per gamba scritto a ogni ingresso).
- EURAUD/AUDCAD su tutto il periodo (dati parziali).
- Timeframe diversi da M15 e finestre oltre 150 barre.
## 6. Come rieseguire
```powershell
backtest ticks --data "A:\Download\Trading" --out "%USERPROFILE%\Documents\Encelado\data\market"
backtest baskets --data "%USERPROFILE%\Documents\Encelado\data\market" --out results [--costs api]
backtest falsify --data "%USERPROFILE%\Documents\Encelado\data\market" --out reports [--costs api]
```
Ogni esecuzione riscrive le tabelle; i numeri di questo documento vengono da quelle del 2026-09-16.
+375
View File
@@ -0,0 +1,375 @@
# Interfaccia web (5.1): linee guida
Aggiornato: 2026-10-01 (5.1, ADR-0013). Sostituisce le linee guida Material 3 della 5.0. L'interfaccia della 5.1 riprende il linguaggio
visivo e gli schemi di codice di Mimante (`C:\Sviluppo\Mimante\Mimante`, BidooBidBot): pagine compatte e dense, colore
che ha un significato, dettagli nei tooltip, nessuna notifica laterale. È servita dal bot stesso
(`src/Encelado.Server/Web/wwwroot/`, incorporata nell'assembly). Il contratto dei dati è in `docs/API.md`: i nomi dei
campi valgono lì.
## 1. Principi
1. **La UI non decide niente.** Legge il tick (`/api/stream`) e le sezioni a richiesta, manda comandi con
`POST /api/commands/<nome>` e impostazioni con `POST /api/settings`. Ogni regola di rischio sta nel motore.
2. **Il colore viene solo dai token** (`css/tokens.css`) e ha un significato:
- neutro = secondario;
- accento = primario;
- verde, ambra e rosso = ok, attenzione, pericolo;
- oro = notevole (il migliore nel contesto, solo fra i bracci provati almeno una volta; il modello campione).
Fanno eccezione, per forza di cose, i colori propri delle bandiere e il bianco della levetta.
3. **Densità compatta.** Testo base a 13 px con cifre tabulari (`font-variant-numeric: tabular-nums`). Controlli alti
30 px, righe di tabella 32 px (28 nelle tabelle compatte), barra in alto 46 px.
4. **Layout fluido.** Niente `max-width` sui contenitori delle pagine. Si usano griglie con `minmax(0,1fr)` e colonne
che si adattano alla larghezza; la pagina non scorre mai di lato, sono le tabelle a scorrere dentro il loro
pannello. A 1920 e a 2560 px non resta nessuna fascia vuota a destra.
5. **Il DOM si costruisce una volta sola e poi si aggiorna sul posto.** Le righe hanno una chiave e si riscrive solo la
cella il cui valore è cambiato. Nessun `innerHTML` con dati.
6. **Ogni numero ha un `title`** con il significato, la formula o la fonte. Gli importi riportano nel tooltip il
valore in USD e il tasso usato.
7. **Niente toast.** Una conferma di routine si vede come cambio di stato sul posto (colore del bottone, riga, esito
accanto al campo). Una finestra al centro compare solo per errori, conferme e risultati importanti. Un comando
rifiutato (`{ ok: false }`, anche i 400 della modalità `--sample`) apre la finestra con il messaggio del server.
8. **I bottoni delle barre strumenti sono icone** con `title` e `aria-label`. Le azioni principali di una pagina sono
bottoni con testo: Salva, Esegui ciclo, Bonifica orfane.
9. **Le azioni irreversibili chiedono conferma**: chiusura di un basket, kill-switch, ripristino (motivazione di almeno
10 caratteri), rimozione di chiavi e token, valori di fabbrica, avvio Live e ogni modifica che riavvia il motore in
Live (frase `CONFERMO LIVE` scritta per intero). Nelle conferme distruttive il fuoco parte su «Annulla»: un Invio
tenuto premuto non esegue niente. Nel kill-switch la casella «chiudi anche le esterne» parte come l'impostazione
«Il kill-switch chiude anche le posizioni esterne» (`tick.closeForeignOnKill`, con una riga che lo dice quando è
accesa) e la scelta fatta nel dialogo è quella che vale: va sempre al server come `foreign` esplicito.
10. **Testi italiani, brevi.** «Non mettere scritte inutili che occupano solo spazio»: i dettagli vanno nel tooltip,
nel log o nella pagina di dettaglio.
## 2. Token
Tema scuro predefinito, chiaro con gli stessi nomi (`:root[data-theme="light"]`). Senza un tema scelto, la pagina segue
`prefers-color-scheme`: è il caso della pagina di accesso. Il tema si sceglie con ◐ nella barra o in Impostazioni ▸
Interfaccia (`ui.theme`), ed è ricordato anche nel browser (`localStorage`, `js/boot.js` lo applica prima del primo
disegno).
| Token | Scuro | Chiaro | Uso |
|---|---|---|---|
| `--bg` | #151920 | #eef1f5 | fondo della pagina |
| `--surface` / `-2` / `-3` | #1c2129 / #232a34 / #2a323d | #fff / #f4f6f9 / #e9edf3 | pannelli, controlli, selezione |
| `--line` | #2c3441 | #d7dde6 | bordi e separatori |
| `--text` / `--muted` / `--faint` | #e6eaf1 / #93a0b4 / #5f6b7d | #1b2230 / #5b6778 / #9aa5b5 | testo, etichette, dati spenti |
| `--accent` | #5b9cff | #2f6fe4 | primario, selezione, livello INFO |
| `--ok` / `--warn` / `--bad` | #3ecf8e / #f2b640 / #f15b50 | #1f9d63 / #c98a10 / #d63b31 | utile, attenzione, perdita o pericolo |
| `--gold` | #e5b94e | #b8891a | il migliore, il campione |
| `--*-soft` | stessi colori al 12-18 % | | fondo di tag, pill, fasce |
Altre variabili:
- `--ctl-h: 30px`, `--topbar-h: 46px`, `--nav-w: 212px`, `--nav-w-narrow: 56px`;
- `--r: 6px` e `--r-lg: 8px` (finestre);
- `--fs: 13px`, `--fs-small: 12px`, `--fs-tiny: 11px`, `--gap: 14px`.
Scala dei testi:
- titolo della pagina 15 px/600;
- titolo di sezione 13,5 px/600;
- valore delle tessere tra 15 e 20 px (con `clamp` nella dashboard);
- testo secondario 12 px, etichette minime 11 px.
Pesi usati: 400 e 600 (700 solo per KILL e i tag di livello).
## 3. File
```
wwwroot/index.html solo lo scheletro (XHTML ben formato: ogni elemento chiuso, attributi con valore)
wwwroot/login.html scheda di accesso, senza JavaScript (/js/* chiede la sessione): il server sostituisce
<!--login-error--> con <p class="login-error" role="alert">…</p>
wwwroot/css/tokens.css i token css/app.css i componenti css/pages/<pagina>.css le regole di una pagina
wwwroot/js/boot.js script classico nel <head>: applica il tema salvato prima del primo disegno
wwwroot/js/app.js ingresso (modulo): barra in alto, menu, striscia degli allarmi, router, tema
wwwroot/js/state.js store del tick, pub/sub, disegno in requestAnimationFrame, sezioni su richiesta, comandi
wwwroot/js/stream.js EventSource su /api/stream (chiuso dopo 15 s di scheda nascosta), ?once=1 per gli screenshot
wwwroot/js/util.js el() e scritture condizionate, formati italiani con Intl in cache, importi, api(), memoria del browser
wwwroot/js/grid.js tabella a righe con chiave e aggiornamento per cella
wwwroot/js/ui.js sezioni, tessere, liste chiave/valore, colonne affiancate, Markdown sicuro, SVG sanificato
wwwroot/js/charts.js gauge dello z, barre, barre centrate sullo zero, sparkline, calibrazione, pesi
wwwroot/js/dialog.js finestra centrale: conferma, richiesta di testo (CONFERMO LIVE), messaggi
wwwroot/js/actions.js AVVIA, FERMA, KILL, chiudi basket, residui, ripristino, pausa, bonifica, ciclo di apprendimento, esci
wwwroot/js/baskets.js come si legge un basket (stato, verso, p_ML, prossimo evento nel fuso del browser)
wwwroot/js/labels.js le parole del ledger e del motore in italiano (evento, codici di motivo, motivi d'uscita,
stati degli ordini, sorgenti del log); il codice resta nel tooltip
wwwroot/js/icons.js flags.js clocks.js split.js
wwwroot/js/pages/<pagina>.js una pagina = { mount(section, ctx, params), unmount(), render(tick), params(p)? }
```
Ogni file sotto `wwwroot/` è servito al suo percorso (`/css/app.css`, `/js/pages/log.js`), con il tipo dal suffisso
(`.js` come `text/javascript`, altrimenti il browser rifiuta i moduli), `ETag` e 304. Libere senza sessione solo
`/login`, `/logout`, `/css/*`, `/img/*`, `/icon.svg`, `/manifest.webmanifest` e `/api/health`.
Le pagine sono moduli ES importati staticamente da `app.js` (niente `import()`). Esiste nel DOM solo la pagina visibile.
## 4. Struttura
### Barra in alto (46 px, tutta la larghezza)
Da sinistra a destra:
1. Menu (solo sotto 480 px).
2. Logo e «Encelado».
3. **Pill del motore**: il pallino dice lo stato, il testo il conto. Sostituisce le scritte «demo» e «in esecuzione»
che nella 5.0 stavano in fondo al menu.
- Pallino verde: in esecuzione. Grigio: fermo. Ambra: in avvio o in arresto, pausa, entrate bloccate, recupero,
perdita giornaliera, heartbeat in ritardo sul suo intervallo (`tick.heartbeatSeconds`). Rosso: errore o bloccato.
- Testo `DEMO` con bordo accento, oppure `LIVE` su fondo rosso.
- Il tooltip dà lo stato completo; il clic apre Sistema.
4. **Pill eToro**: pallino secondo `health.api` e latenza. Il tooltip dà scarto dell'orologio e quota più usata.
5. **Pill dei numeri**: Equity, Oggi (con «stima» quando è provvisorio), Aperto, DD, Basket aperti/massimo. Ognuna ha il
tooltip con formula, USD e tasso.
6. **Orologi** (vedi sotto).
7. A destra:
- la pill dell'allarme più grave (icona e parola; sotto 560 px solo l'icona), cliccabile;
- **KILL** (rosso, attivo solo con il motore in esecuzione);
- tema ◐;
- **accensione** ⏻: verde quando il motore gira (clic = FERMA con conferma), neutra quando è fermo (clic = AVVIA; in
Live chiede la frase), disattivata durante avvio e arresto.
Le pill cedono lo spazio per priorità: prima Basket (<1600 px), poi DD (<1500), Aperto (<1380), eToro (<1240),
orologi (<1024), Equity (<720) e Oggi (<560). Motore, accensione, KILL e allarme restano sempre. La barra non va mai su
due righe: quello che non ci sta scivola su una seconda riga invisibile. Non c'è il selettore della valuta, che sta in
Impostazioni ▸ Interfaccia.
### Orologi
Un orologio per ogni fuso delle valute trattate, da est a ovest:
- Nuova Zelanda (`Pacific/Auckland`, NZD);
- Australia (`Australia/Sydney`, AUD);
- Europa centrale e Svizzera (`Europe/Zurich`, EUR+CHF);
- Stati Uniti e Canada (`America/New_York`, USD+CAD).
Solo `HH:mm`, aggiornati allo scoccare del minuto e fermi con la scheda nascosta. Le bandiere sono SVG in linea, perché
Windows non disegna le emoji delle bandiere.
- **Il fuso del computer** compare come quinto orologio, con l'icona della casa, solo se la sua firma dell'ora legale
(scarti a metà gennaio, aprile, luglio, ottobre e adesso) è diversa da tutte e quattro. Altrimenti un pallino
accento segna l'orologio corrispondente: da Europe/Rome si vede EU+CH.
- **Fuori dalla sessione** locale (08-17 nei giorni feriali, festivi esclusi) l'orologio è spento.
- **Il tooltip** dice città, ora con sigla e scarto UTC, ora UTC, sessione, valute ed eventuale «un giorno avanti o
indietro». In barra compare anche «+1» o «−1».
### Menu a sinistra (212 px, 56 px compresso)
Le voci sono Dashboard, Basket, Posizioni, Mercato, Storico, Apprendimento, Log, Sistema e Impostazioni, con icona.
- **Contatori.** Posizioni in rosso quando ci sono gambe orfane. Log con gli errori arrivati dall'ultima visita alla
pagina (contati da quando il browser ha aperto l'interfaccia).
- **In fondo** c'è solo «Comprimi il menu». La scelta è salvata in `ui.navExpanded` e nel browser.
- **Finestre strette.** Sotto 700 px il menu mostra solo le icone. Sotto 480 px sparisce dietro il bottone del menu e
si apre sopra la pagina.
### Striscia degli allarmi
Una riga sotto la barra, solo quando c'è un allarme da spiegare. Gli allarmi, in ordine di gravità:
| Allarme | Colore | Azione |
|---|---|---|
| motore in errore | rosso | Sistema |
| kill-switch con residuo | rosso | Chiudi residui |
| bloccato (kill o equity stop) | rosso | Sblocca…, cioè la procedura di ripristino |
| Live da confermare | rosso | Avvia… |
| segreti bloccati | rosso | Apri impostazioni |
| nessuna chiave salvata (`health.secrets = empty`, motore fermo) | ambra | Apri impostazioni |
| non riconciliato | ambra | Posizioni |
| perdita giornaliera (fino alle 00:00 UTC anche se l'equity recupera: `dailyLossLatched`) | ambra | |
| entrate bloccate | ambra | |
| pausa | ambra | Riprendi |
| recupero | ambra | |
| gambe orfane | ambra | Posizioni |
| variabili d'ambiente ignorate | tenue | Dettagli (Sistema) |
Si vede il primo; gli altri sono in «+N altri», con l'elenco nel tooltip. Se il tick non arriva per più di 4,5 s compare
«Connessione con il bot interrotta: riprovo…».
### Pagine
Ogni pagina ha:
1. una **barra strumenti** su una sola riga allineata: titolo 15 px, azioni, filtri, contatori a destra. Tutti i
controlli sono alti 30 px e centrati; le etichette stanno a sinistra del controllo o come segnaposto, mai sopra.
Un testo lungo (il percorso del file di log) si accorcia con i puntini invece di mandare a capo i controlli;
2. un **corpo** che scorre dentro la pagina, con margini e spazi di 14 px.
## 5. Componenti
- **Bottoni**:
- `.btn`, alto 30 px, nelle varianti `primary`, `danger`, `ghost`, `sm` (26 px);
- `.icon-btn`, 30×30 con icona 16 px, nelle varianti di colore `c-ok`, `c-bad`, `c-acc`;
- azioni di riga: bottoni 26×26 in un `div.acts` dentro la cella. La cella resta una cella di tabella: una `td` con
`display:flex` perderebbe la larghezza fissa della colonna e le azioni scivolerebbero all'estremo destro;
- `.kill` per il kill-switch.
- **Campi**: `input.txt`, `select.txt` (30 px). I numeri sono allineati a destra. L'unità corta (fino a 13 caratteri:
«secondi», «% dell'equity») sta dentro il campo; una lunga («MB (0 = nessuna rotazione)», «ora UTC (−1 = spento)»)
sta accanto all'etichetta, dove non copre mai il valore. Un numero con `allowEmpty` lasciato vuoto vale «dal preset».
- **Interruttori**: `.switch` (34×18). Nelle barre strumenti si usa `.chk`: una levetta con il testo, nella stessa
scatola da 30 px degli altri controlli («Segui» del Log).
- **Segmentato**: `.seg`, per le viste dello Storico.
- **Schede**: `.tabs`, per il pannello del Basket.
- **Stati**:
- `.chip` (26 px) con `.dot` e icona (14 px) nella barra in alto;
- `.tag` per lo stato di una riga (Aperto verde, Attesa ambra, Inattivo tenue, Errore rosso). Vale la parola del
server: un basket spento in Attesa B, in Errore o in Uscita lo dice, e la riga è attenuata solo se è spento e
senza niente sul conto;
- `.pill`;
- `.lvl` per il livello del log: INFO accento, WARN ambra, ERROR rosso, DEBUG e TRACE tenui.
- **Sezioni**: `.section`, con `h2` alto 38 px (icona, titolo, sottotitolo, strumenti a destra) e corpo `.in` oppure
`.tw` (tabella che scorre).
- **Colonne affiancate**: `stacks()` in `ui.js` dispone le sezioni in colonne («masonry»). Il numero di colonne
dipende dalla larghezza. Le sezioni si ridistribuiscono solo quando cambia il numero di colonne o dopo il primo
caricamento, mai mentre cambiano i dati: niente salta sotto gli occhi.
- **Tessere**: `tile()`, con etichetta, valore e una o due righe di sotto testo (ognuna con i puntini se troppo lunga),
barra facoltativa. La spiegazione completa sta nel `title`.
- **Chiave/valore**: `kv()`, a colonne automatiche (`kv2`) o su una colonna (`kv`), aggiornabile per chiave.
- **Tabelle**: `Grid` in `grid.js`.
- Righe con chiave. Le colonne danno `text`, `tip` e `klass`, oppure `render` + `sig` quando la cella contiene
elementi: gauge, barre, bandiere.
- Layout fisso con larghezze dalle intestazioni; i testi lunghi finiscono con i puntini e il testo intero nel
`title`. Una sola colonna senza larghezza prende lo spazio che resta.
- `hideBelow` nasconde una colonna sotto una larghezza del contenitore: la colonna resta con larghezza zero, perché
`display:none` lascerebbe una colonna fantasma.
- `narrow` le dà una larghezza minore sotto una o più soglie.
- Oltre `virtualizeOver` righe (Storico) si disegnano solo le righe visibili.
- L'ordinamento con clic sull'intestazione è ricordato nel browser.
- **Grafici** (niente librerie):
- gauge dello z: fascia d'ingresso ambra da z_in a z_stop, tacche rosse allo stop, segno blu, ambra o rosso;
- pip/TP con barra;
- barre centrate sullo zero (sentiment, pesi, contributi);
- sparkline dell'AUC con tratteggio a 0,5;
- curva di calibrazione (10 fasce, diagonale = perfetta);
- z del basket nelle ultime 20 chiusure di barra, con le soglie;
- curva del realizzato dallo `equitySvg` del server, letto come XML e sanificato.
- **Pannello a destra**: `split.js`, maniglia trascinabile che cambia solo `--panel-w`. Doppio clic ripristina la
larghezza. Sotto 900 px il pannello va sotto l'elenco.
- **Finestre**: `modal()`, `confirmDialog()` (con casella facoltativa e una riga di spiegazione), `promptDialog()` (con
validazione: il bottone si abilita solo con il testo giusto), `notice()`. Esc o il clic fuori chiudono; il fuoco resta
nella finestra e parte dal campo di testo, altrimenti dall'ultimo bottone, ma su «Annulla» quando l'azione è
distruttiva.
- **Bandiere**: `flags.js`, sprite SVG iniettato una volta, 18×12 (CH 12×12). Ci sono EU, CH, US, CA, AU, NZ, GB e
JP; il testo è nel tooltip dell'elemento che le contiene.
## 6. Le pagine
| Pagina | Dati | Contenuto |
|---|---|---|
| **Dashboard** | tick; `/api/market?calendarDays=7&impact=High,Medium&news=0` | 9 tessere: equity, P&L oggi (con «stima»; è il periodo «oggi» dello Storico), aperto, drawdown con barra verso lo stop, perdita giornaliera con barra (quando scatta resta bloccata fino alle 00:00 UTC anche se l'equity recupera: `dailyLossLatched`, ora di sblocco nel fuso del browser), margine, basket con il preset, chiusi oggi, apprendimento con barra. Tabella dei 5 basket: bandiere e nome con il cross, stato, verso, z con gauge, ρ, HL, pip/TP, P&L, costo, p_ML, prossimo evento (ora nel fuso del browser e conto alla rovescia: l'etichetta del motore porta l'ora UTC), chiudi; un clic apre il Basket. Prossimi eventi, mercato (8 quotazioni con lo spread colorato rispetto alla mediana; «—» per uno strumento non ancora quotato), registro (le ultime `tick.statusLines` righe, cioè Impostazioni ▸ Log ▸ righe di attività, 60 prima del primo tick; clic = Log). A 1440×900 sta tutto senza scorrere; da 1500 px di pagina eventi e mercato vanno in una colonna a destra. |
| **Basket** | tick; `/api/baskets/detail?name=` ogni 2 s; `/api/learning` per la scheda ML | Elenco con tutte le colonne (stato, intento, z, z_in, z_stop, ρ_W, ρ_20, HL, pip/TP, P&L, costo, spread×, p_ML, barre, aggiunte, z d'ingresso, evento) e sotto il grafico dello z del basket scelto. Pannello con schede: Stato (intento, ultima decisione con i motivi, soglie contro valori con ✓/✗, cost gate, dimensione con il vincolo), Posizione (dati del basket e gambe, oppure la gamba in attesa), Segnale, Contesto, ML (p_ML, contributi del modello che l'ha data, feature: «Feature all'ingresso» mentre il basket è in posizione o in attesa di una gamba, «Feature all'ultima barra» altrimenti; una p_ML senza spiegazione conservata dice «Nessun contributo che spieghi questa p_ML…» invece di mostrare contributi di un altro modello), Decisioni (ultime 20). Eventi del ledger, codici e vincoli in italiano (`labels.js`), il codice nel tooltip. |
| **Posizioni** | `/api/positions` | Tessere per origine: tutte, basket, orfane del bot, esterne. Ogni posizione del conto: origine, basket e gamba, strumento, verso, unità, apertura, attuale, pip, P&L, margine, leva, SL/TP, aperta da; bonifica delle orfane. Ordini in attesa con la loro età. |
| **Mercato** | `/api/market?calendarDays=7&impact=High,Medium,Low,Holiday&news=50`; tick | Quotazioni (spread, mediana, rapporto, età, ATR, usato da): gli strumenti dei basket prendono bid, ask, spread ed età dal tick ogni secondo, l'età delle coppie di sola conversione cresce con l'orologio (la sezione è ricostruita al più ogni 15 s); calendario con filtri per impatto e valuta (ricordati nel browser; una valuta ricordata ha sempre il suo chip, anche in una settimana senza eventi), conto alla rovescia e blackout; sentiment 1 h, 4 h, 24 h per valuta con risk-off; notizie con i link; valute di visualizzazione; volatilità per basket. |
| **Storico** | `/api/history/orders`, `positions`, `periods`; tick | Tre viste (Ordini, Posizioni, Profitti per periodo con la curva del realizzato), filtri nella barra, esportazione CSV dal server. `#/storico?vista=periodi` apre direttamente una vista. I filtri basket e strumento vengono dai basket del tick (anche a motore fermo) e si ricostruiscono quando arriva il primo tick; un filtro ricordato che l'elenco non conosce resta fra le opzioni, visibile e annullabile. Motivi d'uscita e stati degli ordini in italiano, il codice nel tooltip. |
| **Apprendimento** | `/api/learning` | Stato e motivo; «Esegui ciclo» (spento mentre gira, con la fase in corso); esportazione JSON. 10 tessere: etichettati/300, win rate, P&L netto, AUC mobile con intervallo, Brier, modello, bandit, volatilità, ultimo e prossimo ciclo. Avvisi. Poi le sezioni: attivazione (criteri ✓/✗), cosa ha imparato (pesi ordinati, 15 + «mostra tutti»), per basket, bandit 3×3 con il migliore in oro (solo un braccio provato almeno una volta: un bandit nuovo non ne ha), ultimo ciclo (logistica contro MLP, calibrazione, AUC nel tempo), stato dei modelli, dataset per basket, preset e uscita, calibrazione per fascia, proposte, registro dei modelli, file, osservazioni (Markdown reso in modo sicuro). |
| **Log** | righe del tick; `/api/log` | Barra su una riga: livello, «Cerca…», «Segui», conteggio, nome del file (il percorso intero nel tooltip), esporta. Una riga per messaggio: ora nel fuso del browser, tag del livello colorato, origine in italiano (la classe nel tooltip), messaggio con i puntini e con i codici del ledger in italiano («motivo take-profit»). Il clic apre il testo intero; il tooltip, la ricerca (come il `q` del server) e l'esportazione usano il testo del file. Al massimo 2000 righe nel DOM. |
| **Sistema** | `/api/system` ogni 3 s | Motore (con Pausa/Riprendi e Ripristino…; heartbeat giudicato sul suo intervallo, `heartbeatSeconds`, rosso oltre la soglia di `/api/health`), collegamento eToro con le quote, feed, Telegram (messaggio di prova), segreti (sblocco e ripartenza, variabili ignorate), processo, disco, log, interfaccia web (Esci), diagnostica (bonifica), informazioni. |
| **Impostazioni** | `/api/settings` | Gruppi disposti in colonne, etichetta a sinistra e controllo a destra, levette per i sì/no, numeri a destra con l'unità, un'icona per l'effetto: ⚡ subito, ⚙ nel motore, ↻ riavvia il motore. Pannelli speciali: chiavi eToro demo e live (gruppo `conto`), token Telegram (`telegram`), Esci (`interfaccia`), segreti bloccati, valori predefiniti; il gruppo `avanzate` è chiuso. «Salva (n)» manda solo i campi diversi dal valore che il server ha adesso (riletto a ogni salvataggio: tornare a un valore di prima è una modifica); se serve la frase CONFERMO LIVE la chiede e ripete; l'esito di ogni campo compare accanto per qualche secondo. |
| **Accesso** | `POST /login` | Logo, «Encelado», «Password interfaccia», «Entra»; errore «Password errata.». |
## 7. Flusso dei dati e prestazioni (regole non negoziabili)
- **Un solo store** (`state.js`), alimentato dal tick SSE. Una sola pagina visibile, che disegna in
`requestAnimationFrame`: con la scheda nascosta non si disegna niente.
- **L'EventSource si chiude dopo 15 s di scheda nascosta** e si riapre quando torna visibile (il server smette di
calcolare i frame). Senza `EventSource` si legge `/api/snapshot` ogni 2 s. Un 401 porta a `/login`.
- **Le sezioni pesanti** si leggono con `watch()` solo mentre la loro pagina è visibile: subito, quando cambia
`tick.versions[chiave]` e ogni 30 s, con `If-None-Match` (304 gratuito). Il dettaglio del basket si legge ogni 2 s,
Sistema ogni 3 s. Nessun altro polling sotto i 2 s.
- **Le righe del log** arrivano nel tick come differenza e si aggiungono per `seq`. Su un salto o una riconnessione si
recupera il mancante con `/api/log?after=`. Al primo tick si caricano le ultime 300 righe (o `statusLines`, se sono
di più, fino a 2000).
- **Ogni POST e DELETE** (`api()` in `util.js`, l'unica `fetch`) manda `Content-Type: application/json`, anche senza
corpo: il server rifiuta gli altri con 415, così un modulo di un altro sito non può comandare il bot.
- **Tabelle con chiave**: righe create una volta; `textContent`, `title` e `className` scritti solo se diversi. Mai
`innerHTML` con dati: lo usano solo i percorsi statici delle icone. L'SVG del server passa da `DOMParser` in XML e da
una lista di elementi ammessi.
- **Formattatori `Intl` in cache**, uno per formato; nessun formattatore creato per valore.
- **CSS**:
- niente `backdrop-filter`, niente `color-mix`;
- niente transizioni su proprietà di layout (solo la levetta);
- `table-layout: fixed` con le larghezze delle colonne;
- `content-visibility: auto` sulle righe del log;
- `prefers-reduced-motion` spegne animazioni e transizioni.
- **Importi**: arrivano in USD e il browser li converte con `fxRates[valuta].usdPerUnit`. Il tooltip mostra USD e
tasso. Le pagine costruite dai dati delle sezioni ridisegnano gli importi quando cambia la valuta.
- **Misure** con il server vero in `--sample`, flusso a 1 Hz, 1440×900, finestre di 10 s (protocollo DevTools,
`Performance.getMetrics`): dashboard circa 64 ms di lavoro del thread principale ogni 10 s (0,6 %: 11 ms di script,
9 di layout, 16 di stile), Basket 47 ms, Log 32 ms; heap tra 1,5 e 2,1 MB. Il tick pesa circa 6 KB al secondo per
client (più le righe di log nuove).
- **Peso**: circa 295 KB di JavaScript non minificato (circa 90 KB con gzip), 60 KB di CSS. Pesano i tooltip in
italiano su ogni numero, le etichette del ledger e le nove pagine importate staticamente. Kestrel non comprime i
file statici.
## 8. Adattamento alla larghezza
Provato a 420×860, 1024×768, 1440×900, 1920×1080 e 2560×1440 con il server vero (e a 800×1000 e 1280×720 con il mock di
sviluppo).
- Le griglie delle tessere passano da 9 colonne a 5 e poi a 3.
- Dashboard, Mercato, Apprendimento, Sistema e Impostazioni dispongono le sezioni su 1, 2 o 3 colonne.
- Nelle tabelle le colonne meno importanti cedono il posto (`hideBelow`, `narrow`); se non basta la tabella scorre
dentro il suo pannello, la pagina mai.
- Il pannello del Basket va sotto l'elenco sotto 900 px.
## 9. Accessibilità e testi
- Tutto si raggiunge da tastiera; il fuoco è visibile (contorno accento di 2 px).
- I bottoni a icona hanno `aria-label`. La striscia degli allarmi ha `role="status"`, le finestre `role="dialog"`.
- Testi in italiano e brevi; i numeri con il formato italiano (1.234,56; −1,23 con il vero segno meno; «12,34 %»).
- Gli orari a schermo sono nel fuso del browser; l'UTC compare solo nei tooltip e nei testi che il motore scrive per
il ledger (motivazioni, intenti).
## 10. Verifica visiva (screenshot)
`docs/img/` contiene una foto per pagina a 1440×900 (`dashboard`, `dashboard-chiaro`, `basket`, `posizioni`,
`mercato`, `storico`, `apprendimento`, `log`, `sistema`, `impostazioni`, `login`) e `mobile` (la dashboard a
420×860). Si rifanno tutte con il server vero in modalità campione:
```powershell
scripts\screenshots.ps1 [-Port 58085] [-Only dashboard,mobile]
sh scripts/screenshots.sh [porta]
```
Lo script compila, avvia `Encelado.Server --sample` su cartelle temporanee e senza password, fotografa e ferma tutto.
- `?once=1` legge un solo snapshot e non apre lo stream: con uno stream aperto un browser headless non considera mai
finito il caricamento della pagina. `?theme=light|dark` forza il tema.
- Le foto da computer usano `msedge --headless=new --window-size=… --screenshot=…`.
- **Edge per desktop non stringe la finestra sotto circa 500 px**: `--window-size=420,860` darebbe una pagina larga
500 tagliata a destra. La foto `mobile` passa quindi dal protocollo DevTools con l'emulazione della finestra
(`Emulation.setDeviceMetricsOverride`): in PowerShell con `ClientWebSocket`, in `screenshots.sh` con
`node scripts/cdp-shot.mjs` (Node 22+, nessun pacchetto; senza Node ripiega su `--window-size`).
- A mano, una pagina:
```powershell
dotnet run --project src/Encelado.Server -- --sample --port 8085
& "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" --headless=new --disable-gpu --hide-scrollbars --window-size=1440,900 --virtual-time-budget=6000 --user-data-dir=$env:TEMP\edge-shot --screenshot=$PWD\shot.png "http://127.0.0.1:8085/?once=1#/dashboard"
```
- Ogni foto va guardata: niente sbordature, niente fasce grigie, niente pannelli vuoti stirati, controlli allineati.
- In `--sample` i comandi, i salvataggi delle impostazioni e le rotte dei segreti rispondono `{ ok: false }` (HTTP 400,
«modalità dimostrativa»): la pagina mostra il messaggio nella finestra centrale e niente viene salvato. Impostazioni
mostra i valori di fabbrica; il server campione lavora in cartelle temporanee e non tocca configurazione, segreti,
dati o Telegram dell'operatore.
## 11. Per chi modifica l'interfaccia
1. Solo token per i colori; controlli da 30 px; niente `max-width`; niente librerie, CDN, font web, `@import` o
`import()`.
2. I dati diventano nodi di testo (`el()`), mai HTML. Un nuovo numero porta il suo `title`.
3. Una nuova tabella usa `Grid` con righe a chiave e colonne con larghezza; una nuova sezione a richiesta usa `watch()`
con la sua chiave di `versions`. Un campo nuovo del server si scrive prima in `docs/API.md`.
4. `index.html` e `login.html` restano XML ben formato: elementi chiusi, `hidden="hidden"`, niente `xlink:`.
5. Una parola del ledger o del motore (evento, codice di motivo, motivo d'uscita, stato di un ordine, sorgente del log)
passa da `labels.js`: la parola in italiano sullo schermo, il codice nel tooltip. Un valore che il server può mandare
`null` si mostra «—»: mai un conto fatto su `null` (`null × 1e4` è 0 e si stamperebbe «0,0»).
6. Prima di chiudere:
- `dotnet test`: `EmbeddedUiTests` controlla che le due pagine siano XHTML ben formato, che ogni file citato da
`index.html` e ogni `import` statico dei moduli esista e esporti i nomi importati (un nome mancante blocca tutta
l'app con un `SyntaxError`), che nessun file citi un altro host, che i token abbiano i due temi con gli stessi
nomi, che l'app usi `/api/stream` e chieda `CONFERMO LIVE`, e che il login mandi il campo `password` senza
script; `WebHostTests` che ogni file sia servito con il suo tipo e che l'errore di accesso prenda il posto del
segnaposto;
- `node --check` su una copia `.mjs` dei moduli toccati, se Node c'è: su un `.js` Node legge uno script e non vede
gli errori propri dei moduli, come un `import` che si scontra con un `let` e ferma tutta l'app;
- gli screenshot del §10 guardati uno per uno, in entrambi i temi, e la console pulita.
@@ -0,0 +1,31 @@
# ADR-0001 — Broker: eToro
Data: 2026-09-16. Stato: accettata.
## Contesto
La strategia opera otto coppie forex (EURUSD, USDCHF, AUDUSD, USDCAD, NZDUSD, EURNZD, EURAUD, AUDCAD) come CFD. Il bot aveva un adattatore Binance (ritirato: dal 1° luglio 2026 l'utente non può operare in USDT) e un adattatore cTrader mai collegato. Alpaca è esclusa perché non offre forex.
## Decisione
Il modulo basket opera su **eToro Public API** (`https://public-api.etoro.com`), autenticazione con `x-api-key` + `x-user-key` (chiavi diverse per demo e reale, ambiente sempre visibile in UI), `x-request-id` obbligatorio (usato anche come `referenceId` idempotente degli ordini).
Fatti verificati il 2026-09-16 sulla specifica OpenAPI servita dall'API (v1.379.0):
- Quote: `GET /api/v2/market-data/rates?instrumentIds=…` (batch, quota condivisa 120/min).
- Candele: `GET /api/v1/market-data/instruments/{id}/history/candles/{asc|desc}/{FifteenMinutes}/{≤1000}` — senza data di partenza: **non pagina lo storico**.
- Strumenti: `GET /api/v2/market-data/instruments?symbols=…`; eligibility `POST /api/v2/trading/info/{demo/}eligibility`; costi what-if `POST /api/v2/trading/info/{demo/}costs`.
- Conto e posizioni: `GET /api/v1/trading/info/{demo/}pnl` (posizioni con P&L non realizzato, `credit`); saldi `GET /api/v1/balances`.
- Ordini: `POST /api/v2/trading/execution/{demo/}orders` (20/min), esito con `GET /api/v2/trading/info/{demo/}orders:lookup?referenceId=…`; chiusura `POST /api/v1/trading/execution/{demo/}market-close-orders/positions/{id}` con esito in `GET /api/v1/trading/info/{demo|real}/close-orders/{orderId}`; SL/TP `PATCH /api/v2/trading/{demo/}positions/{id}`.
- Storico chiusure: `GET /api/v1/trading/info/trade/{demo/}history?minDate=…`.
## Alternative
- **IC Markets / cTrader**: spread ECN più stretti e Open API con streaming, ma l'utente ha chiesto eToro e usa già l'API; l'adattatore resta nel repo per il motore `proba`.
- **Alpaca**: niente forex.
## Conseguenze
- Nessun order book, spread con markup, esecuzione solo a mercato (o MIT) con SL/TP nativi: il cost gate deve leggere spread e markup reali a ogni decisione.
- Lo storico per il backtest viene dai tick MT5 dell'utente, non dall'API.
- Ogni ordine nasce con uno stop nativo (richiesto per `sellShort` e per leva > 1); il bot gestisce comunque lo stop di basket.
@@ -0,0 +1,31 @@
# ADR-0002 — Storage su file per il modulo basket
Data: 2026-09-16. Stato: accettata.
## Contesto
Il repository ha già un database SQLite (`Encelado.Storage`, unica dipendenza NuGet a runtime) usato dal motore `proba` per barre, dataset, modelli e journal. La specifica del modulo basket chiede storage su file: CSV `;` con `motivazione`, JSONL append-only per ledger e notizie, JSON per modelli e stato, scritture atomiche, rotazione mensile, nessuna riga del ledger modificata.
## Decisione
Il modulo basket **non usa SQLite**. Tutto vive in file sotto `Documenti\Encelado\`:
```
data/market/candles_<SYMBOL>_M15.csv barre M15 bid/ask (dallo strumento ticks e dal delta API)
data/calendar/events.jsonl eventi economici (dedup title+date+country)
data/news/news_YYYYMM.jsonl notizie RSS (dedup hash(link))
data/ledger/decisions.jsonl ogni valutazione di ogni basket (append-only, rotazione mensile in decisions_YYYYMM.jsonl)
data/ledger/baskets.csv una riga per basket chiuso (label, P&L, costi, slippage)
data/models/logreg_v<N>.json, mlp_v<N>.json, bandit.json, state.json
knowledge/calibration.csv, insights_YYYYWW.md, proposals.csv, forward_registry.csv, models_registry.csv, preregistrazione.csv
reports/*.csv, results/trials.csv
```
## Alternative
- Riusare SQLite: comodo per query, ma introduce un binario nativo nel percorso del modulo, contraddice la specifica e rende il ledger modificabile per errore.
## Conseguenze
- Le tabelle si aprono in un foglio di calcolo così come sono; il ledger è verificabile riga per riga.
- L'analisi (ricostruzione del dataset, calibrazione) rilegge i file: costa qualche secondo per centinaia di migliaia di righe, accettabile per un ciclo settimanale.
@@ -0,0 +1,15 @@
# ADR-0003 — Motore cTrader mantenuto selezionabile
Data: 2026-09-16 (mattina). Stato: **superata da ADR-0004** (stesso giorno, pomeriggio).
## Contesto
All'inizio del lavoro sui Correlation Baskets l'albero conteneva un motore probabilistico su cTrader (`proba`) non committato e non compilante. La regola «non toccare i comportamenti esistenti se non richiesto» suggeriva di rimetterlo in compilazione e lasciarlo selezionabile con `engine.strategy = "proba"`, con `"baskets"` come predefinito.
## Decisione (originaria)
Tenere entrambi i motori dietro `IEngine`, con la finestra che sceglie le pagine in base al motore configurato.
## Esito
Nel pomeriggio l'utente ha chiesto la rimozione di tutto ciò che riguarda le gestioni precedenti e, alla domanda esplicita, ha incluso cTrader e la ricerca (D-21). La decisione è registrata in ADR-0004; questo documento resta per la cronologia.
@@ -0,0 +1,19 @@
# ADR-0004 — Rimozione dei motori precedenti (Binance, cTrader/proba, ricerca)
Data: 2026-09-16. Stato: accettata. Sostituisce ADR-0003.
## Contesto
Il repository portava tre generazioni di codice: l'arbitraggio statistico su Binance Futures (con adattatore già rimosso), il motore probabilistico su cTrader con la sua pipeline di ricerca (SQLite, GBDT, RL, TA-Lib, backtest a coppie) e il modulo Correlation Baskets su eToro. ADR-0003 aveva tenuto il motore cTrader selezionabile per non toccare comportamenti esistenti. L'utente ha chiesto un rework completo che elimini «qualsiasi cosa legata a vecchie gestioni (binance, alpaca, ecc ecc)» e, alla domanda esplicita, ha scelto di rimuovere anche cTrader e la ricerca (D-21).
## Decisione
Restano solo `Encelado.Core` (basket, broker, notizie, statistica condivisa), `Encelado.Etoro`, `Encelado.Bot` e lo strumento `tools/Encelado.Backtest` con i tre comandi `ticks`, `baskets`, `falsify`. Sono stati eliminati i progetti `Encelado.CTrader` e `Encelado.Storage`, le cartelle `Core/Backtest`, `Indicators`, `Journal`, `Market`, `Portfolio`, `Research`, `Risk`, `Rl`, `Strategies`, quasi tutto `Ml` (restano `Classification` e `Pbo`) e `Statistics` (restano `Performance`, `Ols`, `Distributions`), il motore `ProbaEngine`, le pagine e i test relativi, il selettore `engine.strategy`, le sezioni di configurazione `ctrader`, `engine`, `strategy`, `risk`, `storage`, `symbols`. Nessun pacchetto NuGet resta nei progetti dell'applicazione.
Il codice rimosso è nella storia git (tag `v3.5.0` e commit `b39e08b`).
## Conseguenze
- Una sola strategia, una sola configurazione, una sola finestra: meno codice da capire e da testare (da 322 a 172 test, tutti sul modulo che gira).
- Le conclusioni delle ricerche precedenti (StatArb su BTC non valida fuori campione, ProbaBot) restano solo nei documenti e nella memoria di lavoro; non sono più riproducibili da questo albero.
- Un file di configurazione della versione precedente viene letto con avvisi mirati («sezione di una versione precedente») e il ripristino dei valori di fabbrica lo riscrive.
@@ -0,0 +1,23 @@
# ADR-0005 — Nessuna approvazione manuale dei singoli ordini
Data: 2026-09-16. Stato: accettata (decisione dell'utente, D-20); **superata in parte da ADR-0010** (5.1): la modalità `Paper` non esiste più (le modalità sono `Demo` e `Live`, e la modalità sceglie anche il conto) e il preset non si cambia più a caldo (si sceglie in Impostazioni ▸ Strategia e vale per i basket nuovi). Resta valida la decisione principale: nessuna approvazione dei singoli ordini.
## Contesto
La specifica prevedeva cinque modalità (`Paper`, `DemoApprove`, `DemoAuto`, `LiveApprove`, `LiveAuto`) con `DemoApprove` predefinita: ogni apertura, aggiunta e take-profit era una proposta che aspettava una persona per quindici minuti. Nella sessione di prova del 2026-09-16 il bot in `DemoApprove` non ha mai potuto operare senza qualcuno alla finestra, e il test lungo richiesto dall'utente («sperando di piazzare trade») non è possibile in quel modo. Alla domanda «posso usare DemoAuto per il test lungo?» l'utente ha risposto: «tutti gli Approve devono sparire, almeno per il momento. Il bot deve girare in completa autonomia aprendo e chiudendo le posizioni senza il mio consenso».
## Decisione
Le modalità diventano tre: `Paper`, `Demo` (predefinita) e `Live`. In tutte il bot esegue da solo le decisioni del decisore. La coda delle approvazioni (`ApprovalQueue`), i comandi `approve`/`reject`, il flag `run.allowDemoAuto` e la conferma all'avvio del demo automatico sono rimossi. I nomi precedenti (`DemoApprove`, `DemoAuto`, `LiveApprove`, `LiveAuto`) vengono ancora letti dal file di configurazione, mappati su `Demo`/`Live` con un avviso.
Restano i gate umani che non riguardano il singolo ordine: la frase `CONFERMO LIVE` all'avvio del reale (con `run.allowLive = true`), il kill-switch, il reset motivato dopo un equity stop, il cambio di preset a caldo.
## Conseguenze
- Le regole «mai un ordine reale senza flag e conferma» restano vere a livello di sessione: il reale non parte senza flag e frase.
- Le uscite protettive erano già automatiche in ogni modalità; ora lo sono anche le aperture e i take-profit.
- Se in futuro servisse una revisione umana, va reintrodotta come modalità esplicita e non come default: la specifica originaria resta documentata qui.
## Aggiornamento 5.1 (2026-09-30)
`Paper` è stata eliminata: il conto demo di eToro fa già da simulatore, con le esecuzioni vere. Un file che dice `Paper` si legge come `Demo` con un avviso; le righe storiche del ledger con `mode = Paper` restano. I gate umani che restano sono l'avvio del reale (`run.allowLive` e la frase `CONFERMO LIVE` scritta nell'interfaccia, a ogni avvio: il Live non parte mai da solo), il kill-switch e il reset motivato; il cambio di preset a caldo non c'è più (ADR-0010).
@@ -0,0 +1,28 @@
# ADR-0006 — Apprendimento: livello 0 e logistica in ombra restano, MLP, bandit e ciclo settimanale si spengono a runtime
Data: 2026-09-23. Stato: accettata con il default di D-30 (§8 del piano 5.0); revocabile con una risposta diversa. **Aggiornata da ADR-0014** (5.1): lo stato in ombra e il criterio di riattivazione restano; il ciclo gira in background nel processo con un solo scrittore dei file e l'interfaccia ha la pagina Apprendimento al posto di Impostazioni ▸ Ricerca.
## Contesto
`docs/STRATEGY.md` dà un verdetto negativo sul backtest (7,75 anni, nessuna configurazione con P&L netto positivo, segnale di circa 2 pip contro 3 pip di costo, walk-forward Sharpe −0,91). Il forward test in Demo ha prodotto **0 basket chiusi** in sei giorni per il difetto degli ordini pendenti (post-mortem), e il ciclo settimanale ha girato a vuoto («ledger senza basket chiusi: niente da addestrare»). Un meta-modello può soltanto filtrare i basket: con un segnale sotto i costi il massimo che può fare è ridurre le perdite, e per attivarsi gli servono almeno 300 basket chiusi, cioè mesi alla frequenza osservata. Nel frattempo il bandit **applicava** il preset da solo in Demo: un parametro cambiato dal bot, contro la regola di `RISK_RULES.md`.
## Decisione
- **Restano attivi**: il ledger (è il dato), il livello 0 (tabelle di calibrazione: quasi gratis, utili a leggere il forward test), la previsione di volatilità (`VolForecaster`, usata dal decisore in modo deterministico per `z_in` effettivo), la regressione logistica **in ombra** (predice `p_ML` nel ledger a ogni chiusura di barra e impara a ogni chiusura di basket; non fa mai da cancello).
- **Si spengono a runtime** (codice conservato nel Core): l'MLP challenger, il bandit di Thompson come attuatore (dalla Fase 1 propone soltanto), il ciclo settimanale. In `strategy.json` la sezione `learning` ha `enabled = false` di fabbrica: con `false` il motore non avvia il ciclo, non addestra il challenger e non può mai attivare il cancello `ml_gate`; il bandit registra i premi e propone nel log.
- **Il ciclo settimanale passa allo strumento** `tools/Encelado.Backtest` (comando `learn` su un ledger esportato), così i modelli si valutano quando ci saranno dati, fuori dal processo che opera. Il comando arriva con la Fase 6, quando `LearningState` si sposta nel progetto portabile `Encelado.Engine` (oggi dipende dal log e dal ledger del Bot).
- **Criterio di riattivazione** (`docs/ML_AND_LEARNING.md`): almeno **300 basket chiusi in Demo** *e* **P&L netto forward ≥ 0** sulla metrica pre-registrata (`knowledge/preregistrazione.csv`). Prima di allora ogni «adattamento automatico» è rumore, e `learning.enabled = true` è una decisione dell'operatore scritta nel file, non del bot.
- **Interfaccia**: il riquadro «Apprendimento» esce dalla dashboard; lo stato del modello in ombra (basket visti, AUC mobile, PSI) e il pulsante «esegui ciclo di apprendimento» vanno in Impostazioni → Ricerca (web UI, Fase 7). Nella finestra WPF resta la riga di stato del modello in ombra, che ora dice «disattivato (ADR-0006)».
## Conseguenze
- Nessun cambiamento nelle decisioni del bot: il cancello ML non era mai stato attivo (0 basket chiusi).
- `strategy.json` cresce della sezione `learning` (`enabled`, `weeklyCycle`, `challenger`); l'hash della configurazione la include.
- I file `data/models/*` e `knowledge/*` restano dove sono e vengono letti dallo strumento.
- Quando il criterio sarà soddisfatto, la riattivazione passa da una proposta in `knowledge/proposals.csv`, dalla pre-registrazione e da `learning.enabled = true`.
## Aggiornamento 5.1 (2026-09-30)
- Il ciclo non vive più solo nello strumento: «Esegui ciclo» nella pagina **Apprendimento** lo esegue in background, nel motore se è acceso o come manutenzione sotto il lock di istanza se è fermo; `backtest learn` resta e prende lo stesso lock (ADR-0014). Il ciclo settimanale nel bot gira solo con `learning.enabled` e `learning.weeklyCycle` accesi, come qui deciso.
- Le etichette della 4.0.0-5.0.0 erano i proceeds delle chiusure, non il P&L (ADR-0011): i modelli addestrati su quelle etichette sono stati ritirati e la logistica riaddestrata sulle etichette corrette; il bandit è ripartito dal prior. Il conteggio verso i 300 basket usa solo le righe con il P&L dello storico eToro.
- Il bandit premia il preset con cui il basket è entrato, non quello in vigore alla chiusura.
@@ -0,0 +1,35 @@
# ADR-0007 — Interfaccia web servita dal bot al posto della finestra WPF
Data: 2026-09-23. Stato: accettata (risposta dell'utente a D-28: «il bot deve essere eseguito SOLO tramite container. Elimina tutta la parte della grafica Windows»). **Superata in parte** nella 5.1: lo stile Material 3 e la struttura a un solo `app.js` da ADR-0013 (interfaccia in stile Mimante, moduli ES, nove pagine); il token `ENCELADO_WEB_TOKEN`, le chiavi da variabili d'ambiente e il file `etoro.keys.enc` da ADR-0010 (password `ENCELADO_PASSWORD`, segreti in `secrets.enc` cifrati con la password); lo snapshot completo a ogni secondo da ADR-0012 (tick v2 condiviso e sezioni a richiesta). Resta valida la decisione principale: interfaccia web, vanilla, servita dal bot.
## Contesto
Fino alla 4.0.0 Encelado era un'applicazione WPF (`Encelado.exe`, `net10.0-windows`) con la modalità `--headless` per i test lunghi. Il post-mortem del 16-21/9 (`docs/POSTMORTEM_ordini_pendenti.md`) ha mostrato che il bot deve girare senza interruzioni su una macchina sempre accesa — il server Unraid dell'utente — e che la finestra era diventata il modo meno affidabile di tenerlo d'occhio: apribile solo sul PC di sviluppo, chiusa con la sessione di Windows, con un secondo motore possibile per sbaglio. Una UI Windows non gira in un container Linux.
## Decisione
1. Il progetto WPF viene **rimosso** (`src/Encelado.Bot/App.xaml`, `MainWindow`, `Ui/*`, tema, finestre di login e prompt, test di binding e di rendering). Il motore passa in `src/Encelado.Engine` (libreria `net10.0`), l'eseguibile è `src/Encelado.Server` (Kestrel).
2. L'interfaccia è **web**, servita dal bot stesso: HTML, CSS e JavaScript incorporati nell'assembly (`EmbeddedResource`), nessun framework, nessun font remoto, nessuna dipendenza NuGet (`Microsoft.AspNetCore.App` è un framework reference dell'SDK). Stile Material 3 (`docs/UI_GUIDELINES.md`).
3. Aggiornamenti via Server-Sent Events (`/api/stream`, uno snapshot al secondo); comandi via `POST /api/commands/<nome>`; storico, log, impostazioni, chiavi e diagnostica via API JSON scritta a mano (`Utf8JsonWriter`). Token locale `ENCELADO_WEB_TOKEN` in cookie HttpOnly; senza token il server ascolta solo su localhost.
4. La verifica visiva dei test WPF (`UiRenderTests`) è sostituita dal test dell'HTML incorporato, dal test dello snapshot JSON, dal test dello stream SSE e dagli screenshot (`docs/img/`) presi dal server in modalità `--sample`.
5. Le chiavi eToro non sono più in DPAPI (Windows): variabili d'ambiente oppure file cifrato `etoro.keys.enc` (AES-256-GCM, passphrase in `ENCELADO_KEY_PASSPHRASE`).
## Alternative scartate
- **Tenere WPF e aggiungere la web UI**: due interfacce da tenere allineate su ogni campo dello snapshot, due catene di test, e la finestra non avrebbe comunque girato dove il bot deve girare. L'utente ha chiesto di eliminarla.
- **Framework JavaScript (React, Vue, Blazor)**: una toolchain npm o una dipendenza NuGet contro la regola «nessun pacchetto»; per quattro pagine e un solo flusso di dati (lo snapshot) il vanilla è sufficiente e più leggibile.
- **Blazor Server**: dipendenza da SignalR e da uno stato per circuito; l'SSE fa lo stesso lavoro con una riga per snapshot.
- **Terminale (TUI)**: non raggiungibile da un telefono in rete locale.
## Conseguenze
- Niente più `net10.0-windows`: tutta la soluzione è portabile e la suite di test gira nello stadio di build dell'immagine Docker (ADR-0008).
- Le regole «una barra in alto, pagine sotto, dettagli nei tooltip» restano; cambia il mezzo. La navigazione diventa un navigation rail a sinistra (80/256 px, stato ricordato).
- La bonifica interattiva, il reset in cinque passi, il kill-switch con la spunta «chiudi anche le esterne» e la frase `CONFERMO LIVE` passano da dialoghi HTML.
- Chi vuole la finestra non ce l'ha più: si apre il browser su `http://<ip>:8080/`.
## Aggiornamento 5.1 (2026-09-30)
- L'interfaccia è stata rifatta nello stile di Mimante (ADR-0013): token propri al posto dei ruoli Material 3, menu a sinistra con nove pagine al posto del rail con quattro, moduli ES statici in `wwwroot/js/` e un foglio di stile per pagina, disegno per celle al posto di `innerHTML`.
- L'accesso è con la password dell'interfaccia (`ENCELADO_PASSWORD`, alias deprecato `ENCELADO_WEB_TOKEN`) e il cookie `encelado_session`, un HMAC della password e di un segreto del server (`/config/session.key`); le chiavi eToro dei due conti e il token Telegram stanno in `/config/secrets.enc`, cifrati con la password, e si inseriscono da Impostazioni (ADR-0010). `etoro.keys.enc` e `ENCELADO_KEY_PASSPHRASE` servono solo all'importazione una tantum di un container 5.0.
- Il flusso è il tick v2, uno al secondo condiviso da tutti i browser, più le sezioni a richiesta con `ETag` (ADR-0012, `docs/API.md`).
@@ -0,0 +1,39 @@
# ADR-0008 — Engine + Server, immagine Docker come pacchetto, Unraid come destinazione
Data: 2026-09-23. Stato: accettata (D-28: «solo tramite container»; D-29: registro dei container di Gitea, icona nel repository). **Superata in parte da ADR-0010** (5.1): il template Unraid ha solo la porta, `/config`, `/data` e la variabile `ENCELADO_PASSWORD`; `PUID`, `PGID` e `TZ` restano default dell'immagine (99, 100, UTC; `TZ` lo aggiunge Unraid da sé) e non stanno più nel template; `/api/info` è diventata un alias di `/api/system`. Restano validi i tre progetti, l'immagine come pacchetto, i volumi, l'entrypoint, l'healthcheck e la catena di rilascio.
## Contesto
Con la finestra WPF ritirata (ADR-0007) il bot ha bisogno di un processo che giri per mesi su una macchina sempre accesa, si riavvii da solo, non dipenda dal PC di sviluppo e sia aggiornabile con un comando. L'utente ha un server Unraid e un Gitea privato con il registro dei container.
## Decisione
1. **Tre progetti applicativi**: `Encelado.Core` (logica pura, zero I/O), `Encelado.Engine` (motore, ledger, feed, configurazione, impostazioni, storico, Telegram; ex `Encelado.Bot` senza UI), `Encelado.Server` (l'eseguibile: `Microsoft.NET.Sdk.Web`, Kestrel, API, UI incorporata, ciclo di vita del processo). `Encelado.Etoro` resta il client HTTP. Lo strumento `tools/Encelado.Backtest` referenzia anche Engine per il comando `learn`.
2. **Il pacchetto è l'immagine Docker** (`Dockerfile` alla radice, multi-stage: restore, build, test, publish framework-dependent, runtime `mcr.microsoft.com/dotnet/aspnet:10.0`). Un'immagine con i test rossi non esiste: `dotnet test` gira dentro lo stadio di build. Il commit arriva come `--build-arg GIT_COMMIT` (il contesto non contiene `.git`) e finisce in `AssemblyMetadata` con la data di build, visibili in Impostazioni ▸ Informazioni e in `/api/info`.
3. **Volumi**: `/config` (encelado.json, strategy.json, instruments.json, chiavi cifrate) e `/data` (ledger, stato, barre, cache, conoscenza, rapporti, log). Il rilevamento del container (`ENCELADO_IN_CONTAINER=1`, o `/config` esistente su Linux) rimappa `run.dataPath` e affini sotto `/data` senza toccare la configurazione dell'utente.
4. **Entrypoint** con `gosu`: `PUID`/`PGID` (default 99/100, `nobody:users` di Unraid) diventano proprietari di `/config` e `/data`; `TZ` regola gli orari a schermo; `exec` del processo dotnet come PID 1 per ricevere `SIGTERM` (arresto pulito: ledger chiuso, heartbeat con nota, posizioni lasciate sul conto con gli stop nativi).
5. **Healthcheck** `dotnet Encelado.Server.dll --health`: interroga `/api/health` (heartbeat fresco se il motore gira, disco scrivibile). Niente `curl` nell'immagine.
6. **Catena di rilascio** (`build/Release.proj`): `Verifica` → `Pubblica` (cartella portabile framework-dependent) → `Docker` (`<registro>/alby96/encelado:<versione>` e `:latest`) → tag → `Rilascia` (push dell'immagine sul registro di Gitea con lo stesso token della release, release con lo zip portabile e il template Unraid allegati). Inno Setup e `Encelado.iss` sono rimossi.
7. **Unraid**: template `deploy/unraid/encelado.xml` (Container v2) con porta 8080, i due volumi sotto `/mnt/user/appdata/encelado/`, tutte le variabili con descrizione in italiano e `Mask` sui segreti; icona `assets/encelado.png` servita come file raw da Gitea (D-29).
## Alternative scartate
- **Servizio Windows / VPS Windows**: obbliga a tenere un Windows acceso e non si aggiorna con un `docker pull`; l'utente ha già Unraid.
- **Pubblicazione self-contained o AOT nel container**: il server ospita ASP.NET Core minimal e non è AOT-compatibile; l'immagine `aspnet` porta già il runtime e resta più piccola di un self-contained.
- **Immagine su Docker Hub o GHCR**: il codice è privato su Gitea; il registro di Gitea usa lo stesso token della release e non richiede altri account.
- **Compose come unica via**: resta per lo sviluppo locale (`docker-compose.yml`), ma la destinazione è il template Unraid.
## Conseguenze
- `Documenti\Encelado` sopravvive solo per l'esecuzione fuori dal container (sviluppo con F5); nel container tutto sta in `/config` e `/data`.
- L'istanza unica per cartella dati (`instance.lock`) vale anche fra un container e un processo locale che montino la stessa cartella.
- Un aggiornamento dell'immagine è un riavvio: il recupero dopo inattività (Fase 4) copre il buco.
- La catena `build/` cambia struttura rispetto a Mimante/AutoBidder (niente installatore): la differenza è documentata in `build/README.md`.
## Aggiornamento 5.1 (2026-09-30)
- **Template**: porta, `/config`, `/data` e «Password interfaccia» (`ENCELADO_PASSWORD`, mascherata e obbligatoria). Conto, chiavi eToro dei due conti, Telegram, valuta, log e avvio automatico si impostano dall'interfaccia (ADR-0010); le variabili di un container 5.0 vengono importate una volta al primo avvio della 5.1 e poi ignorate.
- **Healthcheck**: l'heartbeat è vecchio oltre 3 × `recovery.heartbeatSeconds` + 15 s (105 s con il default), non più una soglia fissa (ADR-0012).
- **Arresto**: con `run.closeOnShutdown` la chiusura la esegue il motore sul suo thread entro 30 s; un kill-switch in corso ha 30 s per finire. I 45 s di grazia del container li coprono.
- **Rete**: il server ascolta su tutte le interfacce solo con la password, nel container; fuori dal container (F5, `run-dev`) solo con `--listen-all`.
- Commit e data di build si leggono in Sistema ▸ Informazioni e in `/api/system` (`/api/info` è un alias).
@@ -0,0 +1,31 @@
# ADR-0009 — Registro persistente degli ordini e adozione delle gambe orfane
Data: 2026-09-23. Stato: accettata (Fase 1 del piano 5.0, `docs/PIANO_5.0.md`; post-mortem in `docs/POSTMORTEM_ordini_pendenti.md`).
## Contesto
Fra il 16 e il 21 settembre 2026 il bot ha lasciato sul conto demo 21 gambe singole senza copertura. L'esito di ogni ordine era cercato con la chiave sbagliata (`referenceId`, che eToro non registra per gli ordini v2), l'ordine senza esito veniva dichiarato «non eseguito» e dimenticato, e la posizione che ne nasceva era «sconosciuta» e per regola intoccabile. Tre difetti che, insieme, hanno trasformato una regola di prudenza («non toccare ciò che non è tuo») in un accumulo di rischio scoperto.
## Decisione
1. **Ogni ordine entra in un registro persistente prima della chiamata HTTP** (`OrderTracker`, `data/state/pending_orders.json`, scrittura atomica). Il registro tiene riferimento cliente, `orderId`, strumento, verso, unità richieste ed eseguite, basket, gamba, orario, ultimo stato del server, esito e posizione. All'avvio viene ricaricato e ogni ordine senza esito viene risolto **prima** di qualsiasi decisione.
2. **La chiave dell'esito è l'`orderId`** (`orders:lookup?orderId=`, ripiego `api/v1/trading/info/{demo/}orders/{id}`). Il riferimento cliente resta nell'intestazione per l'idempotenza e serve solo quando la risposta al `POST` è andata persa. Quando il server non ha traccia sotto nessuna chiave, una posizione dello stesso strumento e verso comparsa entro 90 s dall'invio **è** l'esecuzione (le unità possono differire: il server può ridurre l'ordine).
3. **Nessun esito sintetico.** `OrderOutcome.Status` riporta la parola del server, oppure `Unknown`. Un ordine senza esito allo scadere del timeout della gamba porta il basket in `PendingA` o `PendingB`: nessun nuovo ordine su quel basket, il registro continua a chiedere (ogni 2 s nel primo minuto, poi ogni 10 s, poi ogni minuto), e alla risoluzione l'ingresso viene completato (gamba B, ridimensionata sulle unità eseguite di A), oppure annullato con la chiusura immediata della gamba eseguita se il segnale è decaduto o il bot è bloccato.
4. **Ogni posizione del conto viene classificata** a ogni riconciliazione (`PositionClassifier`): `basket` (gamba nota), `orfana-bot` (id nel registro, oppure strumento + verso + orario entro 90 s coerenti con una riga `segnale_ingresso`/`rifiuto`/`ingresso`/`pending` del ledger), `esterna` (tutto il resto). Le orfane-bot vengono **adottate e chiuse** (tre tentativi, poi blocco delle entrate con avviso); le esterne restano intoccate. Il contatore in dashboard distingue basket aperti, ingressi in attesa, orfane ed esterne.
5. **Il picco di equity è al netto dei movimenti di cassa** (`EquityTracker`): un salto del saldo non spiegato dalle chiusure è un deposito o un prelievo, viene scritto nel ledger come `movimento_di_cassa` e non muove né il picco né il drawdown.
6. **`orders.jsonl`** (append-only) riceve una riga a ogni invio e a ogni cambio di stato: è la fonte della scheda Storico → Ordini.
## Alternative scartate
- *Interrogare in parallelo `orderId` e `referenceId`*: la quota dei lookup (60/min, condivisa con l'esito delle chiusure) non regge due richieste ogni 400 ms per gamba, e il riferimento non è registrato dal server.
- *Adottare le orfane solo con unità ± 1 %*: il server ha ridotto gli ordini a 2 000 USD di margine, le unità non sono un identificatore. La finestra temporale sullo strumento e sul verso lo è, sul conto demo dove nient'altro opera così.
- *Ricomporre il basket con la gamba mancante quando si adotta un'orfana*: rifiutato (default della domanda D-35/§5.4): la gamba è vecchia di un tempo ignoto, il segnale che l'ha generata non c'è più; si chiude.
## Conseguenze
- `IBroker` ha due metodi in più (`LookupOrderByIdAsync`, `CancelOrderAsync`); ogni implementazione, anche quelle di prova, li fornisce.
- `BasketExecutor` accetta un `OrderTracker` e pubblica `ResumeAfterAAsync`, `CompleteAfterBAsync`, `UnwindLegAsync`, `ClosePositionAsync`.
- `BasketEngine` è spezzato in file parziali (loop e decisioni; registro; riconciliazione; stato; comandi; snapshot).
- Il bandit **non applica** più il preset da solo in Demo: propone e basta (D-30).
- Nuovi test (m)-(q) in `tests/Encelado.Tests/ExecutionTests.cs`.
- La bonifica delle orfane esistenti è un comando (`--bonifica` in headless, `bonifica` da console): sul conto demo del 2026-09-23 non c'è niente da bonificare (chiusura manuale del 21/9).
@@ -0,0 +1,47 @@
# ADR-0010 — Configurazione solo dall'interfaccia, un solo segreto nel container
Data: 2026-09-30 (aggiornata il 2026-10-01 con le correzioni della revisione 5.1). Stato: accettata (richiesta dell'utente, `Modifiche.txt` del 2026-09-30). Supera in parte ADR-0005 (le modalità), ADR-0007 (chiavi e token dell'interfaccia) e ADR-0008 (le variabili del template).
## Contesto
La 5.0.0 si configurava in due posti: il file `encelado.json` (dall'interfaccia) e una dozzina di variabili d'ambiente del container (chiavi eToro, ambiente, modalità, conferma Live, valuta, passphrase, Telegram, porta, PUID/PGID, TZ, avvio automatico). Le variabili vincevano sul file a ogni riavvio: una modalità o una valuta cambiata dall'interfaccia tornava indietro al riavvio successivo del container. L'utente ha chiesto che nel container resti **solo la password dell'interfaccia** e che tutto il resto si imposti dalla pagina.
L'analisi della superficie di configurazione ha trovato anche tre difetti di sicurezza:
1. `run.executionMode` e `etoro.environment` erano indipendenti: `Demo` con ambiente `real` mandava ordini sul conto reale **senza** il cancello Live (`allowLive` e la frase).
2. La conferma Live restava attiva per sempre dopo il primo avvio (`StartConfirmed` mai azzerato): un riavvio automatico sarebbe entrato in Live senza la frase.
3. Nessuna impostazione salvata arrivava al motore fino al riavvio del processo; la pagina mostrava il valore vecchio subito dopo il salvataggio.
La revisione della 5.1 (2026-09-30/10-01) ha trovato altri buchi nello stesso perimetro: un file 5.0 con `Live` accanto a `demo` (letto Demo) diventava Live al primo salvataggio qualsiasi; la guardia del cambio di conto leggeva la vista pubblicata, che a metà di un ingresso o durante l'avvio sembra piatta; un solo file di stato veniva riscritto dal motore dell'altro conto; una password errata via `Authorization: Bearer` o cookie non costava niente; una pagina di un altro sito poteva mandare un salvataggio con un form; `--sample` leggeva i segreti veri dell'operatore.
## Decisione
1. **Una sola variabile**: `ENCELADO_PASSWORD` («Password interfaccia» nel template Unraid, mascherata e obbligatoria). `ENCELADO_WEB_TOKEN` resta come alias deprecato, così i container 5.0.0 restano raggiungibili dopo l'aggiornamento (con valori diversi vince `ENCELADO_PASSWORD`). Il cookie di sessione `encelado_session` è un HMAC della password e di un segreto del server (`/config/session.key`, 32 byte casuali creati una volta), mai la password; cambiarla, o cancellare `session.key`, chiude tutte le sessioni. Gli script possono mandare `Authorization: Bearer <password>`.
2. **Accesso dalla rete** (revisione): il server ascolta su tutte le interfacce solo con una password **e** nel container (o con l'argomento `--listen-all`); F5 e `run-dev` tengono la password per i segreti della sandbox ma restano su localhost. Senza password ascolta solo su localhost e non chiede niente. Una password errata — dal form o dall'header Bearer — costa al suo indirizzo un'attesa che raddoppia (1, 2, 4, 8, 16, poi 30 s); finché dura, nessuna password di quell'indirizzo viene controllata (429), così i tentativi in parallelo non servono. L'attesa è per indirizzo, non globale: un altro computer della rete non può tenere fuori l'operatore dal kill-switch. Il cookie non è un tentativo (seconda revisione): con il segreto del server dentro non si calcola da una password indovinata, quindi uno valido entra anche mentre l'indirizzo aspetta (un tentatore dietro lo stesso NAT, /64 o proxy non tiene fuori una pagina già entrata) e uno sbagliato — una scheda rimasta aperta dopo un cambio di password — riceve 401 subito; prima, con il cookie derivato dalla sola password e contato come tentativo, una scheda vecchia teneva l'indirizzo in attesa e la password giusta riceveva 429 finché restava aperta. Una richiesta che cambia qualcosa deve dire `Content-Type: application/json` (415 altrimenti) e venire dalla stessa origine (`Origin` e `Sec-Fetch-Site`, 403 altrimenti); senza password ogni richiesta con un `Host` diverso da `localhost`, `127.0.0.1` o `[::1]` riceve 403 (DNS rebinding).
3. **Segreti cifrati con la password**: le chiavi eToro del conto demo e del conto reale e il token Telegram stanno in `/config/secrets.enc` (AES-256-GCM, chiave PBKDF2-SHA256 600 000 iterazioni dalla password, sale conservato, nonce nuovo a ogni scrittura, intestazione autenticata, file leggibile solo dal proprietario). Senza password (sviluppo) la chiave è un file locale casuale (`secrets.key`), sostituito dalla password appena compare. Se la password cambia il deposito risulta «bloccato»: l'interfaccia offre di sbloccarlo con la password precedente o di ricominciare (il vecchio file resta come `.bak`). Un'intestazione che dichiara meno di 100 000 o più di 10 000 000 iterazioni è un file danneggiato, bloccato prima di derivare qualsiasi chiave. I segreti non entrano mai nell'oggetto di configurazione condiviso: motore e storico ne ricevono una copia privata.
4. **Importazione una tantum** dai container 5.0.0: al primo avvio le variabili vecchie vengono portate nel deposito cifrato e in `encelado.json` (`import-5.1.json` registra cosa è stato fatto) — le chiavi nell'ordine di precedenza della 5.0 (ambiente, poi chiavi scritte nel file, poi il vecchio `etoro.keys.enc` con `ENCELADO_KEY_PASSPHRASE`, rinominato `.migrato`), ciascuna solo in uno spazio vuoto; token e chat di Telegram; le impostazioni solo quando differiscono dal valore di fabbrica e il file è ancora di fabbrica. Poi ogni variabile rimasta viene ignorata e segnalata («puoi toglierla dal container») nel log e in Sistema. `TZ` e la conferma Live non vengono mai importate. Il caricatore della configurazione non legge più l'ambiente.
5. **Paper eliminata**: il conto demo di eToro fa già da simulatore. Le modalità sono `Demo` e `Live` e **determinano il conto** (demo o reale): `etoro.environment` non esiste più come impostazione. Un file della 5.0 viene letto con la regola di fusione (Live solo se modalità Live **e** ambiente `real`, altrimenti Demo, con un avviso) e, quando un salvataggio o l'importazione tolgono `etoro.environment`, al suo posto viene scritta la modalità che il file intendeva (revisione: prima un `Live` + `demo` diventava Live al primo salvataggio).
6. **Cancello Live**: `run.allowLive` più la frase `CONFERMO LIVE` scritta nell'interfaccia, all'avvio e prima di un cambio che riavvia il motore in Live. Nessuna variabile e nessun argomento da riga di comando. **Il Live non parte mai da solo**: né all'avvio del container né dopo un riavvio automatico (allarme e avviso Telegram «premi AVVIA»).
7. **Cambio di conto (Demo ↔ Live)** rifiutato finché sul conto in uso c'è qualcosa in sospeso. Dalla revisione: **lo stato è per conto** (`data/state/baskets_state.demo.json` e `baskets_state.live.json`, D-53), quindi un cambio non sovrascrive né scarta niente dell'altro conto; il registro degli ordini resta un file solo, ma ogni motore vede e risolve solo gli ordini del suo conto. Con il motore acceso il controllo lo fa **il motore stesso, sul suo thread di decisione**: prima blocca nuove entrate e aggiunte, poi riconcilia con il conto (seconda revisione: una gamba del bot che nessuno slot tiene, come la gamba A rimasta quando la sua richiusura è rifiutata, compare solo alla riconciliazione successiva, fino a 20 s dopo; se le posizioni non si leggono il cambio è rifiutato), poi conta sui propri basket (posizioni, gambe in attesa, ingressi, aggiunte o uscite in corso, errori con una gamba, ordini senza esito, orfane e residui, chiusure in attesa del P&L). Rifiutato mentre il motore si avvia, si ferma o non risponde in 30 s. Dopo l'arresto, prima di avviare l'altro conto, il file del conto lasciato viene giudicato di nuovo; se non è piatto `encelado.json` e `strategy.json` tornano byte per byte come prima. A motore fermo decide il file del conto in uso.
8. **Preset fisso**: si sceglie in Impostazioni ▸ Strategia ed è scritto in `strategy.json`; il comando per cambiarlo a caldo è stato tolto. Un cambio di strategia vale per i basket nuovi: quelli aperti conservano lo z di stop, le aggiunte massime, il TP, la perdita massima e il preset con cui sono entrati.
9. **Applicazione a caldo**: dopo ogni salvataggio la configurazione in memoria torna uguale al file e le modifiche si applicano subito (log, Telegram, interfaccia), nel motore sul thread di decisione (strategia, intervalli, timeout; riga `configurazione` nel ledger con il nuovo hash) oppure con un riavvio automatico del motore senza chiudere i basket (modalità, chiavi del conto attivo, coppie dei basket, `preferDirectCross`). Il riavvio passa dal lucchetto del ciclo di vita del supervisore (ADR-0012): riavvia solo un motore ancora acceso (un FERMA arrivato prima vince) e mai a metà di un kill-switch, di una chiusura o della chiusura dei residui (409 prima di scrivere). La risposta dice, campo per campo, cosa è successo.
10. **Avvio automatico** come impostazione (`run.autostart`, attiva di fabbrica); `--no-autostart` resta per lo sviluppo.
11. **`--sample`** lavora in cartelle temporanee cancellate all'uscita: non legge né scrive configurazione, segreti e dati dell'operatore, non apre il suo bot Telegram; le Impostazioni mostrano i valori di fabbrica e ogni scrittura risponde 400.
## Alternative scartate
- **Tenere le variabili come override**: è la causa del «torna indietro al riavvio» e l'utente le vuole fuori.
- **Segreti in chiaro in `/config`**: chi legge la share di appdata avrebbe le chiavi del conto.
- **Chiave di cifratura casuale salvata accanto ai segreti**: equivalente al chiaro per chi legge `/config`; la password del container non sta su quel volume.
- **Riavviare il motore a ogni salvataggio**: interrompe decisioni e riconciliazioni per cambi che non ne hanno bisogno.
- **Un solo file di stato con una sezione per conto**: un motore avrebbe comunque riscritto il file intero, e un errore di scrittura avrebbe toccato anche l'altro conto. Due file, ciascuno scritto solo dal suo motore, non si toccano mai.
- **Attesa dopo una password errata unica per tutto il server**: chiunque nella rete potrebbe tenerla accesa e lasciare l'operatore fuori dall'interfaccia, kill-switch compreso.
## Conseguenze
- Il template Unraid ha la porta, le due cartelle e la password; nient'altro. `TZ` lo aggiunge Unraid da sé (vale solo per gli orari mostrati dal server e nel log); PUID/PGID restano 99/100 nell'immagine.
- Cambiare la password del container obbliga a sbloccare i segreti con quella vecchia o a reinserirli. Rinominare `ENCELADO_WEB_TOKEN` in `ENCELADO_PASSWORD` con lo stesso valore li lascia leggibili.
- Un container Live che si riavvia resta fermo finché qualcuno non preme AVVIA: le posizioni aperte hanno solo gli stop nativi nel frattempo.
- Dietro un reverse proxy l'attesa dopo una password errata vale per tutti i client che il proxy fa sembrare uno; il proxy deve passare l'`Host` originale (o `X-Forwarded-Host`), altrimenti ogni salvataggio riceve 403.
- Le righe storiche del ledger con `mode = Paper` restano come sono.
- Il primo avvio dopo l'aggiornamento migra il file di stato unico una volta sola (resta come `.migrato`): un file della 5.1 al conto del suo `mode`; uno della 5.0, il cui `mode` è la modalità e non il conto, al conto su cui operava la configurazione della 5.0, che l'importazione registra in `import-5.1.json` (`legacyState`: un `Live` accanto a `demo` è il conto demo, un `Demo` accanto a `real` il reale). Lo stato di Paper, o scritto con un'altra modalità, non viene ripreso (seconda revisione: un file `Live` del conto demo finiva al conto reale e il suo saldo diventava un «prelievo»).
@@ -0,0 +1,36 @@
# ADR-0011 — Il realizzato viene dallo storico di eToro
Data: 2026-09-30 (aggiornata il 2026-10-01 con le correzioni della revisione 5.1). Stato: accettata.
## Contesto
L'utente ha segnalato un «P&L oggi» di circa 47 000 USD su un'equity di 139 000. La causa: dalla 4.0.0 l'esito di una chiusura (`GET …/close-orders/{orderId}`) veniva letto dal campo `proceeds`, che per eToro è il denaro restituito al conto (margine liberato più profitto), non il profitto. Verificato sul conto demo: dal 23/9 al 30/9 il bot ha chiuso 102 posizioni con un risultato netto di **−269,42 USD**, mentre la somma di investimento più profitto delle stesse chiusure superava i 903 000 USD; il 24/9, sei chiusure con +48,34 USD di netto contavano come circa 53 900 USD.
Lo stesso numero finiva nel «P&L oggi», nelle righe di `baskets.csv` e quindi nelle etichette dell'apprendimento (quasi tutte «vinto»), nei premi del bandit, nei messaggi Telegram e nel controllo della perdita giornaliera, che dopo la prima chiusura del giorno non poteva più scattare. La pagina Storico era giusta: legge lo storico di eToro.
La risposta della chiusura non ha un campo di profitto (verificato sulla specifica dell'API v1.383): ha `proceeds` e, per posizione, prezzo, unità, tasso di conversione e importo chiuso.
## Decisione
1. **Il realizzato di una posizione è quello dello storico di eToro**: `netProfit − fees` della riga con lo stesso `positionId` (l'`orderId` dello storico è l'ordine di apertura, non la chiusura). È la stessa fonte della pagina Storico. `proceeds` non diventa mai P&L.
2. **Stima provvisoria** dalla risposta della chiusura (unità × differenza di prezzo × tasso di conversione − costi), verificata contro lo storico su tre operazioni reali al centesimo. Serve solo finché lo storico non conferma.
3. **Coda di regolamento** persistente nello stato del motore: la riga di `baskets.csv` viene scritta con il numero dello storico quando conferma; dopo 30 minuti senza conferma viene scritta la stima, marcata «P&L: stima», che non addestra mai i modelli. **Una posizione, una riga** (revisione): una posizione già scritta in `baskets.csv` o già in coda non viene registrata di nuovo da nessun percorso (uscita del basket, residuo del kill-switch, riconciliazione, orfana richiusa); le gambe di un basket rimaste nel residuo di un kill-switch diventano una riga sola, come basket, quando sono tutte chiuse.
4. **«P&L oggi»** = somma di `netProfit − fees` delle posizioni **del bot** chiuse nella giornata UTC, ricalcolata dallo storico (più le stime non ancora confermate, segnalate). È uguale al periodo «oggi» della pagina Storico. Accanto: la variazione dell'equity netta da mezzanotte (realizzato più variazione dell'aperto, movimenti di cassa esclusi). Sconosciuto (storico non ancora letto) = «—», mai 0.
5. **Perdita giornaliera** = calo dell'equity netta dalle 00:00 UTC rispetto a quella di inizio giornata, come nel backtest e in `docs/RISK_RULES.md`; una funzione sola per motore e backtest. **Raggiunta una volta, blocca nuove entrate e aggiunte fino alle 00:00 UTC anche se l'equity risale** (D-52, revisione: prima il blocco cadeva appena l'equity tornava sopra la soglia, mentre interfaccia e ledger promettevano «fino a domani»). Il giorno del blocco è nello stato del conto e sopravvive a un riavvio. Un calo del saldo che lo storico non spiega ancora (forse un prelievo) sospende subito le entrate ma blocca la giornata solo quando risulta una perdita (D-54); la sospensione dura finché lo storico non lo spiega, anche se intanto l'equity recupera, e quella lettura giudica la giornata sull'equity più bassa vista nel frattempo, contando un prelievo come uscito prima del minimo e un deposito come arrivato dopo (seconda revisione: una perdita spiegata dopo un recupero non bloccava più la giornata).
6. **Saldo all'avvio** (revisione): il saldo salvato si giudica — chiusure contro movimenti di cassa — solo quando lo storico mostra ogni posizione chiusa da allora; altrimenti resta il riferimento e giudica la riconciliazione che la vede, come in sessione. Una chiusura non ancora nello storico non viene mai scritta come prelievo.
7. **Correzione del passato senza toccare il ledger**: all'avvio, sul conto in uso, una verifica idempotente ritrova il realizzato vero di ogni riga scritta dalla 4.0.0/5.0.0 e aggiunge righe `correzione` (tipo `pnl_realizzato`) in `decisions.jsonl`; un lettore corretto le applica; la feature `lastNOutcomes`, calcolata sulle etichette sbagliate, viene neutralizzata (0,5) per le righe precedenti alla correzione; i modelli addestrati su quelle etichette vengono ritirati (messi da parte in `data/models/ritirati/`), la logistica viene riaddestrata sulle etichette corrette e il bandit riparte dal prior. Dalla revisione la verifica tiene una soglia **per conto** (la nota `verifica_realizzato` porta `mode`; le modalità 4.0 `LiveAuto`/`LiveApprove` contano come Live), abbina ogni gamba singola della 4.0-5.0 alla sua nota solo per stesso `basket_id`, una nota per riga e in ordine di tempo (un abbinamento ambiguo lascia la riga non verificabile invece di indovinare), e il ritiro dei modelli è tutto o niente. Le righe dell'altro conto si correggono quando quel conto gira: quell'avvio, se il ritiro c'è già stato, neutralizza di nuovo `lastNOutcomes` fino ad allora e rifà la sola logistica (seconda revisione).
8. Una lettura dello storico fallita è un errore, mai un elenco vuoto: nessuna chiusura viene contata 0 per un problema di rete.
## Alternative scartate
- **`proceeds` meno l'importo investito**: semantica non documentata, costi non chiari, non copre le chiusure fatte dagli stop nativi o a mano.
- **Accumulare il realizzato chiusura per chiusura**: si perde le chiusure non fatte dal bot (stop nativi, chiusure manuali), può contare due volte dopo un riavvio e si allontana dalla pagina Storico.
- **Riscrivere `baskets.csv`**: vietato (il ledger non si modifica mai).
- **Rivalutare la perdita giornaliera a ogni decisione** (come faceva la prima 5.1 e il backtest): un'equity che oscilla intorno alla soglia apriva e chiudeva il blocco più volte al giorno; il blocco fino a mezzanotte è la regola scritta ed è la più prudente.
## Conseguenze
- Una lettura dello storico in più ogni tanto (quota Default, circa 0,2-1 al minuto contro 55 disponibili).
- I messaggi Telegram e le righe di log già inviati con i valori sbagliati restano sbagliati: lo dice la cronologia.
- Il primo avvio della 5.1 scrive le correzioni e ritira i modelli; il ciclo di apprendimento successivo rigenera calibrazione e intuizioni. Un'installazione che aveva già fatto la verifica con la prima 5.1 (nota senza `mode`) la ripete una volta, senza effetti, e scrive una nota per conto.
- Il backtest applica lo stesso blocco fino a mezzanotte (`ReplayDailyLoss`): i numeri di `docs/STRATEGY.md` §3, fatti prima, vanno rifatti insieme ai limiti di margine.
@@ -0,0 +1,38 @@
# ADR-0012 — Il motore pubblica viste immutabili; un solo tick condiviso per tutti i browser; un solo lucchetto per il ciclo di vita
Data: 2026-09-30 (aggiornata il 2026-10-01 con le correzioni della revisione 5.1: il lucchetto del ciclo di vita e la chiusura all'arresto sul thread di decisione). Stato: accettata.
## Contesto
L'utente ha trovato l'interfaccia della 5.0 «lenta e pesante» e ha chiesto che non rallentasse il bot. L'analisi ha trovato:
- ogni browser aperto faceva costruire e serializzare al server lo snapshot completo una volta al secondo (N schede = N costruzioni al secondo), con dentro 200 righe di log (35-45 KB a tick);
- la costruzione dello snapshot leggeva dal thread web lo stato del thread di decisione senza sincronizzazione (righe incoerenti, possibili eccezioni «collection was modified»), prendeva cinque lock usati anche dal motore e aveva effetti collaterali: chiedeva una previsione di volatilità che finiva in una coda mai svuotata e cambiava il modello di volatilità attivo, che a sua volta scala la soglia di ingresso;
- il browser ricostruiva con `innerHTML` tabelle e liste intere a ogni tick, su ogni pagina e anche a scheda nascosta;
- il ciclo di decisione aspettava il download di tredici feed.
La revisione della 5.1 ha trovato lo stesso problema nel ciclo di vita del motore: un FERMA arrivato mentre AVVIA (o un riavvio automatico delle impostazioni) costruiva il motore dichiarava il bot fermo e lasciava un motore che operava senza che kill-switch, FERMA e comandi lo raggiungessero; un riavvio automatico poteva annullare un FERMA arrivato prima; un comando in coda a un motore che si fermava aspettava 120 s e rispondeva 500; con `closeOnShutdown` il supervisore chiamava la chiusura del motore dal proprio thread, in concorrenza con il ciclo di decisione.
## Decisione
1. **Il thread di decisione pubblica viste immutabili** (`Volatile.Write`) alla fine di ogni giro, dopo le quotazioni, le transizioni, i comandi e le riconciliazioni. Il thread web legge solo quelle. Costruire una vista non ha effetti collaterali.
2. **Un solo tick al secondo, condiviso**: il server serializza una volta sola e manda gli stessi byte a tutti i client SSE; se nessuno è connesso non calcola niente; un client lento riceve solo l'ultimo tick.
3. **Tick piccolo**: le righe di log sono solo quelle nuove dall'ultimo tick; le sezioni pesanti (posizioni, mercato, sistema, dettaglio basket, apprendimento) sono rotte a richiesta con `ETag`, rilette dal browser solo quando il loro numero di versione nel tick cambia.
4. **Il browser** aggiorna solo la pagina visibile, una volta per frame, cella per cella (righe con chiave, nessun `innerHTML` per i dati), con formattatori in cache; chiude lo stream quando la scheda resta nascosta.
5. **I feed (calendario, notizie) si aggiornano in background** e appartengono al processo: il ciclo di decisione non aspetta più la rete dei feed, e la pagina Mercato resta aggiornata anche a motore fermo.
6. **Nessun metodo del motore si chiama da un altro thread** (revisione): tutto ciò che cambia lo stato del motore è un comando eseguito sul thread di decisione, compresa la chiusura all'arresto (`run.closeOnShutdown`: comando `Shutdown`, che prima blocca nuove entrate e aggiunte, poi chiude basket, gambe in attesa e orfane entro 30 s, e solo dopo il ciclo viene annullato), il controllo del cambio di conto (ADR-0010) e l'applicazione delle impostazioni. Ogni comando riceve una risposta: quelli rimasti in coda o interrotti da un arresto rispondono subito «comando interrotto: il motore si è fermato» e finiscono nel ledger; un'attesa scaduta è 504 con un messaggio, mai 500.
7. **Un solo lucchetto per il ciclo di vita** (revisione): il supervisore serializza avvio, arresto, riavvio automatico, rilascio di un motore in errore e ciclo di apprendimento a motore fermo, ciascuno dal primo controllo all'ultimo cambio di stato. Ogni avvio ha un numero di generazione e un arresto pulisce solo il motore che ha fermato; lo stato resta «stopping» finché il motore vecchio non ha lasciato il lock di istanza, così AVVIA subito dopo FERMA aspetta invece di fallire. Un kill-switch, una chiusura, la chiusura dei residui o una chiusura della bonifica in coda o in corso non vengono mai tagliati: FERMA e i salvataggi che riavvierebbero il motore rispondono 409, finché il motore li ha in mano — li conta lui stesso, dalla coda alla fine sul thread di decisione, non il chiamante, che può andarsene (scheda chiusa, 504 dopo 120 s, poller Telegram fermato: seconda revisione); solo l'arresto del processo li interrompe dopo 30 s, e un kill-switch interrotto registra il residuo (Halted-Residuo) invece di un blocco pulito.
8. **Il controllo di salute segue il battito che il motore pubblica**: l'intervallo dell'heartbeat (`recovery.heartbeatSeconds`, cambiabile a caldo) viaggia nella vista; `/api/health` dà l'allarme oltre 3 × intervallo + 15 s.
## Alternative scartate
- **Lock condivisi fra web e motore**: ogni lettura della pagina rallenterebbe il ciclo di decisione, ed è il problema che si voleva togliere.
- **Un `CancellationToken` per interrompere i comandi critici**: un kill-switch tagliato a metà lascia posizioni senza nessuno che le guardi; meglio rifiutare il FERMA e lasciar finire.
- **WebSocket al posto di SSE**: un canale bidirezionale non serve (i comandi sono POST) e porterebbe uno stato per connessione.
## Conseguenze
- Da N a 1 costruzioni al secondo (0 senza browser aperti); tick da ~40 KB a pochi KB.
- Il formato del tick cambia (v2, `docs/API.md`): l'interfaccia 5.0 non è compatibile.
- Un campo nuovo dello stato passa dalla vista pubblicata, non da una lettura diretta dal thread web.
- FERMA durante un kill-switch risponde 409 e va ripetuto quando il kill-switch è concluso; `docker stop` concede 30 s a un kill-switch in corso (il container ne ha 45 di grazia).
@@ -0,0 +1,43 @@
# ADR-0013 — Interfaccia in stile Mimante
Data: 2026-09-30. Stato: accettata (richiesta dell'utente, `Modifiche.txt` del 2026-09-30). Modifica ADR-0007: l'interfaccia resta web, vanilla e servita dal bot; cambiano il linguaggio visivo, la struttura dei file e il modo di disegnare.
## Contesto
L'interfaccia della 5.0 (un solo `app.js` e un solo `app.css` in stile Material 3, quattro pagine con un navigation rail) era, per l'utente, «lenta e pesante», e lui non voleva che la grafica rallentasse il bot. Ha chiesto di rivederla completamente con lo stile del suo altro progetto, Mimante (`C:\Sviluppo\Mimante\Mimante`), e ha elencato cosa non andava:
- una dashboard compatta che riassuma tutto in una schermata, con altre schede che approfondiscono ogni parte (lo stato di Telegram e il dettaglio del collegamento eToro escono dalla dashboard);
- layout fluido, senza larghezza massima e senza la fascia grigia a destra;
- controlli allineati e della stessa altezza (nel Log «Segui» non era allineato con il filtro e la ricerca);
- niente selettore della valuta nella barra in alto (solo in Impostazioni);
- niente scritte «in esecuzione» e «demo» in fondo alla barra laterale: altrove, anche con simboli;
- un solo orologio per paese delle valute trattate, con le bandiere, più il fuso del computer solo se diverso (D-49), al posto di UTC + fuso;
- il log con il livello come etichetta colorata e ogni messaggio su una riga;
- una pagina dedicata all'apprendimento.
La lentezza aveva anche cause sul server (ADR-0012): lo snapshot completo ricostruito per ogni browser ogni secondo. La parte del browser era il ridisegno con `innerHTML` di tabelle intere a ogni tick, su ogni pagina e anche a scheda nascosta.
## Decisione
1. **Resta ADR-0007**: HTML, CSS e JavaScript vanilla, incorporati nell'assembly e serviti dal bot; nessun framework, nessuna libreria, nessun CDN, nessun font remoto, nessun `@import` né `import()` dinamico.
2. **Linguaggio visivo di Mimante**: token in `css/tokens.css` (tema scuro predefinito, chiaro con gli stessi nomi), colore solo dai token e con un significato (neutro secondario, accento primario, verde/ambra/rosso per ok/attenzione/pericolo, oro per il notevole), testo a 13 px con cifre tabulari, controlli alti 30 px, barra in alto di 46 px, menu a sinistra di 212/56 px con icone, nessuna `max-width`, tooltip su ogni numero, niente toast (una finestra al centro solo per errori, conferme e risultati importanti), bottoni a icona con `title` e `aria-label`.
3. **Struttura a moduli ES**: `index.html` è solo lo scheletro (XHTML ben formato), `js/app.js` importa staticamente gli altri moduli (`state`, `stream`, `util`, `grid`, `ui`, `charts`, `dialog`, `actions`, `baskets`, `labels`, `icons`, `flags`, `clocks`, `split`) e una pagina per file in `js/pages/`; un foglio di stile per pagina in `css/pages/`. `login.html` non ha script (`/js/*` chiede la sessione). Ogni file sotto `wwwroot/` è servito al suo percorso con `ETag` e 304.
4. **Nove pagine**: Dashboard (tutto in una schermata a 1440×900), Basket, Posizioni, Mercato, Storico, Apprendimento, Log, Sistema, Impostazioni, più la pagina di accesso. Lo stato del motore e il conto sono la pill nella barra in alto; gli allarmi una striscia sotto la barra.
5. **Disegno**: un solo store alimentato dal tick (ADR-0012); solo la pagina visibile disegna, una volta per frame; righe con chiave e aggiornamento per cella; nessun `innerHTML` con dati; formattatori `Intl` in cache; lo stream si chiude dopo 15 s di scheda nascosta.
6. **Parole del ledger in italiano**: evento, codici di motivo, motivi d'uscita, stati degli ordini, sorgenti del log passano da `js/labels.js`; il codice resta nel tooltip.
Le regole complete sono in `docs/UI_GUIDELINES.md`; il contratto dei dati in `docs/API.md`.
## Alternative scartate
- **Tenere Material 3 e correggere solo le prestazioni**: l'utente ha chiesto lo stile di Mimante, e il ridisegno per celle richiedeva comunque di riscrivere ogni pagina.
- **Un framework (React, Vue, Svelte) o una libreria di componenti**: contro la regola «nessuna libreria» e con una catena di build npm da mantenere.
- **Pagine caricate con `import()` dinamico**: il primo caricamento sarebbe più leggero, ma i test dell'HTML incorporato (che controllano ogni `import` e i nomi esportati) e la regola «nessun caricamento nascosto» lo escludono; il peso misurato a runtime è comunque piccolo.
## Conseguenze
- Circa 295 KB di JavaScript non minificato (circa 90 KB con gzip) e 60 KB di CSS, sopra l'obiettivo di 150 KB: pesano i tooltip in italiano, le etichette del ledger e le nove pagine importate staticamente. Kestrel non comprime i file statici (possibile miglioramento).
- Lavoro del thread principale misurato sul server vero: circa 64 ms ogni 10 s sulla dashboard, heap fra 1,5 e 2,1 MB.
- `EmbeddedUiTests` controlla ogni `import` statico e i nomi esportati: un nome mancante fermerebbe tutta l'app con un `SyntaxError`.
- Le foto in `docs/img/` si rifanno con `scripts/screenshots.ps1|.sh` (Edge headless; la foto da telefono passa dal protocollo DevTools perché Edge per desktop non stringe la finestra sotto circa 500 px).
- L'interfaccia della 5.0 non è compatibile con il tick v2 e non esiste più.
@@ -0,0 +1,34 @@
# ADR-0014 — Ciclo di apprendimento in background, con un solo scrittore dei file
Data: 2026-09-30 (aggiornata il 2026-10-01 con le correzioni della revisione 5.1). Stato: accettata. Aggiorna ADR-0006: lo stato in ombra e il criterio di riattivazione restano; cambia dove e come gira il ciclo.
## Contesto
L'utente ha chiesto una pagina con «le informazioni sull'apprendimento in corso e su ciò che è stato imparato, raccogliendo e mostrando più dati possibile», con un comando per eseguire il ciclo. Nella 5.0 il ciclo aveva quattro difetti che una pagina avrebbe reso evidenti:
- **due scrittori**: «Esegui ciclo» (Impostazioni ▸ Ricerca) con il bot acceso girava nel processo accanto al motore e riscriveva gli stessi file dei modelli (`data/models`, `knowledge/`): aggiornamenti persi, JSON scritti a metà che alla lettura successiva azzeravano il modello, versioni duplicate, e il motore che non ricaricava mai il modello nuovo;
- **ciclo sul thread di decisione**: il ciclo settimanale addestrava con il lock dell'apprendimento preso, fermando quotazioni e uscite per tutta la durata;
- **risultati buttati**: il ciclo calcolava AUC con intervallo, Brier, calibrazione, P&L filtrato, Sharpe e DSR e ne teneva una riga di testo;
- **file scritti da chi non doveva**: un motore rifiutato dal lock di istanza (un secondo bot sulla stessa cartella) salvava comunque lo stato dell'apprendimento all'uscita; l'MLP challenger veniva addestrato anche con `learning.challenger` spento.
## Decisione
1. **Un solo scrittore** di `data/models` e `knowledge/`: chi tiene il lock di istanza della cartella dati (`data/state/instance.lock`). Il motore costruisce lo stato dell'apprendimento solo dopo aver preso il lock e lo salva, sotto il suo lock, prima di rilasciarlo; un motore rifiutato dal lock non scrive niente. A motore fermo il ciclo gira come **manutenzione** che prende lo stesso lock (AVVIA risponde 409 finché dura); lo strumento `backtest learn` lo prende o si rifiuta con il nome di chi lo tiene.
2. **Il ciclo è una funzione pura in background** (`LearningCycle.Train`): legge il ledger in condivisione, senza esserne lo scrittore, e restituisce modelli, valutazione e base di conoscenza senza toccare niente; si interrompe fra un fold, un seme o un'epoca e l'altro quando il motore si ferma. Il thread di decisione lo **applica** fra due tick in pochi millisecondi (`LearningState.Apply`): sostituisce i modelli, rigioca sui modelli nuovi i basket chiusi mentre il ciclo si addestrava, aumenta la versione, scrive ogni file intero (`.tmp` con nome unico e rinomina, `AtomicFile`). Il ciclo settimanale usa lo stesso percorso.
3. **«Esegui ciclo»** (`POST /api/commands/learn`): motore acceso → comando al motore, risposta immediata, avanzamento nella pagina; motore fermo o in errore → manutenzione sotto il lock; rifiutato (409) con un ciclo già in corso, con il motore che si avvia (finché il ciclo di decisione non è partito) o si ferma, o con il lock tenuto da un altro processo.
4. **La valutazione non si butta**: `data/models/last_cycle.json` tiene la valutazione completa di ogni ciclo (logistica e challenger) e il riepilogo del dataset; la pagina la mostra.
5. **La pagina non scrive**: a motore acceso il thread di decisione pubblica un rapporto immutabile (a ogni chiusura di barra e di basket, dopo un ciclo e un comando, all'avvio e ogni minuto); a motore fermo lo stesso rapporto si legge dai file in sola lettura (`LearningDiskReader`: nessuna cartella creata, file aperti in condivisione, righe a metà scartate, mai un `Ledger` o un `LearningState` costruiti).
6. **Correzioni della revisione** sullo stesso principio: il ritiro dei modelli addestrati sui proceeds (ADR-0011) è tutto o niente (i file si spostano prima, i modelli si sostituiscono dopo; una riga del registro che non si scrive non fa ripetere il ritiro); dopo la verifica del realizzato all'avvio il motore rilegge dal ledger corretto gli esiti di `lastNOutcomes` e il conteggio dei basket etichettati, anche se il ritiro fallisce; una `p_ML` viaggia con i contributi e l'intercetta del modello che l'ha data, salvati con l'ingresso in `learning_state.json`, così la pagina non spiega mai una p con un modello che non l'ha prodotta.
## Alternative scartate
- **Tenere il ciclo solo nello strumento `backtest learn`** (come diceva ADR-0006): con il bot acceso il lock lo impedisce, e chiedere all'operatore di fermare il bot per addestrare un modello in ombra è sproporzionato.
- **Un lock dei file condiviso fra il motore e un secondo scrittore**: due processi che scrivono gli stessi file restano due scrittori; un'applicazione sbagliata a metà resterebbe possibile.
- **Addestrare sul thread di decisione, ma più in fretta**: con 5 fold, 5 semi e l'early stopping dell'MLP la durata non è prevedibile, e quotazioni e uscite non devono mai aspettare un modello in ombra.
## Conseguenze
- Il ciclo settimanale gira nel bot solo con `learning.enabled` e `learning.weeklyCycle` accesi (ADR-0006 resta: di fabbrica tutto in ombra); «Esegui ciclo» funziona in ogni stato.
- Con il bot acceso `backtest learn` sulla stessa cartella si rifiuta: si usa «Esegui ciclo».
- `learning_state.json` passa allo schema 2 (legge quello della 5.0; le coppie dell'AUC mobile calcolate con la p ricalcolata alla chiusura vengono scartate alla prima lettura).
- Un ciclo a motore fermo tiene AVVIA in attesa per qualche secondo (409 con il motivo).
Binary file not shown.

After

Width:  |  Height:  |  Size: 145 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 127 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 180 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 178 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 159 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 182 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 11 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 164 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 75 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 95 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 124 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 164 KiB

+14
View File
@@ -0,0 +1,14 @@
test;variante;n_baskets;win_rate;pnl_net;sharpe;maxdd;p1_pnl;p5_pnl;break_even_cost;avg_cost_pips;psr;dsr;motivazione
1_segnale;ZScoreSynthetic;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
1_segnale;PipDivergence;3124;0.4238;-9406.4611;-3.7746;0.9412;-75.4011;-31.0045;-0.6061;3.1477;0;0;3124 basket, win rate 42 %, netto -9406 USD, Sharpe -3.77, DD 94.1 %, 1% -75 USD, 5% -31 USD: perde al netto dei costi assunti
2_averaging;Off x1.0;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
2_averaging;AddOnce x1.0;2123;0.5087;-9689.2745;-3.2225;0.9693;-115.115;-55.905;0.282;3.1382;0;0;2123 basket, win rate 51 %, netto -9689 USD, Sharpe -3.22, DD 96.9 %, 1% -115 USD, 5% -56 USD: perde al netto dei costi assunti
2_averaging;Grid x1.0;2123;0.5087;-9689.2745;-3.2225;0.9693;-115.115;-55.905;0.282;3.1382;0;0;2123 basket, win rate 51 %, netto -9689 USD, Sharpe -3.22, DD 96.9 %, 1% -115 USD, 5% -56 USD: perde al netto dei costi assunti
2_averaging;AddOnce x1.5;1980;0.5066;-9740.7279;-3.2036;0.9745;-121.6451;-59.5631;0.2406;3.1524;0;0;1980 basket, win rate 51 %, netto -9741 USD, Sharpe -3.20, DD 97.4 %, 1% -122 USD, 5% -60 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
2_averaging;Grid x1.5;1980;0.5066;-9740.7279;-3.2036;0.9745;-121.6451;-59.5631;0.2406;3.1524;0;0;1980 basket, win rate 51 %, netto -9741 USD, Sharpe -3.20, DD 97.4 %, 1% -122 USD, 5% -60 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
3_stop;con stop;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
3_stop;senza stop;1844;0.5542;-9228.1048;-2.3634;0.9251;-136.115;-67.6782;-0.1898;3.1101;0;0;1844 basket, win rate 55 %, netto -9228 USD, Sharpe -2.36, DD 92.5 %, 1% -136 USD, 5% -68 USD: il win rate sale ma la coda delle perdite e il drawdown dicono dove finisce il rischio; è il motivo per cui lo stop è obbligatorio
4_cost_gate;2x;2135;0.4843;-9800.3487;-3.7111;0.9803;-93.8542;-45.5499;-0.7129;3.5108;0;0;2135 basket, win rate 48 %, netto -9800 USD, Sharpe -3.71, DD 98.0 %, 1% -94 USD, 5% -46 USD: perde al netto dei costi assunti
4_cost_gate;3x;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
4_cost_gate;4x;0;;0;0;0;;;;;0.5;0;0 basket, win rate NaN, netto 0 USD, Sharpe 0.00, DD 0.0 %, 1% NaN USD, 5% NaN USD: perde al netto dei costi assunti
5_inverso;segnale invertito;1824;0.4331;-9735.0255;-4.0007;0.974;-82.2238;-45.0301;-2.5283;3.1747;0;0;1824 basket, win rate 43 %, netto -9735 USD, Sharpe -4.00, DD 97.4 %, 1% -82 USD, 5% -45 USD: se anche il segnale invertito ha un break-even vicino a zero, il segnale non contiene informazione e il risultato è il solo costo
1 test;variante;n_baskets;win_rate;pnl_net;sharpe;maxdd;p1_pnl;p5_pnl;break_even_cost;avg_cost_pips;psr;dsr;motivazione
2 1_segnale;ZScoreSynthetic;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
3 1_segnale;PipDivergence;3124;0.4238;-9406.4611;-3.7746;0.9412;-75.4011;-31.0045;-0.6061;3.1477;0;0;3124 basket, win rate 42 %, netto -9406 USD, Sharpe -3.77, DD 94.1 %, 1% -75 USD, 5% -31 USD: perde al netto dei costi assunti
4 2_averaging;Off x1.0;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
5 2_averaging;AddOnce x1.0;2123;0.5087;-9689.2745;-3.2225;0.9693;-115.115;-55.905;0.282;3.1382;0;0;2123 basket, win rate 51 %, netto -9689 USD, Sharpe -3.22, DD 96.9 %, 1% -115 USD, 5% -56 USD: perde al netto dei costi assunti
6 2_averaging;Grid x1.0;2123;0.5087;-9689.2745;-3.2225;0.9693;-115.115;-55.905;0.282;3.1382;0;0;2123 basket, win rate 51 %, netto -9689 USD, Sharpe -3.22, DD 96.9 %, 1% -115 USD, 5% -56 USD: perde al netto dei costi assunti
7 2_averaging;AddOnce x1.5;1980;0.5066;-9740.7279;-3.2036;0.9745;-121.6451;-59.5631;0.2406;3.1524;0;0;1980 basket, win rate 51 %, netto -9741 USD, Sharpe -3.20, DD 97.4 %, 1% -122 USD, 5% -60 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
8 2_averaging;Grid x1.5;1980;0.5066;-9740.7279;-3.2036;0.9745;-121.6451;-59.5631;0.2406;3.1524;0;0;1980 basket, win rate 51 %, netto -9741 USD, Sharpe -3.20, DD 97.4 %, 1% -122 USD, 5% -60 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
9 3_stop;con stop;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
10 3_stop;senza stop;1844;0.5542;-9228.1048;-2.3634;0.9251;-136.115;-67.6782;-0.1898;3.1101;0;0;1844 basket, win rate 55 %, netto -9228 USD, Sharpe -2.36, DD 92.5 %, 1% -136 USD, 5% -68 USD: il win rate sale ma la coda delle perdite e il drawdown dicono dove finisce il rischio; è il motivo per cui lo stop è obbligatorio
11 4_cost_gate;2x;2135;0.4843;-9800.3487;-3.7111;0.9803;-93.8542;-45.5499;-0.7129;3.5108;0;0;2135 basket, win rate 48 %, netto -9800 USD, Sharpe -3.71, DD 98.0 %, 1% -94 USD, 5% -46 USD: perde al netto dei costi assunti
12 4_cost_gate;3x;2224;0.5018;-9608.2555;-3.3792;0.9612;-98.1631;-50.2921;-0.3966;3.1231;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, 1% -98 USD, 5% -50 USD: perde al netto dei costi assunti
13 4_cost_gate;4x;0;;0;0;0;;;;;0.5;0;0 basket, win rate NaN, netto 0 USD, Sharpe 0.00, DD 0.0 %, 1% NaN USD, 5% NaN USD: perde al netto dei costi assunti
14 5_inverso;segnale invertito;1824;0.4331;-9735.0255;-4.0007;0.974;-82.2238;-45.0301;-2.5283;3.1747;0;0;1824 basket, win rate 43 %, netto -9735 USD, Sharpe -4.00, DD 97.4 %, 1% -82 USD, 5% -45 USD: se anche il segnale invertito ha un break-even vicino a zero, il segnale non contiene informazione e il risultato è il solo costo
@@ -0,0 +1,14 @@
test;variante;n_baskets;win_rate;pnl_net;sharpe;maxdd;p1_pnl;p5_pnl;break_even_cost;avg_cost_pips;psr;dsr;motivazione
1_segnale;ZScoreSynthetic;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
1_segnale;PipDivergence;2877;0.4282;-9783.9713;-4.2544;0.9786;-74.479;-33.8654;-0.4263;3.1921;0;0;2877 basket, win rate 43 %, netto -9784 USD, Sharpe -4.25, DD 97.9 %, 1% -74 USD, 5% -34 USD: perde al netto dei costi assunti
2_averaging;Off x1.0;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
2_averaging;AddOnce x1.0;1821;0.4811;-9800.0151;-3.6263;0.9802;-115.1734;-58.7312;0.3851;3.2102;0;0;1821 basket, win rate 48 %, netto -9800 USD, Sharpe -3.63, DD 98.0 %, 1% -115 USD, 5% -59 USD: perde al netto dei costi assunti
2_averaging;Grid x1.0;1821;0.4811;-9800.0151;-3.6263;0.9802;-115.1734;-58.7312;0.3851;3.2102;0;0;1821 basket, win rate 48 %, netto -9800 USD, Sharpe -3.63, DD 98.0 %, 1% -115 USD, 5% -59 USD: perde al netto dei costi assunti
2_averaging;AddOnce x1.5;1673;0.4728;-9802.2249;-3.5831;0.9805;-116.0597;-64.5705;0.2809;3.2087;0;0;1673 basket, win rate 47 %, netto -9802 USD, Sharpe -3.58, DD 98.0 %, 1% -116 USD, 5% -65 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
2_averaging;Grid x1.5;1673;0.4728;-9802.2249;-3.5831;0.9805;-116.0597;-64.5705;0.2809;3.2087;0;0;1673 basket, win rate 47 %, netto -9802 USD, Sharpe -3.58, DD 98.0 %, 1% -116 USD, 5% -65 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
3_stop;con stop;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
3_stop;senza stop;1949;0.5387;-9795.9761;-3.054;0.9799;-107.4238;-51.7478;-0.3737;3.1928;0;0;1949 basket, win rate 54 %, netto -9796 USD, Sharpe -3.05, DD 98.0 %, 1% -107 USD, 5% -52 USD: il win rate sale ma la coda delle perdite e il drawdown dicono dove finisce il rischio; è il motivo per cui lo stop è obbligatorio
4_cost_gate;2x;2052;0.4771;-9800.0224;-3.7234;0.9802;-93.1449;-44.9303;-0.6448;3.4791;0;0;2052 basket, win rate 48 %, netto -9800 USD, Sharpe -3.72, DD 98.0 %, 1% -93 USD, 5% -45 USD: perde al netto dei costi assunti
4_cost_gate;3x;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
4_cost_gate;4x;3;0.3333;-81.1762;-0.3256;0.0081;-72.0723;-72.0723;3.8259;2.4592;0.0228;0;3 basket, win rate 33 %, netto -81 USD, Sharpe -0.33, DD 0.8 %, 1% -72 USD, 5% -72 USD: perde al netto dei costi assunti
5_inverso;segnale invertito;1537;0.3852;-9800.9519;-4.3499;0.9801;-83.2267;-48.4287;-2.8935;3.2095;0;0;1537 basket, win rate 39 %, netto -9801 USD, Sharpe -4.35, DD 98.0 %, 1% -83 USD, 5% -48 USD: se anche il segnale invertito ha un break-even vicino a zero, il segnale non contiene informazione e il risultato è il solo costo
1 test;variante;n_baskets;win_rate;pnl_net;sharpe;maxdd;p1_pnl;p5_pnl;break_even_cost;avg_cost_pips;psr;dsr;motivazione
2 1_segnale;ZScoreSynthetic;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
3 1_segnale;PipDivergence;2877;0.4282;-9783.9713;-4.2544;0.9786;-74.479;-33.8654;-0.4263;3.1921;0;0;2877 basket, win rate 43 %, netto -9784 USD, Sharpe -4.25, DD 97.9 %, 1% -74 USD, 5% -34 USD: perde al netto dei costi assunti
4 2_averaging;Off x1.0;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
5 2_averaging;AddOnce x1.0;1821;0.4811;-9800.0151;-3.6263;0.9802;-115.1734;-58.7312;0.3851;3.2102;0;0;1821 basket, win rate 48 %, netto -9800 USD, Sharpe -3.63, DD 98.0 %, 1% -115 USD, 5% -59 USD: perde al netto dei costi assunti
6 2_averaging;Grid x1.0;1821;0.4811;-9800.0151;-3.6263;0.9802;-115.1734;-58.7312;0.3851;3.2102;0;0;1821 basket, win rate 48 %, netto -9800 USD, Sharpe -3.63, DD 98.0 %, 1% -115 USD, 5% -59 USD: perde al netto dei costi assunti
7 2_averaging;AddOnce x1.5;1673;0.4728;-9802.2249;-3.5831;0.9805;-116.0597;-64.5705;0.2809;3.2087;0;0;1673 basket, win rate 47 %, netto -9802 USD, Sharpe -3.58, DD 98.0 %, 1% -116 USD, 5% -65 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
8 2_averaging;Grid x1.5;1673;0.4728;-9802.2249;-3.5831;0.9805;-116.0597;-64.5705;0.2809;3.2087;0;0;1673 basket, win rate 47 %, netto -9802 USD, Sharpe -3.58, DD 98.0 %, 1% -116 USD, 5% -65 USD: moltiplicatore 1,5 ammesso solo qui, in backtest, per mostrare la coda; il bot usa 1,0
9 3_stop;con stop;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
10 3_stop;senza stop;1949;0.5387;-9795.9761;-3.054;0.9799;-107.4238;-51.7478;-0.3737;3.1928;0;0;1949 basket, win rate 54 %, netto -9796 USD, Sharpe -3.05, DD 98.0 %, 1% -107 USD, 5% -52 USD: il win rate sale ma la coda delle perdite e il drawdown dicono dove finisce il rischio; è il motivo per cui lo stop è obbligatorio
11 4_cost_gate;2x;2052;0.4771;-9800.0224;-3.7234;0.9802;-93.1449;-44.9303;-0.6448;3.4791;0;0;2052 basket, win rate 48 %, netto -9800 USD, Sharpe -3.72, DD 98.0 %, 1% -93 USD, 5% -45 USD: perde al netto dei costi assunti
12 4_cost_gate;3x;2076;0.4769;-9801.9491;-3.8807;0.9804;-96.1599;-51.6818;-0.4892;3.2085;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, 1% -96 USD, 5% -52 USD: perde al netto dei costi assunti
13 4_cost_gate;4x;3;0.3333;-81.1762;-0.3256;0.0081;-72.0723;-72.0723;3.8259;2.4592;0.0228;0;3 basket, win rate 33 %, netto -81 USD, Sharpe -0.33, DD 0.8 %, 1% -72 USD, 5% -72 USD: perde al netto dei costi assunti
14 5_inverso;segnale invertito;1537;0.3852;-9800.9519;-4.3499;0.9801;-83.2267;-48.4287;-2.8935;3.2095;0;0;1537 basket, win rate 39 %, netto -9801 USD, Sharpe -4.35, DD 98.0 %, 1% -83 USD, 5% -48 USD: se anche il segnale invertito ha un break-even vicino a zero, il segnale non contiene informazione e il risultato è il solo costo
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+8
View File
@@ -0,0 +1,8 @@
voce;valore;motivazione
periodo;2018-12-12 → 2026-09-15;barre M15 dai tick MT5, spread minimo = tipico eToro, slippage 0.3 pip/gamba, overnight 0.3 pip/gamba/giorno
prove;57;ogni configurazione provata conta nel Sharpe deflazionato
baseline Moderate;Sharpe -3.38, netto -9608 USD, 2224 basket, win rate 50 %;la configurazione di fabbrica così com'è
migliore;BASE-CON: Sharpe 0.00, DSR 0.000;non distinguibile dalla selezione fra le prove
PBO;0.000;probabilità che la scelta in-sample sia sotto la mediana out-of-sample (CSCV, 16 blocchi); sotto 0,5 è il cancello
walk-forward;Sharpe -0.75, DD 13.2 %, PSR 0.005;cosa avrebbe reso la procedura 'scegli il migliore degli ultimi 6 mesi, applicalo un mese' su 88 mesi
verdetto;negativo;NESSUNA configurazione profittevole al netto dei costi assunti: la strategia non regge i costi di eToro su questi dati
1 voce;valore;motivazione
2 periodo;2018-12-12 → 2026-09-15;barre M15 dai tick MT5, spread minimo = tipico eToro, slippage 0.3 pip/gamba, overnight 0.3 pip/gamba/giorno
3 prove;57;ogni configurazione provata conta nel Sharpe deflazionato
4 baseline Moderate;Sharpe -3.38, netto -9608 USD, 2224 basket, win rate 50 %;la configurazione di fabbrica così com'è
5 migliore;BASE-CON: Sharpe 0.00, DSR 0.000;non distinguibile dalla selezione fra le prove
6 PBO;0.000;probabilità che la scelta in-sample sia sotto la mediana out-of-sample (CSCV, 16 blocchi); sotto 0,5 è il cancello
7 walk-forward;Sharpe -0.75, DD 13.2 %, PSR 0.005;cosa avrebbe reso la procedura 'scegli il migliore degli ultimi 6 mesi, applicalo un mese' su 88 mesi
8 verdetto;negativo;NESSUNA configurazione profittevole al netto dei costi assunti: la strategia non regge i costi di eToro su questi dati
@@ -0,0 +1,8 @@
voce;valore;motivazione
periodo;2018-12-12 → 2026-09-16;barre M15 dai tick MT5, spread minimo = nessuno (spread dei tick), slippage 0.3 pip/gamba, overnight 0.9 pip/gamba/giorno
prove;57;ogni configurazione provata conta nel Sharpe deflazionato
baseline Moderate;Sharpe -3.88, netto -9802 USD, 2076 basket, win rate 48 %;la configurazione di fabbrica così com'è
migliore;T013: Sharpe -0.10, DSR 0.000;non distinguibile dalla selezione fra le prove
PBO;0.001;probabilità che la scelta in-sample sia sotto la mediana out-of-sample (CSCV, 16 blocchi); sotto 0,5 è il cancello
walk-forward;Sharpe -0.91, DD 13.5 %, PSR 0.000;cosa avrebbe reso la procedura 'scegli il migliore degli ultimi 6 mesi, applicalo un mese' su 88 mesi
verdetto;negativo;NESSUNA configurazione profittevole al netto dei costi assunti: la strategia non regge i costi di eToro su questi dati
1 voce;valore;motivazione
2 periodo;2018-12-12 → 2026-09-16;barre M15 dai tick MT5, spread minimo = nessuno (spread dei tick), slippage 0.3 pip/gamba, overnight 0.9 pip/gamba/giorno
3 prove;57;ogni configurazione provata conta nel Sharpe deflazionato
4 baseline Moderate;Sharpe -3.88, netto -9802 USD, 2076 basket, win rate 48 %;la configurazione di fabbrica così com'è
5 migliore;T013: Sharpe -0.10, DSR 0.000;non distinguibile dalla selezione fra le prove
6 PBO;0.001;probabilità che la scelta in-sample sia sotto la mediana out-of-sample (CSCV, 16 blocchi); sotto 0,5 è il cancello
7 walk-forward;Sharpe -0.91, DD 13.5 %, PSR 0.000;cosa avrebbe reso la procedura 'scegli il migliore degli ultimi 6 mesi, applicalo un mese' su 88 mesi
8 verdetto;negativo;NESSUNA configurazione profittevole al netto dei costi assunti: la strategia non regge i costi di eToro su questi dati
+58
View File
@@ -0,0 +1,58 @@
trial_id;preset;signalMode;exitMode;averaging;lot_multiplier;z_in;z_out;z_stop;TP;W;rho_min;cost_multiple;basket_stop;n_baskets;win_rate;pnl_net;sharpe;maxdd;break_even_cost;avg_cost_pips;p1_pnl;p5_pnl;psr;dsr;motivazione
BASE-CON;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
BASE-MOD;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.6;3;1;2224;0.5018;-9608.2555;-3.38;0.9612;-0.3966;3.1231;-98.1631;-50.2921;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, costo medio 3.1 pip, break-even -0.4 pip: perde al netto dei costi
BASE-AGG;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.6;3;1;2219;0.5273;-9801.7437;-3.605;0.9808;-0.154;3.4299;-107.4078;-54.9455;0;0;2219 basket, win rate 53 %, netto -9802 USD, Sharpe -3.61, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T001;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;60;0.5;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T002;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;60;0.5;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T003;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;60;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T004;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;60;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T005;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;60;0.7;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T006;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;60;0.7;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T007;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.5;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T008;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;100;0.5;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T009;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T010;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;100;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T011;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.7;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T012;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;100;0.7;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T013;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;150;0.5;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T014;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;150;0.5;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T015;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;150;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T016;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;150;0.6;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T017;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;150;0.7;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T018;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;150;0.7;3;1;0;;0;0;0;;;;;0.5;0;nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
T019;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;60;0.5;3;1;2273;0.5095;-9776.971;-3.676;0.9777;-0.5181;3.1978;-100.8336;-48.8858;0;0;2273 basket, win rate 51 %, netto -9777 USD, Sharpe -3.68, DD 97.8 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T020;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;60;0.5;3;1;2361;0.5078;-9780.3682;-3.8412;0.9781;-0.4561;3.1972;-93.6221;-45.8502;0;0;2361 basket, win rate 51 %, netto -9780 USD, Sharpe -3.84, DD 97.8 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T021;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;60;0.6;3;1;2114;0.5019;-9777.7272;-3.7077;0.9778;-0.9027;3.1945;-97.6587;-50.0165;0;0;2114 basket, win rate 50 %, netto -9778 USD, Sharpe -3.71, DD 97.8 %, costo medio 3.2 pip, break-even -0.9 pip: perde al netto dei costi
T022;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;60;0.6;3;1;2186;0.4973;-9775.8854;-3.9248;0.9777;-0.7664;3.1947;-91.6099;-48.0941;0;0;2186 basket, win rate 50 %, netto -9776 USD, Sharpe -3.92, DD 97.8 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
T023;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;60;0.7;3;1;1904;0.4806;-9758.7378;-3.9609;0.9759;-1.3315;3.1716;-104.8435;-53.09;0;0;1904 basket, win rate 48 %, netto -9759 USD, Sharpe -3.96, DD 97.6 %, costo medio 3.2 pip, break-even -1.3 pip: perde al netto dei costi
T024;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;60;0.7;3;1;1943;0.4668;-9761.2755;-4.0828;0.9761;-1.3364;3.1729;-99.5743;-52.3411;0;0;1943 basket, win rate 47 %, netto -9761 USD, Sharpe -4.08, DD 97.6 %, costo medio 3.2 pip, break-even -1.3 pip: perde al netto dei costi
T025;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.5;3;1;2386;0.4987;-9698.3332;-3.4922;0.9703;-0.5028;3.1298;-97.1191;-49.2531;0;0;2386 basket, win rate 50 %, netto -9698 USD, Sharpe -3.49, DD 97.0 %, costo medio 3.1 pip, break-even -0.5 pip: perde al netto dei costi
T026;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;100;0.5;3;1;2325;0.4886;-9733.1429;-3.7736;0.9737;-0.716;3.1401;-89.9765;-47.1863;0;0;2325 basket, win rate 49 %, netto -9733 USD, Sharpe -3.77, DD 97.4 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
T027;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.6;3;1;2224;0.5018;-9608.2555;-3.38;0.9612;-0.3966;3.1231;-98.1631;-50.2921;0;0;2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, costo medio 3.1 pip, break-even -0.4 pip: perde al netto dei costi
T028;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;100;0.6;3;1;2232;0.4928;-9626.41;-3.5471;0.963;-0.4681;3.1283;-92.7272;-48.5099;0;0;2232 basket, win rate 49 %, netto -9626 USD, Sharpe -3.55, DD 96.3 %, costo medio 3.1 pip, break-even -0.5 pip: perde al netto dei costi
T029;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.7;3;1;1620;0.4969;-9097.1212;-3.0336;0.9104;-0.7071;3.1249;-110.3729;-57.6683;0;0;1620 basket, win rate 50 %, netto -9097 USD, Sharpe -3.03, DD 91.0 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
T030;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;100;0.7;3;1;1659;0.4846;-9151.1206;-3.1928;0.9158;-0.6745;3.125;-105.9072;-54.6317;0;0;1659 basket, win rate 48 %, netto -9151 USD, Sharpe -3.19, DD 91.6 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
T031;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;150;0.5;3;1;1724;0.518;-8946.7157;-2.9015;0.8957;-0.8274;3.1056;-96.5951;-58.2571;0;0;1724 basket, win rate 52 %, netto -8947 USD, Sharpe -2.90, DD 89.6 %, costo medio 3.1 pip, break-even -0.8 pip: perde al netto dei costi
T032;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;150;0.5;3;1;1750;0.5114;-8984.9522;-3.0214;0.8994;-0.7697;3.1053;-94.7592;-56.1468;0;0;1750 basket, win rate 51 %, netto -8985 USD, Sharpe -3.02, DD 89.9 %, costo medio 3.1 pip, break-even -0.8 pip: perde al netto dei costi
T033;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;150;0.6;3;1;1524;0.523;-8546.383;-2.6559;0.856;-0.5673;3.1088;-108.0414;-60.4233;0;0;1524 basket, win rate 52 %, netto -8546 USD, Sharpe -2.66, DD 85.6 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
T034;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;150;0.6;3;1;1555;0.5125;-8644.9455;-2.7834;0.8655;-0.5618;3.1095;-104.0531;-58.2323;0;0;1555 basket, win rate 51 %, netto -8645 USD, Sharpe -2.78, DD 86.5 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
T035;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;150;0.7;3;1;1057;0.5232;-7365.987;-2.1831;0.7384;-0.7041;3.1237;-120.7347;-71.8169;0;0;1057 basket, win rate 52 %, netto -7366 USD, Sharpe -2.18, DD 73.8 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
T036;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;150;0.7;3;1;1080;0.513;-7548.9926;-2.318;0.7562;-0.8988;3.124;-116.8562;-67.6427;0;0;1080 basket, win rate 51 %, netto -7549 USD, Sharpe -2.32, DD 75.6 %, costo medio 3.1 pip, break-even -0.9 pip: perde al netto dei costi
T037;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;60;0.5;3;1;2324;0.503;-9801.8989;-3.7439;0.9802;0.1247;3.453;-94.1066;-44.0792;0;0;2324 basket, win rate 50 %, netto -9802 USD, Sharpe -3.74, DD 98.0 %, costo medio 3.5 pip, break-even 0.1 pip: perde al netto dei costi
T038;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;60;0.5;3;1;2505;0.5022;-9801.8568;-3.8586;0.9802;0.2991;3.4527;-85.3644;-37.9877;0;0;2505 basket, win rate 50 %, netto -9802 USD, Sharpe -3.86, DD 98.0 %, costo medio 3.5 pip, break-even 0.3 pip: perde al netto dei costi
T039;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;60;0.6;3;1;2206;0.4946;-9801.6714;-3.7449;0.9802;-0.122;3.4445;-95.2361;-46.4834;0;0;2206 basket, win rate 49 %, netto -9802 USD, Sharpe -3.74, DD 98.0 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
T040;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;60;0.6;3;1;2382;0.5008;-9801.8364;-3.8898;0.9802;0.1249;3.4433;-91.5065;-39.2958;0;0;2382 basket, win rate 50 %, netto -9802 USD, Sharpe -3.89, DD 98.0 %, costo medio 3.4 pip, break-even 0.1 pip: perde al netto dei costi
T041;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;60;0.7;3;1;2066;0.4782;-9800.3225;-3.9569;0.9801;-0.3695;3.4129;-106.8203;-50.7168;0;0;2066 basket, win rate 48 %, netto -9800 USD, Sharpe -3.96, DD 98.0 %, costo medio 3.4 pip, break-even -0.4 pip: perde al netto dei costi
T042;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;60;0.7;3;1;2228;0.478;-9800.5097;-4.0478;0.9802;-0.0551;3.4114;-99.1796;-46.4296;0;0;2228 basket, win rate 48 %, netto -9801 USD, Sharpe -4.05, DD 98.0 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
T043;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.5;3;1;2333;0.5362;-9800.5583;-3.6212;0.9807;-0.1462;3.455;-114.2527;-52.729;0;0;2333 basket, win rate 54 %, netto -9801 USD, Sharpe -3.62, DD 98.1 %, costo medio 3.5 pip, break-even -0.1 pip: perde al netto dei costi
T044;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;100;0.5;3;1;2418;0.5434;-9801.6954;-3.7353;0.9807;-0.0542;3.4505;-106.0593;-47.7018;0;0;2418 basket, win rate 54 %, netto -9802 USD, Sharpe -3.74, DD 98.1 %, costo medio 3.5 pip, break-even -0.1 pip: perde al netto dei costi
T045;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.6;3;1;2219;0.5273;-9801.7437;-3.605;0.9808;-0.154;3.4299;-107.4078;-54.9455;0;0;2219 basket, win rate 53 %, netto -9802 USD, Sharpe -3.61, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T046;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;100;0.6;3;1;2299;0.5385;-9800.1165;-3.8043;0.9805;-0.0498;3.4277;-102.5053;-49.1087;0;0;2299 basket, win rate 54 %, netto -9800 USD, Sharpe -3.80, DD 98.1 %, costo medio 3.4 pip, break-even -0.0 pip: perde al netto dei costi
T047;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.7;3;1;2034;0.5103;-9801.176;-3.5533;0.9805;-0.7064;3.3793;-110.5845;-56.0264;0;0;2034 basket, win rate 51 %, netto -9801 USD, Sharpe -3.55, DD 98.1 %, costo medio 3.4 pip, break-even -0.7 pip: perde al netto dei costi
T048;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;100;0.7;3;1;2111;0.5216;-9801.5062;-3.6808;0.9805;-0.5194;3.3807;-102.1236;-50.7364;0;0;2111 basket, win rate 52 %, netto -9802 USD, Sharpe -3.68, DD 98.1 %, costo medio 3.4 pip, break-even -0.5 pip: perde al netto dei costi
T049;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;150;0.5;3;1;2535;0.5582;-9800.4562;-3.2691;0.9804;-0.1898;3.4255;-122.7526;-63.8002;0;0;2535 basket, win rate 56 %, netto -9800 USD, Sharpe -3.27, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T050;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;150;0.5;3;1;2652;0.5618;-9800.054;-3.34;0.9804;-0.12;3.4243;-117.3288;-56.7329;0;0;2652 basket, win rate 56 %, netto -9800 USD, Sharpe -3.34, DD 98.0 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
T051;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;150;0.6;3;1;2611;0.558;-9800.3025;-3.3139;0.9804;0.0259;3.3951;-122.3324;-61.2879;0;0;2611 basket, win rate 56 %, netto -9800 USD, Sharpe -3.31, DD 98.0 %, costo medio 3.4 pip, break-even 0.0 pip: perde al netto dei costi
T052;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;150;0.6;3;1;2722;0.5643;-9800.3917;-3.4336;0.9804;0.1646;3.3925;-117.9914;-53.3356;0;0;2722 basket, win rate 56 %, netto -9800 USD, Sharpe -3.43, DD 98.0 %, costo medio 3.4 pip, break-even 0.2 pip: perde al netto dei costi
T053;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;150;0.7;3;1;2549;0.5457;-9799.5834;-3.5684;0.9806;-0.0172;3.3539;-130.1295;-56.5296;0;0;2549 basket, win rate 55 %, netto -9800 USD, Sharpe -3.57, DD 98.1 %, costo medio 3.4 pip, break-even -0.0 pip: perde al netto dei costi
T054;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;150;0.7;3;1;2602;0.5473;-9802.9899;-3.6937;0.9808;-0.0068;3.3538;-125.0607;-49.82;0;0;2602 basket, win rate 55 %, netto -9803 USD, Sharpe -3.69, DD 98.1 %, costo medio 3.4 pip, break-even -0.0 pip: perde al netto dei costi
1 trial_id preset signalMode exitMode averaging lot_multiplier z_in z_out z_stop TP W rho_min cost_multiple basket_stop n_baskets win_rate pnl_net sharpe maxdd break_even_cost avg_cost_pips p1_pnl p5_pnl psr dsr motivazione
2 BASE-CON Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
3 BASE-MOD Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.6 3 1 2224 0.5018 -9608.2555 -3.38 0.9612 -0.3966 3.1231 -98.1631 -50.2921 0 0 2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, costo medio 3.1 pip, break-even -0.4 pip: perde al netto dei costi
4 BASE-AGG Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.6 3 1 2219 0.5273 -9801.7437 -3.605 0.9808 -0.154 3.4299 -107.4078 -54.9455 0 0 2219 basket, win rate 53 %, netto -9802 USD, Sharpe -3.61, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
5 T001 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 60 0.5 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
6 T002 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 60 0.5 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
7 T003 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 60 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
8 T004 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 60 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
9 T005 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 60 0.7 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
10 T006 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 60 0.7 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
11 T007 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.5 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
12 T008 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 100 0.5 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
13 T009 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
14 T010 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 100 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
15 T011 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.7 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
16 T012 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 100 0.7 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
17 T013 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 150 0.5 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
18 T014 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 150 0.5 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
19 T015 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 150 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
20 T016 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 150 0.6 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
21 T017 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 150 0.7 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
22 T018 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 150 0.7 3 1 0 0 0 0 0.5 0 nessun basket aperto: le condizioni di ingresso non si sono mai verificate insieme
23 T019 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 60 0.5 3 1 2273 0.5095 -9776.971 -3.676 0.9777 -0.5181 3.1978 -100.8336 -48.8858 0 0 2273 basket, win rate 51 %, netto -9777 USD, Sharpe -3.68, DD 97.8 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
24 T020 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 60 0.5 3 1 2361 0.5078 -9780.3682 -3.8412 0.9781 -0.4561 3.1972 -93.6221 -45.8502 0 0 2361 basket, win rate 51 %, netto -9780 USD, Sharpe -3.84, DD 97.8 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
25 T021 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 60 0.6 3 1 2114 0.5019 -9777.7272 -3.7077 0.9778 -0.9027 3.1945 -97.6587 -50.0165 0 0 2114 basket, win rate 50 %, netto -9778 USD, Sharpe -3.71, DD 97.8 %, costo medio 3.2 pip, break-even -0.9 pip: perde al netto dei costi
26 T022 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 60 0.6 3 1 2186 0.4973 -9775.8854 -3.9248 0.9777 -0.7664 3.1947 -91.6099 -48.0941 0 0 2186 basket, win rate 50 %, netto -9776 USD, Sharpe -3.92, DD 97.8 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
27 T023 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 60 0.7 3 1 1904 0.4806 -9758.7378 -3.9609 0.9759 -1.3315 3.1716 -104.8435 -53.09 0 0 1904 basket, win rate 48 %, netto -9759 USD, Sharpe -3.96, DD 97.6 %, costo medio 3.2 pip, break-even -1.3 pip: perde al netto dei costi
28 T024 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 60 0.7 3 1 1943 0.4668 -9761.2755 -4.0828 0.9761 -1.3364 3.1729 -99.5743 -52.3411 0 0 1943 basket, win rate 47 %, netto -9761 USD, Sharpe -4.08, DD 97.6 %, costo medio 3.2 pip, break-even -1.3 pip: perde al netto dei costi
29 T025 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.5 3 1 2386 0.4987 -9698.3332 -3.4922 0.9703 -0.5028 3.1298 -97.1191 -49.2531 0 0 2386 basket, win rate 50 %, netto -9698 USD, Sharpe -3.49, DD 97.0 %, costo medio 3.1 pip, break-even -0.5 pip: perde al netto dei costi
30 T026 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 100 0.5 3 1 2325 0.4886 -9733.1429 -3.7736 0.9737 -0.716 3.1401 -89.9765 -47.1863 0 0 2325 basket, win rate 49 %, netto -9733 USD, Sharpe -3.77, DD 97.4 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
31 T027 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.6 3 1 2224 0.5018 -9608.2555 -3.38 0.9612 -0.3966 3.1231 -98.1631 -50.2921 0 0 2224 basket, win rate 50 %, netto -9608 USD, Sharpe -3.38, DD 96.1 %, costo medio 3.1 pip, break-even -0.4 pip: perde al netto dei costi
32 T028 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 100 0.6 3 1 2232 0.4928 -9626.41 -3.5471 0.963 -0.4681 3.1283 -92.7272 -48.5099 0 0 2232 basket, win rate 49 %, netto -9626 USD, Sharpe -3.55, DD 96.3 %, costo medio 3.1 pip, break-even -0.5 pip: perde al netto dei costi
33 T029 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.7 3 1 1620 0.4969 -9097.1212 -3.0336 0.9104 -0.7071 3.1249 -110.3729 -57.6683 0 0 1620 basket, win rate 50 %, netto -9097 USD, Sharpe -3.03, DD 91.0 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
34 T030 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 100 0.7 3 1 1659 0.4846 -9151.1206 -3.1928 0.9158 -0.6745 3.125 -105.9072 -54.6317 0 0 1659 basket, win rate 48 %, netto -9151 USD, Sharpe -3.19, DD 91.6 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
35 T031 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 150 0.5 3 1 1724 0.518 -8946.7157 -2.9015 0.8957 -0.8274 3.1056 -96.5951 -58.2571 0 0 1724 basket, win rate 52 %, netto -8947 USD, Sharpe -2.90, DD 89.6 %, costo medio 3.1 pip, break-even -0.8 pip: perde al netto dei costi
36 T032 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 150 0.5 3 1 1750 0.5114 -8984.9522 -3.0214 0.8994 -0.7697 3.1053 -94.7592 -56.1468 0 0 1750 basket, win rate 51 %, netto -8985 USD, Sharpe -3.02, DD 89.9 %, costo medio 3.1 pip, break-even -0.8 pip: perde al netto dei costi
37 T033 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 150 0.6 3 1 1524 0.523 -8546.383 -2.6559 0.856 -0.5673 3.1088 -108.0414 -60.4233 0 0 1524 basket, win rate 52 %, netto -8546 USD, Sharpe -2.66, DD 85.6 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
38 T034 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 150 0.6 3 1 1555 0.5125 -8644.9455 -2.7834 0.8655 -0.5618 3.1095 -104.0531 -58.2323 0 0 1555 basket, win rate 51 %, netto -8645 USD, Sharpe -2.78, DD 86.5 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
39 T035 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 150 0.7 3 1 1057 0.5232 -7365.987 -2.1831 0.7384 -0.7041 3.1237 -120.7347 -71.8169 0 0 1057 basket, win rate 52 %, netto -7366 USD, Sharpe -2.18, DD 73.8 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
40 T036 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 150 0.7 3 1 1080 0.513 -7548.9926 -2.318 0.7562 -0.8988 3.124 -116.8562 -67.6427 0 0 1080 basket, win rate 51 %, netto -7549 USD, Sharpe -2.32, DD 75.6 %, costo medio 3.1 pip, break-even -0.9 pip: perde al netto dei costi
41 T037 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 60 0.5 3 1 2324 0.503 -9801.8989 -3.7439 0.9802 0.1247 3.453 -94.1066 -44.0792 0 0 2324 basket, win rate 50 %, netto -9802 USD, Sharpe -3.74, DD 98.0 %, costo medio 3.5 pip, break-even 0.1 pip: perde al netto dei costi
42 T038 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 60 0.5 3 1 2505 0.5022 -9801.8568 -3.8586 0.9802 0.2991 3.4527 -85.3644 -37.9877 0 0 2505 basket, win rate 50 %, netto -9802 USD, Sharpe -3.86, DD 98.0 %, costo medio 3.5 pip, break-even 0.3 pip: perde al netto dei costi
43 T039 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 60 0.6 3 1 2206 0.4946 -9801.6714 -3.7449 0.9802 -0.122 3.4445 -95.2361 -46.4834 0 0 2206 basket, win rate 49 %, netto -9802 USD, Sharpe -3.74, DD 98.0 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
44 T040 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 60 0.6 3 1 2382 0.5008 -9801.8364 -3.8898 0.9802 0.1249 3.4433 -91.5065 -39.2958 0 0 2382 basket, win rate 50 %, netto -9802 USD, Sharpe -3.89, DD 98.0 %, costo medio 3.4 pip, break-even 0.1 pip: perde al netto dei costi
45 T041 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 60 0.7 3 1 2066 0.4782 -9800.3225 -3.9569 0.9801 -0.3695 3.4129 -106.8203 -50.7168 0 0 2066 basket, win rate 48 %, netto -9800 USD, Sharpe -3.96, DD 98.0 %, costo medio 3.4 pip, break-even -0.4 pip: perde al netto dei costi
46 T042 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 60 0.7 3 1 2228 0.478 -9800.5097 -4.0478 0.9802 -0.0551 3.4114 -99.1796 -46.4296 0 0 2228 basket, win rate 48 %, netto -9801 USD, Sharpe -4.05, DD 98.0 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
47 T043 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.5 3 1 2333 0.5362 -9800.5583 -3.6212 0.9807 -0.1462 3.455 -114.2527 -52.729 0 0 2333 basket, win rate 54 %, netto -9801 USD, Sharpe -3.62, DD 98.1 %, costo medio 3.5 pip, break-even -0.1 pip: perde al netto dei costi
48 T044 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 100 0.5 3 1 2418 0.5434 -9801.6954 -3.7353 0.9807 -0.0542 3.4505 -106.0593 -47.7018 0 0 2418 basket, win rate 54 %, netto -9802 USD, Sharpe -3.74, DD 98.1 %, costo medio 3.5 pip, break-even -0.1 pip: perde al netto dei costi
49 T045 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.6 3 1 2219 0.5273 -9801.7437 -3.605 0.9808 -0.154 3.4299 -107.4078 -54.9455 0 0 2219 basket, win rate 53 %, netto -9802 USD, Sharpe -3.61, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
50 T046 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 100 0.6 3 1 2299 0.5385 -9800.1165 -3.8043 0.9805 -0.0498 3.4277 -102.5053 -49.1087 0 0 2299 basket, win rate 54 %, netto -9800 USD, Sharpe -3.80, DD 98.1 %, costo medio 3.4 pip, break-even -0.0 pip: perde al netto dei costi
51 T047 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.7 3 1 2034 0.5103 -9801.176 -3.5533 0.9805 -0.7064 3.3793 -110.5845 -56.0264 0 0 2034 basket, win rate 51 %, netto -9801 USD, Sharpe -3.55, DD 98.1 %, costo medio 3.4 pip, break-even -0.7 pip: perde al netto dei costi
52 T048 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 100 0.7 3 1 2111 0.5216 -9801.5062 -3.6808 0.9805 -0.5194 3.3807 -102.1236 -50.7364 0 0 2111 basket, win rate 52 %, netto -9802 USD, Sharpe -3.68, DD 98.1 %, costo medio 3.4 pip, break-even -0.5 pip: perde al netto dei costi
53 T049 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 150 0.5 3 1 2535 0.5582 -9800.4562 -3.2691 0.9804 -0.1898 3.4255 -122.7526 -63.8002 0 0 2535 basket, win rate 56 %, netto -9800 USD, Sharpe -3.27, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
54 T050 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 150 0.5 3 1 2652 0.5618 -9800.054 -3.34 0.9804 -0.12 3.4243 -117.3288 -56.7329 0 0 2652 basket, win rate 56 %, netto -9800 USD, Sharpe -3.34, DD 98.0 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
55 T051 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 150 0.6 3 1 2611 0.558 -9800.3025 -3.3139 0.9804 0.0259 3.3951 -122.3324 -61.2879 0 0 2611 basket, win rate 56 %, netto -9800 USD, Sharpe -3.31, DD 98.0 %, costo medio 3.4 pip, break-even 0.0 pip: perde al netto dei costi
56 T052 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 150 0.6 3 1 2722 0.5643 -9800.3917 -3.4336 0.9804 0.1646 3.3925 -117.9914 -53.3356 0 0 2722 basket, win rate 56 %, netto -9800 USD, Sharpe -3.43, DD 98.0 %, costo medio 3.4 pip, break-even 0.2 pip: perde al netto dei costi
57 T053 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 150 0.7 3 1 2549 0.5457 -9799.5834 -3.5684 0.9806 -0.0172 3.3539 -130.1295 -56.5296 0 0 2549 basket, win rate 55 %, netto -9800 USD, Sharpe -3.57, DD 98.1 %, costo medio 3.4 pip, break-even -0.0 pip: perde al netto dei costi
58 T054 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 150 0.7 3 1 2602 0.5473 -9802.9899 -3.6937 0.9808 -0.0068 3.3538 -125.0607 -49.82 0 0 2602 basket, win rate 55 %, netto -9803 USD, Sharpe -3.69, DD 98.1 %, costo medio 3.4 pip, break-even -0.0 pip: perde al netto dei costi
+58
View File
@@ -0,0 +1,58 @@
trial_id;preset;signalMode;exitMode;averaging;lot_multiplier;z_in;z_out;z_stop;TP;W;rho_min;cost_multiple;basket_stop;n_baskets;win_rate;pnl_net;sharpe;maxdd;break_even_cost;avg_cost_pips;p1_pnl;p5_pnl;psr;dsr;motivazione
BASE-CON;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.6;3;1;5;0.4;-68.6995;-0.3203;0.0092;5.8625;2.5825;-60.6171;-60.6171;0.0947;0;5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
BASE-MOD;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.6;3;1;2076;0.4769;-9801.9491;-3.8807;0.9804;-0.4892;3.2085;-96.1599;-51.6818;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
BASE-AGG;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.6;3;1;1995;0.5143;-9800.4836;-3.7229;0.9806;-0.1782;3.4269;-113.7756;-55.2381;0;0;1995 basket, win rate 51 %, netto -9800 USD, Sharpe -3.72, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T001;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;60;0.5;3;1;8;0.5;-69.5629;-0.2771;0.0086;4.9254;2.5879;-80.2036;-80.2036;0.1196;0;8 basket, win rate 50 %, netto -70 USD, Sharpe -0.28, DD 0.9 %, costo medio 2.6 pip, break-even 4.9 pip: perde al netto dei costi
T002;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;60;0.5;3;1;8;0.375;-110.4189;-0.3764;0.0127;3.8879;2.5879;-80.2036;-80.2036;0.0455;0;8 basket, win rate 38 %, netto -110 USD, Sharpe -0.38, DD 1.3 %, costo medio 2.6 pip, break-even 3.9 pip: perde al netto dei costi
T003;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;60;0.6;3;1;8;0.5;-69.5629;-0.2771;0.0086;4.9254;2.5879;-80.2036;-80.2036;0.1196;0;8 basket, win rate 50 %, netto -70 USD, Sharpe -0.28, DD 0.9 %, costo medio 2.6 pip, break-even 4.9 pip: perde al netto dei costi
T004;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;60;0.6;3;1;8;0.375;-110.4189;-0.3764;0.0127;3.8879;2.5879;-80.2036;-80.2036;0.0455;0;8 basket, win rate 38 %, netto -110 USD, Sharpe -0.38, DD 1.3 %, costo medio 2.6 pip, break-even 3.9 pip: perde al netto dei costi
T005;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;60;0.7;3;1;3;0.3333;-16.5569;-0.2092;0.0024;10.6949;2.5283;-24.5014;-24.5014;0.1936;0;3 basket, win rate 33 %, netto -17 USD, Sharpe -0.21, DD 0.2 %, costo medio 2.5 pip, break-even 10.7 pip: perde al netto dei costi
T006;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;60;0.7;3;1;3;0.3333;-16.5569;-0.2092;0.0024;10.6949;2.5283;-24.5014;-24.5014;0.1936;0;3 basket, win rate 33 %, netto -17 USD, Sharpe -0.21, DD 0.2 %, costo medio 2.5 pip, break-even 10.7 pip: perde al netto dei costi
T007;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.5;3;1;5;0.4;-68.6995;-0.3203;0.0092;5.8625;2.5825;-60.6171;-60.6171;0.0947;0;5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
T008;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;100;0.5;3;1;5;0.4;-68.6995;-0.3203;0.0092;5.8625;2.5825;-60.6171;-60.6171;0.0947;0;5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
T009;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.6;3;1;5;0.4;-68.6995;-0.3203;0.0092;5.8625;2.5825;-60.6171;-60.6171;0.0947;0;5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
T010;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;100;0.6;3;1;5;0.4;-68.6995;-0.3203;0.0092;5.8625;2.5825;-60.6171;-60.6171;0.0947;0;5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
T011;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;100;0.7;3;1;3;0.3333;-31.767;-0.2049;0.0048;5.9618;2.5284;-38.4174;-38.4174;0.2014;0;3 basket, win rate 33 %, netto -32 USD, Sharpe -0.20, DD 0.5 %, costo medio 2.5 pip, break-even 6.0 pip: perde al netto dei costi
T012;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;100;0.7;3;1;3;0.3333;-31.767;-0.2049;0.0048;5.9618;2.5284;-38.4174;-38.4174;0.2014;0;3 basket, win rate 33 %, netto -32 USD, Sharpe -0.20, DD 0.5 %, costo medio 2.5 pip, break-even 6.0 pip: perde al netto dei costi
T013;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;150;0.5;3;1;8;0.625;-44.5609;-0.1017;0.0143;0.1426;2.3801;-111.7539;-111.7539;0.3732;0;8 basket, win rate 62 %, netto -45 USD, Sharpe -0.10, DD 1.4 %, costo medio 2.4 pip, break-even 0.1 pip: perde al netto dei costi
T014;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;150;0.5;3;1;8;0.625;-44.5609;-0.1017;0.0143;0.1426;2.3801;-111.7539;-111.7539;0.3732;0;8 basket, win rate 62 %, netto -45 USD, Sharpe -0.10, DD 1.4 %, costo medio 2.4 pip, break-even 0.1 pip: perde al netto dei costi
T015;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;150;0.6;3;1;6;0.5;-113.611;-0.2917;0.0152;-4.221;2.629;-111.7539;-111.7539;0.1381;0;6 basket, win rate 50 %, netto -114 USD, Sharpe -0.29, DD 1.5 %, costo medio 2.6 pip, break-even -4.2 pip: perde al netto dei costi
T016;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;150;0.6;3;1;6;0.5;-113.611;-0.2917;0.0152;-4.221;2.629;-111.7539;-111.7539;0.1381;0;6 basket, win rate 50 %, netto -114 USD, Sharpe -0.29, DD 1.5 %, costo medio 2.6 pip, break-even -4.2 pip: perde al netto dei costi
T017;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.25;3;8;150;0.7;3;1;4;0.5;-100.5194;-0.2632;0.0139;-8.8621;2.6129;-111.7035;-111.7035;0.1631;0;4 basket, win rate 50 %, netto -101 USD, Sharpe -0.26, DD 1.4 %, costo medio 2.6 pip, break-even -8.9 pip: perde al netto dei costi
T018;Conservative;ZScoreSynthetic;First;Off;1;2.5;0.5;3;8;150;0.7;3;1;4;0.5;-100.5194;-0.2632;0.0139;-8.8621;2.6129;-111.7035;-111.7035;0.1631;0;4 basket, win rate 50 %, netto -101 USD, Sharpe -0.26, DD 1.4 %, costo medio 2.6 pip, break-even -8.9 pip: perde al netto dei costi
T019;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;60;0.5;3;1;2018;0.4792;-9800.6546;-4.1396;0.9801;-0.7742;3.2141;-103.5455;-51.4822;0;0;2018 basket, win rate 48 %, netto -9801 USD, Sharpe -4.14, DD 98.0 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
T020;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;60;0.5;3;1;2192;0.4886;-9803.1597;-4.2704;0.9803;-0.5484;3.2139;-97.7234;-46.9665;0;0;2192 basket, win rate 49 %, netto -9803 USD, Sharpe -4.27, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T021;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;60;0.6;3;1;1972;0.4787;-9801.7849;-4.0332;0.9802;-0.9003;3.2155;-100.0295;-49.8798;0;0;1972 basket, win rate 48 %, netto -9802 USD, Sharpe -4.03, DD 98.0 %, costo medio 3.2 pip, break-even -0.9 pip: perde al netto dei costi
T022;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;60;0.6;3;1;2069;0.4819;-9803.6976;-4.2507;0.9804;-0.782;3.2167;-93.6889;-48.8346;0;0;2069 basket, win rate 48 %, netto -9804 USD, Sharpe -4.25, DD 98.0 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
T023;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;60;0.7;3;1;2055;0.4818;-9801.1624;-4.0098;0.9801;-0.5217;3.2143;-102.1531;-50.7697;0;0;2055 basket, win rate 48 %, netto -9801 USD, Sharpe -4.01, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T024;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;60;0.7;3;1;2132;0.4855;-9801.1437;-4.1302;0.9801;-0.4595;3.2148;-98.965;-47.3869;0;0;2132 basket, win rate 49 %, netto -9801 USD, Sharpe -4.13, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T025;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.5;3;1;2101;0.4731;-9801.082;-3.7918;0.9804;-0.5503;3.2078;-94.4597;-50.6244;0;0;2101 basket, win rate 47 %, netto -9801 USD, Sharpe -3.79, DD 98.0 %, costo medio 3.2 pip, break-even -0.6 pip: perde al netto dei costi
T026;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;100;0.5;3;1;2140;0.4738;-9801.717;-3.9388;0.9804;-0.5081;3.2089;-80.9489;-48.5339;0;0;2140 basket, win rate 47 %, netto -9802 USD, Sharpe -3.94, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T027;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.6;3;1;2076;0.4769;-9801.9491;-3.8807;0.9804;-0.4892;3.2085;-96.1599;-51.6818;0;0;2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T028;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;100;0.6;3;1;2108;0.4782;-9801.8954;-4.0225;0.9803;-0.4629;3.2091;-87.7027;-50.0178;0;0;2108 basket, win rate 48 %, netto -9802 USD, Sharpe -4.02, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
T029;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;100;0.7;3;1;1984;0.4582;-9797.6241;-4.1086;0.9799;-0.798;3.1973;-92.7908;-47.5743;0;0;1984 basket, win rate 46 %, netto -9798 USD, Sharpe -4.11, DD 98.0 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
T030;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;100;0.7;3;1;2040;0.4574;-9797.1369;-4.2728;0.9799;-0.7345;3.1987;-87.6021;-45.6211;0;0;2040 basket, win rate 46 %, netto -9797 USD, Sharpe -4.27, DD 98.0 %, costo medio 3.2 pip, break-even -0.7 pip: perde al netto dei costi
T031;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;150;0.5;3;1;2238;0.4915;-9733.8654;-3.7948;0.9738;-0.5971;3.1445;-90.112;-47.5574;0;0;2238 basket, win rate 49 %, netto -9734 USD, Sharpe -3.79, DD 97.4 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
T032;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;150;0.5;3;1;2247;0.4887;-9738.5622;-3.9701;0.9742;-0.6768;3.1479;-89.2127;-45.6445;0;0;2247 basket, win rate 49 %, netto -9739 USD, Sharpe -3.97, DD 97.4 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
T033;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;150;0.6;3;1;2090;0.4856;-9697.0682;-3.7782;0.97;-0.7223;3.1429;-95.5498;-51.6315;0;0;2090 basket, win rate 49 %, netto -9697 USD, Sharpe -3.78, DD 97.0 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
T034;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;150;0.6;3;1;2120;0.4863;-9681.6883;-3.8261;0.9684;-0.5759;3.1425;-96.173;-48.981;0;0;2120 basket, win rate 49 %, netto -9682 USD, Sharpe -3.83, DD 96.8 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
T035;Moderate;ZScoreSynthetic;First;Off;1;2;0.25;3.5;10;150;0.7;3;1;1616;0.4901;-9304.7978;-3.3946;0.9309;-0.9725;3.1466;-103.2808;-55.1427;0;0;1616 basket, win rate 49 %, netto -9305 USD, Sharpe -3.39, DD 93.1 %, costo medio 3.1 pip, break-even -1.0 pip: perde al netto dei costi
T036;Moderate;ZScoreSynthetic;First;Off;1;2;0.5;3.5;10;150;0.7;3;1;1650;0.4818;-9315.3955;-3.4957;0.9319;-0.9219;3.1469;-103.8865;-53.903;0;0;1650 basket, win rate 48 %, netto -9315 USD, Sharpe -3.50, DD 93.2 %, costo medio 3.1 pip, break-even -0.9 pip: perde al netto dei costi
T037;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;60;0.5;3;1;2222;0.5018;-9800.1789;-3.493;0.9801;0.1139;3.4884;-95.5877;-43.0006;0;0;2222 basket, win rate 50 %, netto -9800 USD, Sharpe -3.49, DD 98.0 %, costo medio 3.5 pip, break-even 0.1 pip: perde al netto dei costi
T038;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;60;0.5;3;1;2319;0.5071;-9801.3643;-3.6642;0.9802;0.1721;3.4888;-90.1871;-38.1818;0;0;2319 basket, win rate 51 %, netto -9801 USD, Sharpe -3.66, DD 98.0 %, costo medio 3.5 pip, break-even 0.2 pip: perde al netto dei costi
T039;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;60;0.6;3;1;2068;0.4971;-9802.4311;-3.6774;0.9803;-0.3555;3.4622;-96.564;-45.9072;0;0;2068 basket, win rate 50 %, netto -9802 USD, Sharpe -3.68, DD 98.0 %, costo medio 3.5 pip, break-even -0.4 pip: perde al netto dei costi
T040;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;60;0.6;3;1;2261;0.5042;-9801.8015;-3.7059;0.9802;-0.0458;3.4572;-87.7666;-43.2972;0;0;2261 basket, win rate 50 %, netto -9802 USD, Sharpe -3.71, DD 98.0 %, costo medio 3.5 pip, break-even -0.0 pip: perde al netto dei costi
T041;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;60;0.7;3;1;2032;0.4818;-9803.4939;-3.8824;0.9804;-0.2081;3.3942;-102.0523;-51.4273;0;0;2032 basket, win rate 48 %, netto -9803 USD, Sharpe -3.88, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T042;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;60;0.7;3;1;2223;0.4876;-9799.9736;-4.122;0.9801;0.1232;3.3884;-96.1687;-46.1443;0;0;2223 basket, win rate 49 %, netto -9800 USD, Sharpe -4.12, DD 98.0 %, costo medio 3.4 pip, break-even 0.1 pip: perde al netto dei costi
T043;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.5;3;1;2161;0.5298;-9800.4196;-3.5742;0.9806;-0.0636;3.461;-110.6802;-51.9967;0;0;2161 basket, win rate 53 %, netto -9800 USD, Sharpe -3.57, DD 98.1 %, costo medio 3.5 pip, break-even -0.1 pip: perde al netto dei costi
T044;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;100;0.5;3;1;2289;0.5382;-9801.341;-3.7496;0.9806;-0.0314;3.4567;-99.7287;-47.5057;0;0;2289 basket, win rate 54 %, netto -9801 USD, Sharpe -3.75, DD 98.1 %, costo medio 3.5 pip, break-even -0.0 pip: perde al netto dei costi
T045;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.6;3;1;1995;0.5143;-9800.4836;-3.7229;0.9806;-0.1782;3.4269;-113.7756;-55.2381;0;0;1995 basket, win rate 51 %, netto -9800 USD, Sharpe -3.72, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T046;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;100;0.6;3;1;2092;0.5268;-9801.2355;-3.8187;0.9806;-0.1043;3.4231;-103.851;-49.8169;0;0;2092 basket, win rate 53 %, netto -9801 USD, Sharpe -3.82, DD 98.1 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
T047;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;100;0.7;3;1;1790;0.4955;-9801.26;-3.7117;0.9805;-1.011;3.3543;-107.8876;-56.2754;0;0;1790 basket, win rate 50 %, netto -9801 USD, Sharpe -3.71, DD 98.1 %, costo medio 3.4 pip, break-even -1.0 pip: perde al netto dei costi
T048;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;100;0.7;3;1;1972;0.5137;-9802.9285;-3.7993;0.9806;-0.6154;3.3518;-97.0256;-50.7654;0;0;1972 basket, win rate 51 %, netto -9803 USD, Sharpe -3.80, DD 98.1 %, costo medio 3.4 pip, break-even -0.6 pip: perde al netto dei costi
T049;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;150;0.5;3;1;2267;0.5483;-9800.1872;-3.3236;0.9804;-0.2425;3.4352;-127.609;-57.2805;0;0;2267 basket, win rate 55 %, netto -9800 USD, Sharpe -3.32, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T050;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;150;0.5;3;1;2289;0.547;-9800.6111;-3.4919;0.9804;-0.2567;3.4319;-121.7571;-55.2384;0;0;2289 basket, win rate 55 %, netto -9801 USD, Sharpe -3.49, DD 98.0 %, costo medio 3.4 pip, break-even -0.3 pip: perde al netto dei costi
T051;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;150;0.6;3;1;2280;0.55;-9799.948;-3.3521;0.9804;-0.177;3.383;-116.3317;-59.2741;0;0;2280 basket, win rate 55 %, netto -9800 USD, Sharpe -3.35, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
T052;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;150;0.6;3;1;2412;0.5547;-9800.0702;-3.4091;0.9804;0.0354;3.3835;-114.6115;-56.6657;0;0;2412 basket, win rate 55 %, netto -9800 USD, Sharpe -3.41, DD 98.0 %, costo medio 3.4 pip, break-even 0.0 pip: perde al netto dei costi
T053;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.25;4;12;150;0.7;3;1;2298;0.5361;-9802.0629;-3.5954;0.9808;-0.121;3.3223;-127.3343;-57.6739;0;0;2298 basket, win rate 54 %, netto -9802 USD, Sharpe -3.60, DD 98.1 %, costo medio 3.3 pip, break-even -0.1 pip: perde al netto dei costi
T054;Aggressive;ZScoreSynthetic;First;Off;1;1.5;0.5;4;12;150;0.7;3;1;2441;0.5453;-9800.0711;-3.6641;0.9805;0.0417;3.3249;-123.3318;-50.6626;0;0;2441 basket, win rate 55 %, netto -9800 USD, Sharpe -3.66, DD 98.1 %, costo medio 3.3 pip, break-even 0.0 pip: perde al netto dei costi
1 trial_id preset signalMode exitMode averaging lot_multiplier z_in z_out z_stop TP W rho_min cost_multiple basket_stop n_baskets win_rate pnl_net sharpe maxdd break_even_cost avg_cost_pips p1_pnl p5_pnl psr dsr motivazione
2 BASE-CON Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.6 3 1 5 0.4 -68.6995 -0.3203 0.0092 5.8625 2.5825 -60.6171 -60.6171 0.0947 0 5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
3 BASE-MOD Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.6 3 1 2076 0.4769 -9801.9491 -3.8807 0.9804 -0.4892 3.2085 -96.1599 -51.6818 0 0 2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
4 BASE-AGG Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.6 3 1 1995 0.5143 -9800.4836 -3.7229 0.9806 -0.1782 3.4269 -113.7756 -55.2381 0 0 1995 basket, win rate 51 %, netto -9800 USD, Sharpe -3.72, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
5 T001 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 60 0.5 3 1 8 0.5 -69.5629 -0.2771 0.0086 4.9254 2.5879 -80.2036 -80.2036 0.1196 0 8 basket, win rate 50 %, netto -70 USD, Sharpe -0.28, DD 0.9 %, costo medio 2.6 pip, break-even 4.9 pip: perde al netto dei costi
6 T002 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 60 0.5 3 1 8 0.375 -110.4189 -0.3764 0.0127 3.8879 2.5879 -80.2036 -80.2036 0.0455 0 8 basket, win rate 38 %, netto -110 USD, Sharpe -0.38, DD 1.3 %, costo medio 2.6 pip, break-even 3.9 pip: perde al netto dei costi
7 T003 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 60 0.6 3 1 8 0.5 -69.5629 -0.2771 0.0086 4.9254 2.5879 -80.2036 -80.2036 0.1196 0 8 basket, win rate 50 %, netto -70 USD, Sharpe -0.28, DD 0.9 %, costo medio 2.6 pip, break-even 4.9 pip: perde al netto dei costi
8 T004 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 60 0.6 3 1 8 0.375 -110.4189 -0.3764 0.0127 3.8879 2.5879 -80.2036 -80.2036 0.0455 0 8 basket, win rate 38 %, netto -110 USD, Sharpe -0.38, DD 1.3 %, costo medio 2.6 pip, break-even 3.9 pip: perde al netto dei costi
9 T005 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 60 0.7 3 1 3 0.3333 -16.5569 -0.2092 0.0024 10.6949 2.5283 -24.5014 -24.5014 0.1936 0 3 basket, win rate 33 %, netto -17 USD, Sharpe -0.21, DD 0.2 %, costo medio 2.5 pip, break-even 10.7 pip: perde al netto dei costi
10 T006 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 60 0.7 3 1 3 0.3333 -16.5569 -0.2092 0.0024 10.6949 2.5283 -24.5014 -24.5014 0.1936 0 3 basket, win rate 33 %, netto -17 USD, Sharpe -0.21, DD 0.2 %, costo medio 2.5 pip, break-even 10.7 pip: perde al netto dei costi
11 T007 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.5 3 1 5 0.4 -68.6995 -0.3203 0.0092 5.8625 2.5825 -60.6171 -60.6171 0.0947 0 5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
12 T008 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 100 0.5 3 1 5 0.4 -68.6995 -0.3203 0.0092 5.8625 2.5825 -60.6171 -60.6171 0.0947 0 5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
13 T009 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.6 3 1 5 0.4 -68.6995 -0.3203 0.0092 5.8625 2.5825 -60.6171 -60.6171 0.0947 0 5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
14 T010 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 100 0.6 3 1 5 0.4 -68.6995 -0.3203 0.0092 5.8625 2.5825 -60.6171 -60.6171 0.0947 0 5 basket, win rate 40 %, netto -69 USD, Sharpe -0.32, DD 0.9 %, costo medio 2.6 pip, break-even 5.9 pip: perde al netto dei costi
15 T011 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 100 0.7 3 1 3 0.3333 -31.767 -0.2049 0.0048 5.9618 2.5284 -38.4174 -38.4174 0.2014 0 3 basket, win rate 33 %, netto -32 USD, Sharpe -0.20, DD 0.5 %, costo medio 2.5 pip, break-even 6.0 pip: perde al netto dei costi
16 T012 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 100 0.7 3 1 3 0.3333 -31.767 -0.2049 0.0048 5.9618 2.5284 -38.4174 -38.4174 0.2014 0 3 basket, win rate 33 %, netto -32 USD, Sharpe -0.20, DD 0.5 %, costo medio 2.5 pip, break-even 6.0 pip: perde al netto dei costi
17 T013 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 150 0.5 3 1 8 0.625 -44.5609 -0.1017 0.0143 0.1426 2.3801 -111.7539 -111.7539 0.3732 0 8 basket, win rate 62 %, netto -45 USD, Sharpe -0.10, DD 1.4 %, costo medio 2.4 pip, break-even 0.1 pip: perde al netto dei costi
18 T014 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 150 0.5 3 1 8 0.625 -44.5609 -0.1017 0.0143 0.1426 2.3801 -111.7539 -111.7539 0.3732 0 8 basket, win rate 62 %, netto -45 USD, Sharpe -0.10, DD 1.4 %, costo medio 2.4 pip, break-even 0.1 pip: perde al netto dei costi
19 T015 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 150 0.6 3 1 6 0.5 -113.611 -0.2917 0.0152 -4.221 2.629 -111.7539 -111.7539 0.1381 0 6 basket, win rate 50 %, netto -114 USD, Sharpe -0.29, DD 1.5 %, costo medio 2.6 pip, break-even -4.2 pip: perde al netto dei costi
20 T016 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 150 0.6 3 1 6 0.5 -113.611 -0.2917 0.0152 -4.221 2.629 -111.7539 -111.7539 0.1381 0 6 basket, win rate 50 %, netto -114 USD, Sharpe -0.29, DD 1.5 %, costo medio 2.6 pip, break-even -4.2 pip: perde al netto dei costi
21 T017 Conservative ZScoreSynthetic First Off 1 2.5 0.25 3 8 150 0.7 3 1 4 0.5 -100.5194 -0.2632 0.0139 -8.8621 2.6129 -111.7035 -111.7035 0.1631 0 4 basket, win rate 50 %, netto -101 USD, Sharpe -0.26, DD 1.4 %, costo medio 2.6 pip, break-even -8.9 pip: perde al netto dei costi
22 T018 Conservative ZScoreSynthetic First Off 1 2.5 0.5 3 8 150 0.7 3 1 4 0.5 -100.5194 -0.2632 0.0139 -8.8621 2.6129 -111.7035 -111.7035 0.1631 0 4 basket, win rate 50 %, netto -101 USD, Sharpe -0.26, DD 1.4 %, costo medio 2.6 pip, break-even -8.9 pip: perde al netto dei costi
23 T019 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 60 0.5 3 1 2018 0.4792 -9800.6546 -4.1396 0.9801 -0.7742 3.2141 -103.5455 -51.4822 0 0 2018 basket, win rate 48 %, netto -9801 USD, Sharpe -4.14, DD 98.0 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
24 T020 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 60 0.5 3 1 2192 0.4886 -9803.1597 -4.2704 0.9803 -0.5484 3.2139 -97.7234 -46.9665 0 0 2192 basket, win rate 49 %, netto -9803 USD, Sharpe -4.27, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
25 T021 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 60 0.6 3 1 1972 0.4787 -9801.7849 -4.0332 0.9802 -0.9003 3.2155 -100.0295 -49.8798 0 0 1972 basket, win rate 48 %, netto -9802 USD, Sharpe -4.03, DD 98.0 %, costo medio 3.2 pip, break-even -0.9 pip: perde al netto dei costi
26 T022 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 60 0.6 3 1 2069 0.4819 -9803.6976 -4.2507 0.9804 -0.782 3.2167 -93.6889 -48.8346 0 0 2069 basket, win rate 48 %, netto -9804 USD, Sharpe -4.25, DD 98.0 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
27 T023 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 60 0.7 3 1 2055 0.4818 -9801.1624 -4.0098 0.9801 -0.5217 3.2143 -102.1531 -50.7697 0 0 2055 basket, win rate 48 %, netto -9801 USD, Sharpe -4.01, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
28 T024 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 60 0.7 3 1 2132 0.4855 -9801.1437 -4.1302 0.9801 -0.4595 3.2148 -98.965 -47.3869 0 0 2132 basket, win rate 49 %, netto -9801 USD, Sharpe -4.13, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
29 T025 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.5 3 1 2101 0.4731 -9801.082 -3.7918 0.9804 -0.5503 3.2078 -94.4597 -50.6244 0 0 2101 basket, win rate 47 %, netto -9801 USD, Sharpe -3.79, DD 98.0 %, costo medio 3.2 pip, break-even -0.6 pip: perde al netto dei costi
30 T026 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 100 0.5 3 1 2140 0.4738 -9801.717 -3.9388 0.9804 -0.5081 3.2089 -80.9489 -48.5339 0 0 2140 basket, win rate 47 %, netto -9802 USD, Sharpe -3.94, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
31 T027 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.6 3 1 2076 0.4769 -9801.9491 -3.8807 0.9804 -0.4892 3.2085 -96.1599 -51.6818 0 0 2076 basket, win rate 48 %, netto -9802 USD, Sharpe -3.88, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
32 T028 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 100 0.6 3 1 2108 0.4782 -9801.8954 -4.0225 0.9803 -0.4629 3.2091 -87.7027 -50.0178 0 0 2108 basket, win rate 48 %, netto -9802 USD, Sharpe -4.02, DD 98.0 %, costo medio 3.2 pip, break-even -0.5 pip: perde al netto dei costi
33 T029 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 100 0.7 3 1 1984 0.4582 -9797.6241 -4.1086 0.9799 -0.798 3.1973 -92.7908 -47.5743 0 0 1984 basket, win rate 46 %, netto -9798 USD, Sharpe -4.11, DD 98.0 %, costo medio 3.2 pip, break-even -0.8 pip: perde al netto dei costi
34 T030 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 100 0.7 3 1 2040 0.4574 -9797.1369 -4.2728 0.9799 -0.7345 3.1987 -87.6021 -45.6211 0 0 2040 basket, win rate 46 %, netto -9797 USD, Sharpe -4.27, DD 98.0 %, costo medio 3.2 pip, break-even -0.7 pip: perde al netto dei costi
35 T031 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 150 0.5 3 1 2238 0.4915 -9733.8654 -3.7948 0.9738 -0.5971 3.1445 -90.112 -47.5574 0 0 2238 basket, win rate 49 %, netto -9734 USD, Sharpe -3.79, DD 97.4 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
36 T032 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 150 0.5 3 1 2247 0.4887 -9738.5622 -3.9701 0.9742 -0.6768 3.1479 -89.2127 -45.6445 0 0 2247 basket, win rate 49 %, netto -9739 USD, Sharpe -3.97, DD 97.4 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
37 T033 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 150 0.6 3 1 2090 0.4856 -9697.0682 -3.7782 0.97 -0.7223 3.1429 -95.5498 -51.6315 0 0 2090 basket, win rate 49 %, netto -9697 USD, Sharpe -3.78, DD 97.0 %, costo medio 3.1 pip, break-even -0.7 pip: perde al netto dei costi
38 T034 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 150 0.6 3 1 2120 0.4863 -9681.6883 -3.8261 0.9684 -0.5759 3.1425 -96.173 -48.981 0 0 2120 basket, win rate 49 %, netto -9682 USD, Sharpe -3.83, DD 96.8 %, costo medio 3.1 pip, break-even -0.6 pip: perde al netto dei costi
39 T035 Moderate ZScoreSynthetic First Off 1 2 0.25 3.5 10 150 0.7 3 1 1616 0.4901 -9304.7978 -3.3946 0.9309 -0.9725 3.1466 -103.2808 -55.1427 0 0 1616 basket, win rate 49 %, netto -9305 USD, Sharpe -3.39, DD 93.1 %, costo medio 3.1 pip, break-even -1.0 pip: perde al netto dei costi
40 T036 Moderate ZScoreSynthetic First Off 1 2 0.5 3.5 10 150 0.7 3 1 1650 0.4818 -9315.3955 -3.4957 0.9319 -0.9219 3.1469 -103.8865 -53.903 0 0 1650 basket, win rate 48 %, netto -9315 USD, Sharpe -3.50, DD 93.2 %, costo medio 3.1 pip, break-even -0.9 pip: perde al netto dei costi
41 T037 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 60 0.5 3 1 2222 0.5018 -9800.1789 -3.493 0.9801 0.1139 3.4884 -95.5877 -43.0006 0 0 2222 basket, win rate 50 %, netto -9800 USD, Sharpe -3.49, DD 98.0 %, costo medio 3.5 pip, break-even 0.1 pip: perde al netto dei costi
42 T038 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 60 0.5 3 1 2319 0.5071 -9801.3643 -3.6642 0.9802 0.1721 3.4888 -90.1871 -38.1818 0 0 2319 basket, win rate 51 %, netto -9801 USD, Sharpe -3.66, DD 98.0 %, costo medio 3.5 pip, break-even 0.2 pip: perde al netto dei costi
43 T039 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 60 0.6 3 1 2068 0.4971 -9802.4311 -3.6774 0.9803 -0.3555 3.4622 -96.564 -45.9072 0 0 2068 basket, win rate 50 %, netto -9802 USD, Sharpe -3.68, DD 98.0 %, costo medio 3.5 pip, break-even -0.4 pip: perde al netto dei costi
44 T040 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 60 0.6 3 1 2261 0.5042 -9801.8015 -3.7059 0.9802 -0.0458 3.4572 -87.7666 -43.2972 0 0 2261 basket, win rate 50 %, netto -9802 USD, Sharpe -3.71, DD 98.0 %, costo medio 3.5 pip, break-even -0.0 pip: perde al netto dei costi
45 T041 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 60 0.7 3 1 2032 0.4818 -9803.4939 -3.8824 0.9804 -0.2081 3.3942 -102.0523 -51.4273 0 0 2032 basket, win rate 48 %, netto -9803 USD, Sharpe -3.88, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
46 T042 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 60 0.7 3 1 2223 0.4876 -9799.9736 -4.122 0.9801 0.1232 3.3884 -96.1687 -46.1443 0 0 2223 basket, win rate 49 %, netto -9800 USD, Sharpe -4.12, DD 98.0 %, costo medio 3.4 pip, break-even 0.1 pip: perde al netto dei costi
47 T043 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.5 3 1 2161 0.5298 -9800.4196 -3.5742 0.9806 -0.0636 3.461 -110.6802 -51.9967 0 0 2161 basket, win rate 53 %, netto -9800 USD, Sharpe -3.57, DD 98.1 %, costo medio 3.5 pip, break-even -0.1 pip: perde al netto dei costi
48 T044 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 100 0.5 3 1 2289 0.5382 -9801.341 -3.7496 0.9806 -0.0314 3.4567 -99.7287 -47.5057 0 0 2289 basket, win rate 54 %, netto -9801 USD, Sharpe -3.75, DD 98.1 %, costo medio 3.5 pip, break-even -0.0 pip: perde al netto dei costi
49 T045 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.6 3 1 1995 0.5143 -9800.4836 -3.7229 0.9806 -0.1782 3.4269 -113.7756 -55.2381 0 0 1995 basket, win rate 51 %, netto -9800 USD, Sharpe -3.72, DD 98.1 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
50 T046 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 100 0.6 3 1 2092 0.5268 -9801.2355 -3.8187 0.9806 -0.1043 3.4231 -103.851 -49.8169 0 0 2092 basket, win rate 53 %, netto -9801 USD, Sharpe -3.82, DD 98.1 %, costo medio 3.4 pip, break-even -0.1 pip: perde al netto dei costi
51 T047 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 100 0.7 3 1 1790 0.4955 -9801.26 -3.7117 0.9805 -1.011 3.3543 -107.8876 -56.2754 0 0 1790 basket, win rate 50 %, netto -9801 USD, Sharpe -3.71, DD 98.1 %, costo medio 3.4 pip, break-even -1.0 pip: perde al netto dei costi
52 T048 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 100 0.7 3 1 1972 0.5137 -9802.9285 -3.7993 0.9806 -0.6154 3.3518 -97.0256 -50.7654 0 0 1972 basket, win rate 51 %, netto -9803 USD, Sharpe -3.80, DD 98.1 %, costo medio 3.4 pip, break-even -0.6 pip: perde al netto dei costi
53 T049 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 150 0.5 3 1 2267 0.5483 -9800.1872 -3.3236 0.9804 -0.2425 3.4352 -127.609 -57.2805 0 0 2267 basket, win rate 55 %, netto -9800 USD, Sharpe -3.32, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
54 T050 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 150 0.5 3 1 2289 0.547 -9800.6111 -3.4919 0.9804 -0.2567 3.4319 -121.7571 -55.2384 0 0 2289 basket, win rate 55 %, netto -9801 USD, Sharpe -3.49, DD 98.0 %, costo medio 3.4 pip, break-even -0.3 pip: perde al netto dei costi
55 T051 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 150 0.6 3 1 2280 0.55 -9799.948 -3.3521 0.9804 -0.177 3.383 -116.3317 -59.2741 0 0 2280 basket, win rate 55 %, netto -9800 USD, Sharpe -3.35, DD 98.0 %, costo medio 3.4 pip, break-even -0.2 pip: perde al netto dei costi
56 T052 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 150 0.6 3 1 2412 0.5547 -9800.0702 -3.4091 0.9804 0.0354 3.3835 -114.6115 -56.6657 0 0 2412 basket, win rate 55 %, netto -9800 USD, Sharpe -3.41, DD 98.0 %, costo medio 3.4 pip, break-even 0.0 pip: perde al netto dei costi
57 T053 Aggressive ZScoreSynthetic First Off 1 1.5 0.25 4 12 150 0.7 3 1 2298 0.5361 -9802.0629 -3.5954 0.9808 -0.121 3.3223 -127.3343 -57.6739 0 0 2298 basket, win rate 54 %, netto -9802 USD, Sharpe -3.60, DD 98.1 %, costo medio 3.3 pip, break-even -0.1 pip: perde al netto dei costi
58 T054 Aggressive ZScoreSynthetic First Off 1 1.5 0.5 4 12 150 0.7 3 1 2441 0.5453 -9800.0711 -3.6641 0.9805 0.0417 3.3249 -123.3318 -50.6626 0 0 2441 basket, win rate 55 %, netto -9800 USD, Sharpe -3.66, DD 98.1 %, costo medio 3.3 pip, break-even 0.0 pip: perde al netto dei costi
+40
View File
@@ -0,0 +1,40 @@
// A screenshot at a true device size through the DevTools protocol of a headless Edge/Chrome, for
// scripts/screenshots.sh: desktop Edge will not make a window narrower than about 500 px, so
// --window-size=420,860 would photograph a 500 px page cut on the right. Node 22+ (global fetch
// and WebSocket), no packages. scripts/screenshots.ps1 does the same in PowerShell.
// node scripts/cdp-shot.mjs <browser> <url> <out.png> <width> <height> <profileDir>
import { spawn } from 'node:child_process';
import { writeFileSync } from 'node:fs';
const [browser, url, out, width, height, profile] = process.argv.slice(2);
const port = 9300 + Math.floor(Math.random() * 500);
const proc = spawn(browser, ['--headless=new', '--disable-gpu', '--no-first-run', '--no-default-browser-check', '--hide-scrollbars', '--disable-extensions',
`--remote-debugging-port=${port}`, `--user-data-dir=${profile}`, 'about:blank'], { stdio: 'ignore' });
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
let code = 1;
try {
let target = null;
for (let i = 0; i < 60 && !target; i++) {
await sleep(250);
try { target = (await (await fetch(`http://127.0.0.1:${port}/json/list`)).json()).find(t => t.type === 'page'); } catch { /* not up yet */ }
}
if (!target) throw new Error(`il browser non espone il protocollo DevTools sulla porta ${port}`);
const ws = new WebSocket(target.webSocketDebuggerUrl);
await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = reject; });
let id = 0;
const pending = new Map();
ws.onmessage = ev => { const m = JSON.parse(ev.data); if (m.id && pending.has(m.id)) { pending.get(m.id)(m); pending.delete(m.id); } };
const send = (method, params = {}) => new Promise(resolve => { const i = ++id; pending.set(i, resolve); ws.send(JSON.stringify({ id: i, method, params })); });
await send('Emulation.setDeviceMetricsOverride', { width: Number(width), height: Number(height), deviceScaleFactor: 1, mobile: true });
await send('Page.navigate', { url });
await sleep(4000);
const shot = await send('Page.captureScreenshot', { format: 'png' });
writeFileSync(out, Buffer.from(shot.result.data, 'base64'));
ws.close();
code = 0;
} catch (e) {
console.error(e.message);
} finally {
proc.kill();
process.exit(code);
}
+45
View File
@@ -0,0 +1,45 @@
<#
.SYNOPSIS
Compila e avvia Encelado in locale, senza container, nella sandbox deploy/local.
.DESCRIPTION
Stessa disposizione del container: deploy/local/config (encelado.json, strategy.json,
segreti cifrati) e deploy/local/data (ledger, stato, log). La cartella è ignorata da git.
La password dell'interfaccia è "sviluppo", come nel compose: i segreti cifrati della
sandbox restano leggibili in entrambi i modi. La password serve ai segreti, non apre la
rete: il server ascolta solo su localhost (la rete solo nel container o con --listen-all).
Conto, chiavi eToro dei due conti e Telegram si impostano da Impostazioni nella pagina.
scripts\run-dev.ps1 # motore fermo: premi AVVIA nella pagina
scripts\run-dev.ps1 -Autostart # motore avviato subito (servono le chiavi)
scripts\run-dev.ps1 -Sample # dati finti in cartelle temporanee: la sandbox, i segreti e Telegram non vengono toccati
scripts\run-dev.ps1 -Port 8090
#>
param(
[int] $Port = 8080,
[switch] $Autostart,
[switch] $Sample,
[switch] $NoBrowser
)
$ErrorActionPreference = "Stop"
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
$env:ENCELADO_CONFIG_DIR = Join-Path $root "deploy\local\config"
$env:ENCELADO_DATA_DIR = Join-Path $root "deploy\local\data"
$env:ENCELADO_WEB_PORT = "$Port"
$env:ENCELADO_PASSWORD = "sviluppo"
New-Item -ItemType Directory -Force $env:ENCELADO_CONFIG_DIR, $env:ENCELADO_DATA_DIR | Out-Null
dotnet build src/Encelado.Server -c Debug -nologo -v q
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
$args = @()
if ($Sample) { $args += "--sample" } elseif (-not $Autostart) { $args += "--no-autostart" }
$url = "http://localhost:$Port/"
$where = if ($Sample) { "campione: cartelle temporanee, deploy\local non viene letto" } else { "configurazione in deploy\local\config, dati in deploy\local\data" }
Write-Host "Encelado in locale: $url password: quella della sandbox, sviluppo (solo localhost; $where)" -ForegroundColor Cyan
Write-Host "Comandi da tastiera: status, close <basket>, kill, residuo, reset <motivazione>, bonifica, stop. Ctrl+C = arresto." -ForegroundColor DarkGray
if (-not $NoBrowser) { Start-Job -ScriptBlock { param($u) Start-Sleep -Seconds 3; Start-Process $u } -ArgumentList $url | Out-Null }
dotnet src/Encelado.Server/bin/Debug/net10.0/Encelado.Server.dll @args
+31
View File
@@ -0,0 +1,31 @@
#!/usr/bin/env sh
# Builds and starts Encelado locally, without the container, in the deploy/local sandbox
# (deploy/local/config as /config, deploy/local/data as /data; ignored by git).
# sh scripts/run-dev.sh # engine stopped: press AVVIA in the page
# sh scripts/run-dev.sh --sample # fake data in throwaway folders: the sandbox, its secrets and Telegram are not touched
# sh scripts/run-dev.sh --autostart # engine started at once (keys needed)
# The interface password is "sviluppo", as in docker-compose.yml: the encrypted secrets of
# the sandbox (eToro keys, Telegram token, entered from Impostazioni) stay readable both ways.
# The password is for the secrets, not for the network: the server listens on localhost only
# (the network only in the container or with --listen-all).
set -eu
cd "$(dirname "$0")/.."
export ENCELADO_CONFIG_DIR="$(pwd)/deploy/local/config"
export ENCELADO_DATA_DIR="$(pwd)/deploy/local/data"
export ENCELADO_WEB_PORT="${ENCELADO_WEB_PORT:-8080}"
export ENCELADO_PASSWORD="sviluppo"
mkdir -p "$ENCELADO_CONFIG_DIR" "$ENCELADO_DATA_DIR"
MODE="--no-autostart"
for a in "$@"; do
case "$a" in
--sample) MODE="--sample" ;;
--autostart) MODE="" ;;
esac
done
dotnet build src/Encelado.Server -c Debug -nologo -v q
WHERE="config in deploy/local/config, dati in deploy/local/data"
[ "$MODE" = "--sample" ] && WHERE="campione: cartelle temporanee, deploy/local non viene letto"
echo "Encelado in locale: http://localhost:$ENCELADO_WEB_PORT/ password: quella della sandbox, sviluppo (solo localhost; $WHERE)"
exec dotnet src/Encelado.Server/bin/Debug/net10.0/Encelado.Server.dll $MODE
+43
View File
@@ -0,0 +1,43 @@
<#
.SYNOPSIS
Costruisce l'immagine e avvia Encelado nel container con la docker-compose.yml alla radice.
.DESCRIPTION
Le cartelle deploy/local/config e deploy/local/data vengono montate come /config e /data:
sono le stesse di scripts\run-dev.ps1, quindi configurazione e segreti salvati valgono
in entrambi i modi. La password dell'interfaccia è "sviluppo" salvo ENCELADO_PASSWORD in
un file .env accanto alla compose; conto, chiavi eToro e Telegram si impostano dalla
pagina Impostazioni. Segue il log finché non premi Ctrl+C; il container resta acceso:
scripts\run-docker.ps1 -Down per fermarlo (SIGTERM, stop pulito).
scripts\run-docker.ps1 # build + up -d + log
scripts\run-docker.ps1 -NoBuild # senza ricostruire l'immagine
scripts\run-docker.ps1 -Down # docker compose down
#>
param(
[switch] $NoBuild,
[switch] $Down,
[switch] $NoBrowser
)
$ErrorActionPreference = "Stop"
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
if ($Down) { docker compose down; exit $LASTEXITCODE }
New-Item -ItemType Directory -Force "deploy\local\config", "deploy\local\data" | Out-Null
$env:GIT_COMMIT = (git rev-parse --short=12 HEAD 2>$null); if (-not $env:GIT_COMMIT) { $env:GIT_COMMIT = "n/d" }
if ($NoBuild) { docker compose up -d } else { docker compose up -d --build }
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
$port = if ($env:ENCELADO_WEB_PORT) { $env:ENCELADO_WEB_PORT } else { "8080" }
# Da dove viene la password, mai il suo valore (può essere una vera): la variabile, poi il .env della compose.
$envFile = Join-Path $root ".env"
$password = if ($env:ENCELADO_PASSWORD) { "(da ENCELADO_PASSWORD)" }
elseif ((Test-Path $envFile) -and (Select-String -Path $envFile -Pattern '^\s*ENCELADO_PASSWORD=.+' -Quiet)) { "(da .env)" }
else { "sviluppo (quella predefinita della compose)" }
$url = "http://localhost:$port/"
Write-Host "Encelado nel container: $url password: $password (docker compose down per fermare)" -ForegroundColor Cyan
if (-not $NoBrowser) { Start-Job -ScriptBlock { param($u) Start-Sleep -Seconds 4; Start-Process $u } -ArgumentList $url | Out-Null }
docker compose logs -f encelado
+26
View File
@@ -0,0 +1,26 @@
#!/usr/bin/env sh
# Builds the image and starts Encelado in the container with the docker-compose.yml at the root.
# deploy/local/config and deploy/local/data are mounted as /config and /data (the same
# folders scripts/run-dev.sh uses). Interface password "sviluppo" unless ENCELADO_PASSWORD
# is in .env; account, eToro keys and Telegram are set from the Impostazioni page.
# sh scripts/run-docker.sh # build + up -d + follow the log (Ctrl+C leaves it running)
# sh scripts/run-docker.sh --no-build
# sh scripts/run-docker.sh --down # docker compose down (SIGTERM, clean stop)
set -eu
cd "$(dirname "$0")/.."
case "${1:-}" in
--down) exec docker compose down ;;
esac
mkdir -p deploy/local/config deploy/local/data
export GIT_COMMIT="$(git rev-parse --short=12 HEAD 2>/dev/null || echo n/d)"
if [ "${1:-}" = "--no-build" ]; then docker compose up -d; else docker compose up -d --build; fi
# Where the password comes from, never its value (it may be a real one).
if [ -n "${ENCELADO_PASSWORD:-}" ]; then
PASSWORD_NOTE="(da ENCELADO_PASSWORD)"
elif [ -f .env ] && grep -Eq '^[[:space:]]*ENCELADO_PASSWORD=.+' .env; then
PASSWORD_NOTE="(da .env)"
else
PASSWORD_NOTE="sviluppo (quella predefinita della compose)"
fi
echo "Encelado nel container: http://localhost:${ENCELADO_WEB_PORT:-8080}/ password: $PASSWORD_NOTE (sh scripts/run-docker.sh --down per fermare)"
exec docker compose logs -f encelado
+134
View File
@@ -0,0 +1,134 @@
<#
.SYNOPSIS
Rigenera docs/img/*.png: il server in modalità campione (--sample) e Edge headless su ogni pagina.
.DESCRIPTION
Niente chiavi, niente mercato: i dati sono d'esempio ma coerenti fra loro (SampleData), su una
configurazione temporanea che non tocca la sandbox né Documenti. Serve Microsoft Edge.
Le pagine si aprono con ?once=1 (una sola lettura dello snapshot, nessuno stream: con uno stream
aperto il browser headless non considera mai concluso il caricamento). Le foto da computer
(1440x900) usano --screenshot; quella da telefono (420x860) passa dal protocollo DevTools con
l'emulazione della finestra, perché Edge per desktop non stringe la finestra sotto circa 500 px
e --window-size=420 darebbe una pagina larga 500 tagliata a destra.
scripts\screenshots.ps1 [-Port 58085] [-Only dashboard,mobile]
#>
param([int] $Port = 58085, [string[]] $Only = @())
$ErrorActionPreference = "Stop"
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
$edge = @("${env:ProgramFiles(x86)}\Microsoft\Edge\Application\msedge.exe", "$env:ProgramFiles\Microsoft\Edge\Application\msedge.exe") | Where-Object { Test-Path $_ } | Select-Object -First 1
if (-not $edge) { throw "Microsoft Edge non trovato" }
# Pagina, nome del file e dimensione; "mobile" è la dashboard su un telefono.
$shots = @(
@{ name = "dashboard"; page = "dashboard"; size = "1440,900" },
@{ name = "dashboard-chiaro"; page = "dashboard"; size = "1440,900"; query = "theme=light" },
@{ name = "basket"; page = "basket"; size = "1440,900" },
@{ name = "posizioni"; page = "posizioni"; size = "1440,900" },
@{ name = "mercato"; page = "mercato"; size = "1440,900" },
@{ name = "storico"; page = "storico"; size = "1440,900" },
@{ name = "apprendimento"; page = "apprendimento"; size = "1440,900" },
@{ name = "log"; page = "log"; size = "1440,900" },
@{ name = "sistema"; page = "sistema"; size = "1440,900" },
@{ name = "impostazioni"; page = "impostazioni"; size = "1440,900" },
@{ name = "login"; page = "login"; size = "1440,900" },
@{ name = "mobile"; page = "dashboard"; size = "420,860"; device = $true }
)
if ($Only.Count -gt 0) { $shots = @($shots | Where-Object { $Only -contains $_.name }) }
function Get-PageUrl($shot) {
if ($shot.page -eq "login") { return "http://127.0.0.1:$Port/login" }
$q = "once=1" + $(if ($shot.query) { "&" + $shot.query } else { "" })
return "http://127.0.0.1:$Port/?$q#/$($shot.page)"
}
# One DevTools command over the page's WebSocket; events that arrive meanwhile are skipped.
function Invoke-Cdp($ws, [int] $id, [string] $method, $params) {
$json = @{ id = $id; method = $method; params = $params } | ConvertTo-Json -Depth 6 -Compress
$bytes = [Text.Encoding]::UTF8.GetBytes($json)
$ws.SendAsync([ArraySegment[byte]]::new($bytes), [Net.WebSockets.WebSocketMessageType]::Text, $true, [Threading.CancellationToken]::None).Wait()
$buffer = New-Object byte[] 65536
while ($true) {
$ms = New-Object IO.MemoryStream
do {
$r = $ws.ReceiveAsync([ArraySegment[byte]]::new($buffer), [Threading.CancellationToken]::None).Result
$ms.Write($buffer, 0, $r.Count)
} while (-not $r.EndOfMessage)
$text = [Text.Encoding]::UTF8.GetString($ms.ToArray())
if ($text -match ('^\{"id":' + $id + '[,}]')) { return $text }
}
}
# The phone shot: a real 420 px viewport through the DevTools protocol (no Node, no library).
function Save-DeviceShot([string] $url, [string] $out, [int] $width, [int] $height, [string] $profileDir) {
$debugPort = Get-Random -Minimum 9300 -Maximum 9800
$edgeArgs = @("--headless=new", "--disable-gpu", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", "--disable-extensions", "--remote-debugging-port=$debugPort", "--user-data-dir=$profileDir", "about:blank")
$browser = Start-Process -FilePath $edge -ArgumentList $edgeArgs -PassThru -WindowStyle Hidden -RedirectStandardError "$profileDir.err" -RedirectStandardOutput "$profileDir.out"
$ws = $null
try {
$target = $null
for ($i = 0; $i -lt 60 -and -not $target; $i++) {
Start-Sleep -Milliseconds 250
# PowerShell 5.1 passes a JSON array down the pipeline as one object: @() enumerates it.
try { $list = (Invoke-WebRequest -UseBasicParsing "http://127.0.0.1:$debugPort/json/list" -TimeoutSec 2).Content | ConvertFrom-Json; $target = @($list) | Where-Object { $_.type -eq "page" } | Select-Object -First 1 } catch {}
}
if (-not $target) { throw "Edge non espone il protocollo DevTools sulla porta $debugPort" }
$ws = New-Object Net.WebSockets.ClientWebSocket
$ws.ConnectAsync([Uri] $target.webSocketDebuggerUrl, [Threading.CancellationToken]::None).Wait()
Invoke-Cdp $ws 1 "Emulation.setDeviceMetricsOverride" @{ width = $width; height = $height; deviceScaleFactor = 1; mobile = $true } | Out-Null
Invoke-Cdp $ws 2 "Page.navigate" @{ url = $url } | Out-Null
Start-Sleep -Seconds 4
$answer = Invoke-Cdp $ws 3 "Page.captureScreenshot" @{ format = "png" }
$data = [regex]::Match($answer, '"data":"([^"]+)"')
if (-not $data.Success) { throw "screenshot non ricevuto: $($answer.Substring(0, [Math]::Min(200, $answer.Length)))" }
[IO.File]::WriteAllBytes($out, [Convert]::FromBase64String($data.Groups[1].Value))
}
finally {
if ($ws) { $ws.Dispose() }
# The whole tree of this headless Edge (renderer, GPU, crashpad), never another Edge of the user.
if (-not $browser.HasExited) { & taskkill.exe /PID $browser.Id /T /F 2>&1 | Out-Null }
}
}
dotnet build src/Encelado.Server -c Debug -nologo -v q
if ($LASTEXITCODE -ne 0) { throw "compilazione non riuscita" }
$work = Join-Path $env:TEMP ("encelado-shot-" + [guid]::NewGuid().ToString("N"))
New-Item -ItemType Directory -Force "$work\config", "$work\data", "docs\img" | Out-Null
# The sample server gets its own folders and no password (a password would show the login everywhere);
# the variables of this session are put back at the end.
$variables = "ENCELADO_CONFIG_DIR", "ENCELADO_DATA_DIR", "ENCELADO_PASSWORD", "ENCELADO_WEB_TOKEN"
$saved = @{}
foreach ($v in $variables) { $saved[$v] = [Environment]::GetEnvironmentVariable($v, "Process") }
$env:ENCELADO_CONFIG_DIR = "$work\config"
$env:ENCELADO_DATA_DIR = "$work\data"
Remove-Item Env:ENCELADO_PASSWORD, Env:ENCELADO_WEB_TOKEN -ErrorAction SilentlyContinue
$server = Start-Process -FilePath "dotnet" -ArgumentList "src/Encelado.Server/bin/Debug/net10.0/Encelado.Server.dll", "--sample", "--port", "$Port" -PassThru -WindowStyle Hidden -RedirectStandardOutput "$work\server.out" -RedirectStandardError "$work\server.err"
try {
$ready = $false
for ($i = 0; $i -lt 30 -and -not $ready; $i++) { Start-Sleep -Seconds 1; try { $ready = (Invoke-WebRequest -UseBasicParsing "http://127.0.0.1:$Port/api/health" -TimeoutSec 2).StatusCode -eq 200 } catch {} }
if (-not $ready) { throw "il server campione non risponde sulla porta $Port" }
foreach ($s in $shots) {
$out = Join-Path $root ("docs\img\" + $s.name + ".png")
$profileDir = Join-Path $work ("edge-" + $s.name)
if (Test-Path $out) { Remove-Item $out -Force }
$w, $h = $s.size.Split(",")
if ($s.device) {
Save-DeviceShot (Get-PageUrl $s) $out ([int] $w) ([int] $h) $profileDir
}
else {
# Start-Process: Edge scrive avvisi su stderr e in PowerShell 5.1 diventerebbero errori bloccanti.
$edgeArgs = @("--headless=new", "--disable-gpu", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", "--disable-extensions", "--user-data-dir=$profileDir", "--window-size=$($s.size)", "--virtual-time-budget=6000", "--screenshot=$out", (Get-PageUrl $s))
Start-Process -FilePath $edge -ArgumentList $edgeArgs -Wait -WindowStyle Hidden -RedirectStandardError "$profileDir.err" -RedirectStandardOutput "$profileDir.out"
}
if (Test-Path $out) { Write-Host (" {0,-17} {1,9:N0} byte" -f $s.name, (Get-Item $out).Length) } else { Write-Warning "$($s.name): screenshot non scritto" }
}
}
finally {
if ($server -and -not $server.HasExited) { Stop-Process -Id $server.Id -Force }
foreach ($v in $variables) { [Environment]::SetEnvironmentVariable($v, $saved[$v], "Process") }
Start-Sleep -Milliseconds 500
Remove-Item $work -Recurse -Force -ErrorAction SilentlyContinue
}
+61
View File
@@ -0,0 +1,61 @@
#!/usr/bin/env sh
# Regenerates docs/img/*.png: the server in sample mode (--sample) and a headless Edge/Chrome on every page.
# No keys, no market: the data is sample data, consistent across the pages. Pages are opened with ?once=1
# (one snapshot, no stream), otherwise the headless browser never considers the page loaded. The phone
# shot (420x860) needs a true 420 px viewport: through the DevTools protocol with Node 22+ when present
# (scripts/cdp-shot.mjs), otherwise --window-size, which desktop Edge widens to about 500 px.
# sh scripts/screenshots.sh [port]
set -eu
cd "$(dirname "$0")/.."
PORT="${1:-58085}"
BROWSER="${ENCELADO_BROWSER:-}"
for c in "/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe" "/c/Program Files/Microsoft/Edge/Application/msedge.exe" "$(command -v microsoft-edge || true)" "$(command -v google-chrome || true)" "$(command -v chromium || true)"; do
[ -n "$BROWSER" ] && break
[ -n "$c" ] && [ -x "$c" ] && BROWSER="$c"
done
[ -n "$BROWSER" ] || { echo "nessun browser Chromium trovato (imposta ENCELADO_BROWSER)" >&2; exit 1; }
# Windows paths for the native programs when running in Git Bash.
native() { if command -v cygpath >/dev/null 2>&1; then cygpath -w "$1"; else printf '%s' "$1"; fi; }
dotnet build src/Encelado.Server -c Debug -nologo -v q
WORK="$(mktemp -d)"
cleanup() {
if [ -n "${PID:-}" ]; then kill "$PID" 2>/dev/null || true; wait "$PID" 2>/dev/null || true; fi
# On Windows the server's log file may stay locked for a moment after the process exits.
rm -rf "$WORK" 2>/dev/null || { sleep 2; rm -rf "$WORK" 2>/dev/null || true; }
}
trap cleanup EXIT
mkdir -p "$WORK/config" "$WORK/data" docs/img
# Own folders and no password: a password would show the login page everywhere.
env -u ENCELADO_PASSWORD -u ENCELADO_WEB_TOKEN ENCELADO_CONFIG_DIR="$WORK/config" ENCELADO_DATA_DIR="$WORK/data" \
dotnet src/Encelado.Server/bin/Debug/net10.0/Encelado.Server.dll --sample --port "$PORT" >"$WORK/server.out" 2>&1 &
PID=$!
i=0; until curl -sf "http://127.0.0.1:$PORT/api/health" >/dev/null 2>&1; do i=$((i+1)); [ "$i" -lt 30 ] || { echo "il server campione non risponde" >&2; exit 1; }; sleep 1; done
report() { [ -s "docs/img/$1.png" ] && echo " $1: $(wc -c < "docs/img/$1.png") byte" || echo " $1: screenshot non scritto" >&2; }
shot() { # shot <name> <url> <size>
rm -f "docs/img/$1.png"
"$BROWSER" --headless=new --disable-gpu --no-first-run --no-default-browser-check --hide-scrollbars --disable-extensions "--user-data-dir=$WORK/edge-$1" "--window-size=$3" --virtual-time-budget=6000 "--screenshot=$(pwd)/docs/img/$1.png" "$2" >/dev/null 2>&1 || true
report "$1"
}
device_shot() { # device_shot <name> <url> <width> <height>
rm -f "docs/img/$1.png"
if command -v node >/dev/null 2>&1; then
node scripts/cdp-shot.mjs "$(native "$BROWSER")" "$2" "$(native "$(pwd)/docs/img/$1.png")" "$3" "$4" "$(native "$WORK/edge-$1")" || true
report "$1"
else
echo " $1: node non trovato, foto con --window-size (la pagina risulta larga circa 500 px)" >&2
shot "$1" "$2" "$3,$4"
fi
}
BASE="http://127.0.0.1:$PORT"
for page in dashboard basket posizioni mercato storico apprendimento log sistema impostazioni; do
shot "$page" "$BASE/?once=1#/$page" 1440,900
done
shot dashboard-chiaro "$BASE/?once=1&theme=light#/dashboard" 1440,900
shot login "$BASE/login" 1440,900
device_shot mobile "$BASE/?once=1#/dashboard" 420 860
@@ -1,114 +0,0 @@
using Encelado.Core.Market;
namespace Encelado.Alpaca;
/// <summary>Connection settings for every Alpaca endpoint the bot talks to.</summary>
public sealed class AlpacaOptions
{
public const string PaperTradingBase = "https://paper-api.alpaca.markets";
public const string LiveTradingBase = "https://api.alpaca.markets";
public const string MarketDataBase = "https://data.alpaca.markets";
public const string MarketDataStreamBase = "wss://stream.data.alpaca.markets";
public string KeyId { get; set; } = string.Empty;
public string SecretKey { get; set; } = string.Empty;
/// <summary>Paper trading is the default. Flipping this to <see langword="false"/> risks real money.</summary>
public bool Paper { get; set; } = true;
/// <summary>
/// Equity data feed: <c>iex</c> (free), <c>sip</c> (full tape, paid),
/// <c>delayed_sip</c>, or <c>test</c> (Alpaca's synthetic FAKEPACA stream).
/// </summary>
public string DataFeed { get; set; } = "iex";
/// <summary>Overrides the trading REST base URL. Leave empty to derive it from <see cref="Paper"/>.</summary>
public string TradingBaseUrlOverride { get; set; } = string.Empty;
/// <summary>Overrides the market-data REST base URL.</summary>
public string DataBaseUrlOverride { get; set; } = string.Empty;
/// <summary>Client-side throttle. Alpaca allows 200 requests/minute per account on the basic plan.</summary>
public int RequestsPerMinute { get; set; } = 180;
public TimeSpan HttpTimeout { get; set; } = TimeSpan.FromSeconds(15);
/// <summary>Number of retries for transient failures (429 / 5xx / socket errors).</summary>
public int MaxRetries { get; set; } = 4;
public string TradingBaseUrl =>
string.IsNullOrWhiteSpace(TradingBaseUrlOverride)
? (Paper ? PaperTradingBase : LiveTradingBase)
: TradingBaseUrlOverride.TrimEnd('/');
public string DataBaseUrl =>
string.IsNullOrWhiteSpace(DataBaseUrlOverride)
? MarketDataBase
: DataBaseUrlOverride.TrimEnd('/');
/// <summary>Order/position event stream. Lives on the trading host, not the data host.</summary>
public Uri TradeUpdatesStreamUri =>
new(TradingBaseUrl.Replace("https://", "wss://", StringComparison.Ordinal) + "/stream");
public Uri MarketDataStreamUri(AssetClass assetClass) => assetClass switch
{
AssetClass.Crypto => new Uri($"{MarketDataStreamBase}/v1beta3/crypto/us"),
_ => new Uri($"{MarketDataStreamBase}/v2/{DataFeed}"),
};
public AlpacaOptions Validate()
{
if (string.IsNullOrWhiteSpace(KeyId) || string.IsNullOrWhiteSpace(SecretKey))
{
throw new InvalidOperationException(
"Alpaca credentials are missing. Set APCA_API_KEY_ID and APCA_API_SECRET_KEY " +
"(or alpaca.keyId / alpaca.secretKey in the config file).");
}
// Credentials travel as HTTP headers. A stray non-ASCII character (a smart quote
// from a copy/paste, a BOM, a UTF-16 artefact from a pipe) would otherwise
// surface much later as an opaque "invalid char encoding" transport failure.
RequirePrintableAscii(KeyId, nameof(KeyId));
RequirePrintableAscii(SecretKey, nameof(SecretKey));
if (DataFeed is not ("iex" or "sip" or "delayed_sip" or "otc" or "test"))
{
throw new InvalidOperationException(
$"alpaca.dataFeed '{DataFeed}' is not one of: iex, sip, delayed_sip, otc, test.");
}
if (RequestsPerMinute is < 1 or > 1000)
{
throw new InvalidOperationException("alpaca.requestsPerMinute must be between 1 and 1000.");
}
return this;
}
private static void RequirePrintableAscii(string value, string field)
{
foreach (char c in value)
{
if (c is < ' ' or > '~')
{
throw new InvalidOperationException(
$"alpaca.{char.ToLowerInvariant(field[0])}{field[1..]} contains a character that is not " +
$"printable ASCII (U+{(int)c:X4}). Re-copy the key from the Alpaca dashboard — " +
"invisible characters are usually picked up by copy/paste.");
}
}
}
}
/// <summary>Raised when Alpaca answers with a non-success status or an unusable payload.</summary>
public sealed class AlpacaApiException(string message, int statusCode = 0, string? body = null)
: Exception(message)
{
public int StatusCode { get; } = statusCode;
public string? Body { get; } = body;
/// <summary>Transient conditions worth retrying.</summary>
public bool IsTransient => StatusCode is 429 or >= 500;
}
@@ -1,12 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<RootNamespace>Encelado.Alpaca</RootNamespace>
<AssemblyName>Encelado.Alpaca</AssemblyName>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\Encelado.Core\Encelado.Core.csproj" />
</ItemGroup>
</Project>
@@ -1,98 +0,0 @@
using System.Globalization;
using System.Text.Json;
namespace Encelado.Alpaca.Internal;
/// <summary>
/// Reading helpers for Alpaca's REST payloads. Alpaca encodes most numeric fields as
/// JSON <i>strings</i> (<c>"qty": "10"</c>), and omits or nulls fields liberally, so
/// every accessor tolerates both shapes and a missing property.
/// </summary>
public static class JsonRead
{
public static string? StringOrNull(this JsonElement e, string name) =>
e.TryGetProperty(name, out JsonElement v) && v.ValueKind == JsonValueKind.String
? v.GetString()
: null;
public static string StringOrEmpty(this JsonElement e, string name) =>
e.StringOrNull(name) ?? string.Empty;
public static double Double(this JsonElement e, string name, double fallback = 0)
{
if (!e.TryGetProperty(name, out JsonElement v))
{
return fallback;
}
return v.ValueKind switch
{
JsonValueKind.Number => v.GetDouble(),
JsonValueKind.String => double.TryParse(v.GetString(), NumberStyles.Float, CultureInfo.InvariantCulture, out double d)
? d
: fallback,
_ => fallback,
};
}
public static decimal Decimal(this JsonElement e, string name, decimal fallback = 0)
{
if (!e.TryGetProperty(name, out JsonElement v))
{
return fallback;
}
return v.ValueKind switch
{
JsonValueKind.Number => v.GetDecimal(),
JsonValueKind.String => decimal.TryParse(v.GetString(), NumberStyles.Float, CultureInfo.InvariantCulture, out decimal d)
? d
: fallback,
_ => fallback,
};
}
public static int Int32(this JsonElement e, string name, int fallback = 0)
{
if (!e.TryGetProperty(name, out JsonElement v))
{
return fallback;
}
return v.ValueKind switch
{
JsonValueKind.Number => v.TryGetInt32(out int i) ? i : (int)v.GetDouble(),
JsonValueKind.String => int.TryParse(v.GetString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out int i)
? i
: fallback,
_ => fallback,
};
}
public static bool Bool(this JsonElement e, string name, bool fallback = false)
{
if (!e.TryGetProperty(name, out JsonElement v))
{
return fallback;
}
return v.ValueKind switch
{
JsonValueKind.True => true,
JsonValueKind.False => false,
JsonValueKind.String => bool.TryParse(v.GetString(), out bool b) ? b : fallback,
_ => fallback,
};
}
public static DateTime Timestamp(this JsonElement e, string name) =>
e.TryGetProperty(name, out JsonElement v) && v.ValueKind == JsonValueKind.String
? Rfc3339.ParseUtc(v.GetString())
: DateTime.MinValue;
public static DateTime? TimestampOrNull(this JsonElement e, string name)
{
DateTime dt = e.Timestamp(name);
return dt == DateTime.MinValue ? null : dt;
}
}
@@ -1,121 +0,0 @@
using System.Globalization;
namespace Encelado.Alpaca.Internal;
/// <summary>
/// Hand-rolled RFC3339 parser for the shape Alpaca actually emits
/// (<c>2024-05-17T13:04:56.334262119Z</c>). It runs on every tick of the market-data
/// stream, so it avoids the general-purpose date parser and its culture lookups.
/// Falls back to <see cref="DateTime.TryParse(ReadOnlySpan{char}, IFormatProvider, DateTimeStyles, out DateTime)"/>
/// for anything unusual (offsets, missing fractions, non-UTC).
/// </summary>
public static class Rfc3339
{
/// <summary>Parses a UTC timestamp from UTF-8 bytes. Returns <see cref="DateTime.MinValue"/> on failure.</summary>
public static DateTime ParseUtc(ReadOnlySpan<byte> utf8)
{
// Fast path: exactly "YYYY-MM-DDTHH:MM:SS" plus optional ".fraction" and a "Z".
if (utf8.Length >= 20 && utf8[^1] == (byte)'Z' &&
utf8[4] == (byte)'-' && utf8[7] == (byte)'-' &&
(utf8[10] == (byte)'T' || utf8[10] == (byte)' ') &&
utf8[13] == (byte)':' && utf8[16] == (byte)':')
{
if (TryDigits(utf8, 0, 4, out int year) &&
TryDigits(utf8, 5, 2, out int month) &&
TryDigits(utf8, 8, 2, out int day) &&
TryDigits(utf8, 11, 2, out int hour) &&
TryDigits(utf8, 14, 2, out int minute) &&
TryDigits(utf8, 17, 2, out int second))
{
long fractionTicks = 0;
if (utf8.Length > 20 && utf8[19] == (byte)'.')
{
// Consume up to 7 fractional digits (100 ns resolution); ignore the rest.
int i = 20;
int digits = 0;
long value = 0;
while (i < utf8.Length - 1 && utf8[i] >= (byte)'0' && utf8[i] <= (byte)'9')
{
if (digits < 7)
{
value = (value * 10) + (utf8[i] - (byte)'0');
digits++;
}
i++;
}
while (digits < 7)
{
value *= 10;
digits++;
}
fractionTicks = value;
}
try
{
return new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc)
.AddTicks(fractionTicks);
}
catch (ArgumentOutOfRangeException)
{
return DateTime.MinValue;
}
}
}
return SlowParse(utf8);
}
public static DateTime ParseUtc(string? text)
{
if (string.IsNullOrEmpty(text))
{
return DateTime.MinValue;
}
return DateTime.TryParse(
text,
CultureInfo.InvariantCulture,
DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal,
out DateTime dt)
? DateTime.SpecifyKind(dt, DateTimeKind.Utc)
: DateTime.MinValue;
}
private static DateTime SlowParse(ReadOnlySpan<byte> utf8)
{
Span<char> chars = utf8.Length <= 64 ? stackalloc char[utf8.Length] : new char[utf8.Length];
for (int i = 0; i < utf8.Length; i++)
{
chars[i] = (char)utf8[i];
}
return DateTime.TryParse(
chars,
CultureInfo.InvariantCulture,
DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal,
out DateTime dt)
? DateTime.SpecifyKind(dt, DateTimeKind.Utc)
: DateTime.MinValue;
}
private static bool TryDigits(ReadOnlySpan<byte> utf8, int offset, int count, out int value)
{
value = 0;
for (int i = offset; i < offset + count; i++)
{
byte b = utf8[i];
if (b < (byte)'0' || b > (byte)'9')
{
return false;
}
value = (value * 10) + (b - (byte)'0');
}
return true;
}
}
@@ -1,197 +0,0 @@
using System.Globalization;
using System.Text;
using System.Text.Json;
using Encelado.Alpaca.Internal;
using Encelado.Core.Market;
namespace Encelado.Alpaca.Rest;
/// <summary>
/// Historical and latest-snapshot market data. Used to warm indicators up before the
/// live stream takes over, and by the replay/backtest mode.
/// </summary>
public sealed class AlpacaDataClient(AlpacaOptions options) : IDisposable
{
private readonly AlpacaHttp _http = new(options.Validate(), options.DataBaseUrl);
private readonly string _feed = options.DataFeed;
/// <summary>Alpaca caps a single bars page at 10 000 rows.</summary>
private const int PageLimit = 10_000;
public Task WarmupAsync(CancellationToken ct) =>
_http.WarmupAsync("v2/stocks/bars?symbols=SPY&timeframe=1Day&limit=1", ct);
/// <summary>
/// Fetches historical bars for one or more symbols in chronological order,
/// following pagination across the whole requested range.
/// <para>
/// <paramref name="maxBarsPerSymbol"/> keeps the <b>most recent</b> N bars, which is
/// what indicator warm-up needs — trimming while paging would keep the oldest ones
/// and leave the strategies primed with stale state.
/// </para>
/// </summary>
public async Task<Dictionary<string, List<Bar>>> GetBarsAsync(
IReadOnlyList<string> symbols,
TimeFrame timeFrame,
DateTime startUtc,
DateTime? endUtc,
AssetClass assetClass,
int maxBarsPerSymbol,
CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(symbols);
Dictionary<string, List<Bar>> result = new(StringComparer.OrdinalIgnoreCase);
if (symbols.Count == 0 || maxBarsPerSymbol <= 0)
{
return result;
}
string basePath = assetClass == AssetClass.Crypto
? "v1beta3/crypto/us/bars"
: "v2/stocks/bars";
string? pageToken = null;
int guard = 0;
do
{
StringBuilder path = new(256);
path.Append(basePath)
.Append("?symbols=").Append(Uri.EscapeDataString(string.Join(',', symbols)))
.Append("&timeframe=").Append(timeFrame.ToAlpaca())
.Append("&limit=").Append(PageLimit)
.Append("&sort=asc")
.Append("&start=").Append(Uri.EscapeDataString(FormatInstant(startUtc)));
if (endUtc is { } end)
{
path.Append("&end=").Append(Uri.EscapeDataString(FormatInstant(end)));
}
if (assetClass != AssetClass.Crypto)
{
path.Append("&adjustment=raw&feed=").Append(_feed == "test" ? "iex" : _feed);
}
if (pageToken is not null)
{
path.Append("&page_token=").Append(Uri.EscapeDataString(pageToken));
}
using JsonDocument doc = await _http.GetAsync(path.ToString(), ct).ConfigureAwait(false);
JsonElement root = doc.RootElement;
if (root.TryGetProperty("bars", out JsonElement barsBySymbol) &&
barsBySymbol.ValueKind == JsonValueKind.Object)
{
foreach (JsonProperty symbolBars in barsBySymbol.EnumerateObject())
{
if (!result.TryGetValue(symbolBars.Name, out List<Bar>? list))
{
list = new List<Bar>(Math.Min(maxBarsPerSymbol, 1024));
result[symbolBars.Name] = list;
}
foreach (JsonElement b in symbolBars.Value.EnumerateArray())
{
list.Add(ParseBar(b));
}
}
}
pageToken = root.TryGetProperty("next_page_token", out JsonElement token) &&
token.ValueKind == JsonValueKind.String
? token.GetString()
: null;
}
while (pageToken is not null && ++guard < 500);
// Keep only the newest slice, preserving chronological order.
foreach (string key in result.Keys)
{
List<Bar> bars = result[key];
if (bars.Count > maxBarsPerSymbol)
{
result[key] = bars.GetRange(bars.Count - maxBarsPerSymbol, maxBarsPerSymbol);
}
}
return result;
}
public async Task<Dictionary<string, Quote>> GetLatestQuotesAsync(
IReadOnlyList<string> symbols,
AssetClass assetClass,
CancellationToken ct)
{
Dictionary<string, Quote> result = new(StringComparer.OrdinalIgnoreCase);
if (symbols.Count == 0)
{
return result;
}
string path = assetClass == AssetClass.Crypto
? $"v1beta3/crypto/us/latest/quotes?symbols={Uri.EscapeDataString(string.Join(',', symbols))}"
: $"v2/stocks/quotes/latest?symbols={Uri.EscapeDataString(string.Join(',', symbols))}&feed={(_feed == "test" ? "iex" : _feed)}";
using JsonDocument doc = await _http.GetAsync(path, ct).ConfigureAwait(false);
if (doc.RootElement.TryGetProperty("quotes", out JsonElement quotes) &&
quotes.ValueKind == JsonValueKind.Object)
{
foreach (JsonProperty p in quotes.EnumerateObject())
{
result[p.Name] = new Quote(
p.Value.Timestamp("t"),
p.Value.Double("bp"),
p.Value.Double("bs"),
p.Value.Double("ap"),
p.Value.Double("as"));
}
}
return result;
}
public async Task<Dictionary<string, Tick>> GetLatestTradesAsync(
IReadOnlyList<string> symbols,
AssetClass assetClass,
CancellationToken ct)
{
Dictionary<string, Tick> result = new(StringComparer.OrdinalIgnoreCase);
if (symbols.Count == 0)
{
return result;
}
string path = assetClass == AssetClass.Crypto
? $"v1beta3/crypto/us/latest/trades?symbols={Uri.EscapeDataString(string.Join(',', symbols))}"
: $"v2/stocks/trades/latest?symbols={Uri.EscapeDataString(string.Join(',', symbols))}&feed={(_feed == "test" ? "iex" : _feed)}";
using JsonDocument doc = await _http.GetAsync(path, ct).ConfigureAwait(false);
if (doc.RootElement.TryGetProperty("trades", out JsonElement trades) &&
trades.ValueKind == JsonValueKind.Object)
{
foreach (JsonProperty p in trades.EnumerateObject())
{
result[p.Name] = new Tick(p.Value.Timestamp("t"), p.Value.Double("p"), p.Value.Double("s"));
}
}
return result;
}
internal static Bar ParseBar(JsonElement e) => new(
e.Timestamp("t"),
e.Double("o"),
e.Double("h"),
e.Double("l"),
e.Double("c"),
e.Double("v"),
e.Double("vw"),
e.Int32("n"));
private static string FormatInstant(DateTime utc) =>
DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
public void Dispose() => _http.Dispose();
}
@@ -1,225 +0,0 @@
using System.Diagnostics;
using System.Net;
using System.Net.Http.Headers;
using System.Text.Json;
namespace Encelado.Alpaca.Rest;
/// <summary>
/// Shared HTTP transport for the Alpaca REST APIs: one pooled, pre-warmed HTTP/2
/// connection per host, a client-side rate limiter that keeps us under Alpaca's
/// 200 req/min, and bounded retries for transient failures.
/// </summary>
public sealed class AlpacaHttp : IDisposable
{
private readonly HttpClient _http;
private readonly MinuteRateLimiter _limiter;
private readonly int _maxRetries;
public AlpacaHttp(AlpacaOptions options, string baseUrl)
{
ArgumentNullException.ThrowIfNull(options);
SocketsHttpHandler handler = new()
{
// Long-lived pooled connections: TLS handshakes are the single biggest
// source of order latency, so we never want to pay one on the hot path.
PooledConnectionLifetime = TimeSpan.FromMinutes(10),
PooledConnectionIdleTimeout = TimeSpan.FromMinutes(5),
MaxConnectionsPerServer = 16,
EnableMultipleHttp2Connections = true,
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
ConnectTimeout = TimeSpan.FromSeconds(10),
KeepAlivePingDelay = TimeSpan.FromSeconds(30),
KeepAlivePingTimeout = TimeSpan.FromSeconds(10),
KeepAlivePingPolicy = HttpKeepAlivePingPolicy.WithActiveRequests,
};
_http = new HttpClient(handler, disposeHandler: true)
{
BaseAddress = new Uri(baseUrl.TrimEnd('/') + "/"),
Timeout = options.HttpTimeout,
DefaultRequestVersion = HttpVersion.Version20,
DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrLower,
};
_http.DefaultRequestHeaders.Add("APCA-API-KEY-ID", options.KeyId);
_http.DefaultRequestHeaders.Add("APCA-API-SECRET-KEY", options.SecretKey);
_http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_http.DefaultRequestHeaders.UserAgent.ParseAdd("Encelado/2.0");
_limiter = new MinuteRateLimiter(options.RequestsPerMinute);
_maxRetries = Math.Max(0, options.MaxRetries);
}
/// <summary>
/// Opens the TLS connection ahead of the first real request so the first order
/// does not pay for the handshake.
/// </summary>
public async Task WarmupAsync(string probePath, CancellationToken ct)
{
try
{
using JsonDocument _ = await GetAsync(probePath, ct).ConfigureAwait(false);
}
catch (AlpacaApiException)
{
// A 4xx still means the socket is up, which is all warm-up needs.
}
}
public Task<JsonDocument> GetAsync(string path, CancellationToken ct) =>
SendAsync(HttpMethod.Get, path, null, ct);
public Task<JsonDocument> PostAsync(string path, ReadOnlyMemory<byte> json, CancellationToken ct) =>
SendAsync(HttpMethod.Post, path, json, ct);
public Task<JsonDocument> PatchAsync(string path, ReadOnlyMemory<byte> json, CancellationToken ct) =>
SendAsync(HttpMethod.Patch, path, json, ct);
public Task<JsonDocument> DeleteAsync(string path, CancellationToken ct) =>
SendAsync(HttpMethod.Delete, path, null, ct);
/// <summary>Like <see cref="GetAsync"/> but maps HTTP 404 to <see langword="null"/>.</summary>
public async Task<JsonDocument?> GetOrNullAsync(string path, CancellationToken ct)
{
try
{
return await GetAsync(path, ct).ConfigureAwait(false);
}
catch (AlpacaApiException ex) when (ex.StatusCode == 404)
{
return null;
}
}
private async Task<JsonDocument> SendAsync(
HttpMethod method,
string path,
ReadOnlyMemory<byte>? body,
CancellationToken ct)
{
AlpacaApiException? last = null;
for (int attempt = 0; attempt <= _maxRetries; attempt++)
{
await _limiter.WaitAsync(ct).ConfigureAwait(false);
using HttpRequestMessage request = new(method, path);
if (body is { } payload)
{
request.Content = new ReadOnlyMemoryContent(payload);
request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
HttpResponseMessage? response = null;
try
{
response = await _http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct)
.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
await using Stream stream = await response.Content.ReadAsStreamAsync(ct).ConfigureAwait(false);
if (response.StatusCode == HttpStatusCode.NoContent || response.Content.Headers.ContentLength == 0)
{
return JsonDocument.Parse("{}"u8.ToArray());
}
return await JsonDocument.ParseAsync(stream, default, ct).ConfigureAwait(false);
}
string errorBody = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
last = new AlpacaApiException(
$"{method} {path} -> {(int)response.StatusCode} {response.ReasonPhrase}: {Truncate(errorBody)}",
(int)response.StatusCode,
errorBody);
if (!last.IsTransient || attempt == _maxRetries)
{
throw last;
}
await BackoffAsync(attempt, response.Headers.RetryAfter, ct).ConfigureAwait(false);
}
catch (HttpRequestException ex) when (attempt < _maxRetries)
{
last = new AlpacaApiException($"{method} {path} -> transport failure: {ex.Message}");
await BackoffAsync(attempt, null, ct).ConfigureAwait(false);
}
catch (TaskCanceledException) when (!ct.IsCancellationRequested && attempt < _maxRetries)
{
last = new AlpacaApiException($"{method} {path} -> timed out after {_http.Timeout.TotalSeconds:F0}s");
await BackoffAsync(attempt, null, ct).ConfigureAwait(false);
}
finally
{
response?.Dispose();
}
}
throw last ?? new AlpacaApiException($"{method} {path} failed without a response.");
}
private static async Task BackoffAsync(int attempt, RetryConditionHeaderValue? retryAfter, CancellationToken ct)
{
TimeSpan delay;
if (retryAfter?.Delta is { } delta && delta > TimeSpan.Zero)
{
delay = delta;
}
else
{
double baseMs = 200 * Math.Pow(2, attempt);
delay = TimeSpan.FromMilliseconds(baseMs + Random.Shared.Next(0, 150));
}
await Task.Delay(delay > TimeSpan.FromSeconds(30) ? TimeSpan.FromSeconds(30) : delay, ct)
.ConfigureAwait(false);
}
private static string Truncate(string s) => s.Length <= 400 ? s : s[..400] + "…";
public void Dispose() => _http.Dispose();
}
/// <summary>
/// Sliding-window limiter: remembers when each of the last N requests went out and
/// blocks until the oldest falls out of the 60 second window.
/// </summary>
internal sealed class MinuteRateLimiter(int permitsPerMinute)
{
private static readonly long WindowTicks = Stopwatch.Frequency * 60;
private readonly long[] _sentAt = new long[Math.Max(1, permitsPerMinute)];
private readonly SemaphoreSlim _gate = new(1, 1);
private int _index;
public async ValueTask WaitAsync(CancellationToken ct)
{
await _gate.WaitAsync(ct).ConfigureAwait(false);
try
{
long now = Stopwatch.GetTimestamp();
long oldest = _sentAt[_index];
if (oldest != 0)
{
long elapsed = now - oldest;
if (elapsed < WindowTicks)
{
double waitSeconds = (WindowTicks - elapsed) / (double)Stopwatch.Frequency;
await Task.Delay(TimeSpan.FromSeconds(waitSeconds), ct).ConfigureAwait(false);
now = Stopwatch.GetTimestamp();
}
}
_sentAt[_index] = now;
_index = _index + 1 == _sentAt.Length ? 0 : _index + 1;
}
finally
{
_gate.Release();
}
}
}
@@ -1,350 +0,0 @@
using System.Text.Json;
using Encelado.Alpaca.Internal;
using Encelado.Core.Market;
namespace Encelado.Alpaca.Rest;
public enum OrderStatus : byte
{
Unknown = 0,
New,
PendingNew,
Accepted,
AcceptedForBidding,
PartiallyFilled,
Filled,
DoneForDay,
Canceled,
PendingCancel,
Expired,
Replaced,
PendingReplace,
Rejected,
Suspended,
Stopped,
Calculated,
Held,
}
public static class OrderStatusParser
{
public static OrderStatus Parse(string? s) => s switch
{
"new" => OrderStatus.New,
"pending_new" => OrderStatus.PendingNew,
"accepted" => OrderStatus.Accepted,
"accepted_for_bidding" => OrderStatus.AcceptedForBidding,
"partially_filled" => OrderStatus.PartiallyFilled,
"filled" => OrderStatus.Filled,
"done_for_day" => OrderStatus.DoneForDay,
"canceled" => OrderStatus.Canceled,
"pending_cancel" => OrderStatus.PendingCancel,
"expired" => OrderStatus.Expired,
"replaced" => OrderStatus.Replaced,
"pending_replace" => OrderStatus.PendingReplace,
"rejected" => OrderStatus.Rejected,
"suspended" => OrderStatus.Suspended,
"stopped" => OrderStatus.Stopped,
"calculated" => OrderStatus.Calculated,
"held" => OrderStatus.Held,
_ => OrderStatus.Unknown,
};
/// <summary>True once the order can no longer change state.</summary>
public static bool IsTerminal(this OrderStatus s) =>
s is OrderStatus.Filled or OrderStatus.Canceled or OrderStatus.Expired
or OrderStatus.Rejected or OrderStatus.Replaced or OrderStatus.DoneForDay;
public static bool IsWorking(this OrderStatus s) =>
s is OrderStatus.New or OrderStatus.PendingNew or OrderStatus.Accepted
or OrderStatus.AcceptedForBidding or OrderStatus.PartiallyFilled
or OrderStatus.PendingCancel or OrderStatus.PendingReplace or OrderStatus.Held;
}
public sealed record AlpacaAccount(
string Id,
string AccountNumber,
string Status,
string Currency,
decimal Cash,
decimal Equity,
decimal LastEquity,
decimal BuyingPower,
decimal DaytradingBuyingPower,
decimal PortfolioValue,
decimal Multiplier,
int DaytradeCount,
bool PatternDayTrader,
bool TradingBlocked,
bool AccountBlocked,
bool TransfersBlocked,
bool TradeSuspendedByUser,
bool ShortingEnabled)
{
/// <summary>True when the broker will refuse new orders for any reason.</summary>
public bool CanTrade => !TradingBlocked && !AccountBlocked && !TradeSuspendedByUser &&
string.Equals(Status, "ACTIVE", StringComparison.OrdinalIgnoreCase);
public static AlpacaAccount FromJson(JsonElement e) => new(
e.StringOrEmpty("id"),
e.StringOrEmpty("account_number"),
e.StringOrEmpty("status"),
e.StringOrEmpty("currency"),
e.Decimal("cash"),
e.Decimal("equity"),
e.Decimal("last_equity"),
e.Decimal("buying_power"),
e.Decimal("daytrading_buying_power"),
e.Decimal("portfolio_value"),
e.Decimal("multiplier", 1),
e.Int32("daytrade_count"),
e.Bool("pattern_day_trader"),
e.Bool("trading_blocked"),
e.Bool("account_blocked"),
e.Bool("transfers_blocked"),
e.Bool("trade_suspended_by_user"),
e.Bool("shorting_enabled"));
}
public sealed record AlpacaPosition(
string Symbol,
string AssetClass,
double Quantity,
double AverageEntryPrice,
double CurrentPrice,
double MarketValue,
double UnrealizedPnl,
double UnrealizedPnlPct)
{
public static AlpacaPosition FromJson(JsonElement e)
{
double qty = e.Double("qty");
// Alpaca reports short positions with a negative qty already, but be explicit.
if (string.Equals(e.StringOrNull("side"), "short", StringComparison.OrdinalIgnoreCase) && qty > 0)
{
qty = -qty;
}
return new AlpacaPosition(
e.StringOrEmpty("symbol"),
e.StringOrEmpty("asset_class"),
qty,
e.Double("avg_entry_price"),
e.Double("current_price"),
e.Double("market_value"),
e.Double("unrealized_pl"),
e.Double("unrealized_plpc"));
}
}
public sealed record AlpacaOrder(
string Id,
string ClientOrderId,
string Symbol,
Side Side,
string Type,
string OrderClass,
OrderStatus Status,
double Quantity,
double FilledQuantity,
double FilledAveragePrice,
double LimitPrice,
double StopPrice,
DateTime SubmittedAtUtc,
DateTime? FilledAtUtc,
IReadOnlyList<AlpacaOrder> Legs)
{
private static readonly AlpacaOrder[] NoLegs = [];
public bool IsWorking => Status.IsWorking();
public static AlpacaOrder FromJson(JsonElement e)
{
AlpacaOrder[] legs = NoLegs;
if (e.TryGetProperty("legs", out JsonElement legsElement) && legsElement.ValueKind == JsonValueKind.Array)
{
int n = legsElement.GetArrayLength();
if (n > 0)
{
legs = new AlpacaOrder[n];
int i = 0;
foreach (JsonElement leg in legsElement.EnumerateArray())
{
legs[i++] = FromJson(leg);
}
}
}
return new AlpacaOrder(
e.StringOrEmpty("id"),
e.StringOrEmpty("client_order_id"),
e.StringOrEmpty("symbol"),
string.Equals(e.StringOrNull("side"), "sell", StringComparison.OrdinalIgnoreCase) ? Side.Sell : Side.Buy,
e.StringOrEmpty("type"),
e.StringOrEmpty("order_class"),
OrderStatusParser.Parse(e.StringOrNull("status")),
e.Double("qty"),
e.Double("filled_qty"),
e.Double("filled_avg_price"),
e.Double("limit_price", double.NaN),
e.Double("stop_price", double.NaN),
e.Timestamp("submitted_at"),
e.TimestampOrNull("filled_at"),
legs);
}
}
public sealed record AlpacaClock(
DateTime TimestampUtc,
bool IsOpen,
DateTime NextOpenUtc,
DateTime NextCloseUtc)
{
public static AlpacaClock FromJson(JsonElement e) => new(
e.Timestamp("timestamp"),
e.Bool("is_open"),
e.Timestamp("next_open"),
e.Timestamp("next_close"));
}
public sealed record AlpacaAsset(
string Symbol,
string Name,
string Exchange,
string Class,
string Status,
bool Tradable,
bool Marginable,
bool Shortable,
bool EasyToBorrow,
bool Fractionable,
double MinOrderSize,
double MinTradeIncrement,
double PriceIncrement)
{
public bool IsActive => Tradable && string.Equals(Status, "active", StringComparison.OrdinalIgnoreCase);
public static AlpacaAsset FromJson(JsonElement e) => new(
e.StringOrEmpty("symbol"),
e.StringOrEmpty("name"),
e.StringOrEmpty("exchange"),
e.StringOrEmpty("class"),
e.StringOrEmpty("status"),
e.Bool("tradable"),
e.Bool("marginable"),
e.Bool("shortable"),
e.Bool("easy_to_borrow"),
e.Bool("fractionable"),
e.Double("min_order_size"),
e.Double("min_trade_increment"),
e.Double("price_increment"));
}
/// <summary>
/// Account equity over time, straight from Alpaca. <see cref="BaseValue"/> is the
/// equity at the start of the requested window, so lifetime P&amp;L is
/// <c>Equity[^1] - BaseValue</c> — with the usual caveat that deposits and withdrawals
/// move equity without being profit.
/// </summary>
public sealed record AlpacaPortfolioHistory(
IReadOnlyList<long> TimestampsUnix,
IReadOnlyList<double> Equity,
IReadOnlyList<double> ProfitLoss,
double BaseValue,
string Timeframe)
{
public static readonly AlpacaPortfolioHistory Empty =
new([], [], [], 0, string.Empty);
public bool HasData => Equity.Count > 0;
public double LastEquity => Equity.Count > 0 ? Equity[^1] : 0;
/// <summary>Change over the whole window in absolute terms.</summary>
public double TotalProfitLoss => HasData && BaseValue > 0 ? LastEquity - BaseValue : 0;
public double TotalProfitLossPct => BaseValue > 0 ? TotalProfitLoss / BaseValue : 0;
public static AlpacaPortfolioHistory FromJson(JsonElement e)
{
return new AlpacaPortfolioHistory(
ReadLongs(e, "timestamp"),
ReadDoubles(e, "equity"),
ReadDoubles(e, "profit_loss"),
e.Double("base_value"),
e.StringOrEmpty("timeframe"));
static double[] ReadDoubles(JsonElement root, string name)
{
if (!root.TryGetProperty(name, out JsonElement array) || array.ValueKind != JsonValueKind.Array)
{
return [];
}
double[] values = new double[array.GetArrayLength()];
int i = 0;
foreach (JsonElement item in array.EnumerateArray())
{
values[i++] = item.ValueKind == JsonValueKind.Number ? item.GetDouble() : 0;
}
return values;
}
static long[] ReadLongs(JsonElement root, string name)
{
if (!root.TryGetProperty(name, out JsonElement array) || array.ValueKind != JsonValueKind.Array)
{
return [];
}
long[] values = new long[array.GetArrayLength()];
int i = 0;
foreach (JsonElement item in array.EnumerateArray())
{
values[i++] = item.ValueKind == JsonValueKind.Number ? item.GetInt64() : 0;
}
return values;
}
}
}
/// <summary>An order about to be submitted. Built by the execution router, never by strategies.</summary>
public sealed record NewOrder
{
public required string Symbol { get; init; }
public required Side Side { get; init; }
public required double Quantity { get; init; }
public OrderType Type { get; init; } = OrderType.Market;
public TimeInForce TimeInForce { get; init; } = TimeInForce.Day;
public double LimitPrice { get; init; } = double.NaN;
public double StopPrice { get; init; } = double.NaN;
/// <summary>Idempotency key. Alpaca rejects duplicates, which is exactly what we want on a retry.</summary>
public string? ClientOrderId { get; init; }
public bool ExtendedHours { get; init; }
/// <summary>Attached protective stop. Turns the order into a bracket/OTO order.</summary>
public double TakeProfitLimitPrice { get; init; } = double.NaN;
public double StopLossStopPrice { get; init; } = double.NaN;
public double StopLossLimitPrice { get; init; } = double.NaN;
public bool HasBracket => !double.IsNaN(TakeProfitLimitPrice) || !double.IsNaN(StopLossStopPrice);
/// <summary>Alpaca's <c>order_class</c> implied by the attached legs.</summary>
public string OrderClass =>
!double.IsNaN(TakeProfitLimitPrice) && !double.IsNaN(StopLossStopPrice) ? "bracket"
: !double.IsNaN(TakeProfitLimitPrice) || !double.IsNaN(StopLossStopPrice) ? "oto"
: "simple";
}
@@ -1,307 +0,0 @@
using System.Buffers;
using System.Globalization;
using System.Text.Json;
using Encelado.Core.Market;
namespace Encelado.Alpaca.Rest;
/// <summary>
/// Typed wrapper over Alpaca's trading REST API (<c>/v2/account</c>, <c>/v2/orders</c>,
/// <c>/v2/positions</c>, …). Request bodies are written straight to UTF-8 with
/// <see cref="Utf8JsonWriter"/> — no serializer, no reflection, no per-order allocation
/// beyond a pooled buffer.
/// </summary>
public sealed class AlpacaTradingClient(AlpacaOptions options) : IDisposable
{
private readonly AlpacaHttp _http = new(options.Validate(), options.TradingBaseUrl);
public string BaseUrl { get; } = options.TradingBaseUrl;
public bool IsPaper { get; } = options.Paper;
/// <summary>Opens the TLS/HTTP2 connection before the session starts.</summary>
public Task WarmupAsync(CancellationToken ct) => _http.WarmupAsync("v2/clock", ct);
public async Task<AlpacaAccount> GetAccountAsync(CancellationToken ct)
{
using JsonDocument doc = await _http.GetAsync("v2/account", ct).ConfigureAwait(false);
return AlpacaAccount.FromJson(doc.RootElement);
}
public async Task<AlpacaClock> GetClockAsync(CancellationToken ct)
{
using JsonDocument doc = await _http.GetAsync("v2/clock", ct).ConfigureAwait(false);
return AlpacaClock.FromJson(doc.RootElement);
}
/// <summary>
/// Equity curve for the account. <paramref name="period"/> uses Alpaca's notation
/// (<c>1D</c>, <c>1M</c>, <c>1A</c>, <c>all</c>) and <paramref name="timeframe"/> the
/// bucket size (<c>1Min</c>, <c>15Min</c>, <c>1H</c>, <c>1D</c>).
/// </summary>
public async Task<AlpacaPortfolioHistory> GetPortfolioHistoryAsync(
string period,
string timeframe,
CancellationToken ct)
{
string path = $"v2/account/portfolio/history?period={Uri.EscapeDataString(period)}" +
$"&timeframe={Uri.EscapeDataString(timeframe)}&intraday_reporting=continuous";
try
{
using JsonDocument doc = await _http.GetAsync(path, ct).ConfigureAwait(false);
return AlpacaPortfolioHistory.FromJson(doc.RootElement);
}
catch (AlpacaApiException)
{
// History is a nice-to-have for the dashboard, never a reason to stop trading.
return AlpacaPortfolioHistory.Empty;
}
}
public async Task<AlpacaAsset?> GetAssetAsync(string symbol, CancellationToken ct)
{
using JsonDocument? doc = await _http.GetOrNullAsync($"v2/assets/{Uri.EscapeDataString(symbol)}", ct)
.ConfigureAwait(false);
return doc is null ? null : AlpacaAsset.FromJson(doc.RootElement);
}
public async Task<List<AlpacaPosition>> ListPositionsAsync(CancellationToken ct)
{
using JsonDocument doc = await _http.GetAsync("v2/positions", ct).ConfigureAwait(false);
List<AlpacaPosition> positions = [];
if (doc.RootElement.ValueKind == JsonValueKind.Array)
{
foreach (JsonElement e in doc.RootElement.EnumerateArray())
{
positions.Add(AlpacaPosition.FromJson(e));
}
}
return positions;
}
public async Task<AlpacaPosition?> GetPositionAsync(string symbol, CancellationToken ct)
{
using JsonDocument? doc = await _http.GetOrNullAsync($"v2/positions/{Uri.EscapeDataString(symbol)}", ct)
.ConfigureAwait(false);
return doc is null ? null : AlpacaPosition.FromJson(doc.RootElement);
}
/// <summary>Liquidates a position at market. Alpaca cancels the open legs for us.</summary>
public async Task<AlpacaOrder?> ClosePositionAsync(string symbol, double? quantity, CancellationToken ct)
{
string path = $"v2/positions/{Uri.EscapeDataString(symbol)}";
if (quantity is > 0)
{
path += $"?qty={FormatQuantity(quantity.Value)}";
}
try
{
using JsonDocument doc = await _http.DeleteAsync(path, ct).ConfigureAwait(false);
return doc.RootElement.ValueKind == JsonValueKind.Object && doc.RootElement.TryGetProperty("id", out _)
? AlpacaOrder.FromJson(doc.RootElement)
: null;
}
catch (AlpacaApiException ex) when (ex.StatusCode == 404)
{
// Already flat: treat as success so the caller's exit path is idempotent.
return null;
}
}
public async Task CloseAllPositionsAsync(bool cancelOrders, CancellationToken ct)
{
using JsonDocument _ = await _http
.DeleteAsync($"v2/positions?cancel_orders={(cancelOrders ? "true" : "false")}", ct)
.ConfigureAwait(false);
}
public async Task<List<AlpacaOrder>> ListOrdersAsync(
string status,
int limit,
string? symbols,
CancellationToken ct)
{
string path = $"v2/orders?status={status}&limit={limit}&nested=true";
if (!string.IsNullOrWhiteSpace(symbols))
{
path += $"&symbols={Uri.EscapeDataString(symbols)}";
}
using JsonDocument doc = await _http.GetAsync(path, ct).ConfigureAwait(false);
List<AlpacaOrder> orders = [];
if (doc.RootElement.ValueKind == JsonValueKind.Array)
{
foreach (JsonElement e in doc.RootElement.EnumerateArray())
{
orders.Add(AlpacaOrder.FromJson(e));
}
}
return orders;
}
public Task<List<AlpacaOrder>> ListOpenOrdersAsync(CancellationToken ct) =>
ListOrdersAsync("open", 500, null, ct);
public async Task<AlpacaOrder> SubmitOrderAsync(NewOrder order, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(order);
byte[] body = WriteOrderJson(order);
using JsonDocument doc = await _http.PostAsync("v2/orders", body, ct).ConfigureAwait(false);
return AlpacaOrder.FromJson(doc.RootElement);
}
/// <summary>Moves an open order's stop/limit — used to trail protective stops.</summary>
public async Task<AlpacaOrder> ReplaceOrderAsync(
string orderId,
double? quantity,
double? limitPrice,
double? stopPrice,
string? clientOrderId,
CancellationToken ct)
{
ArrayBufferWriter<byte> buffer = new(192);
using (Utf8JsonWriter w = new(buffer))
{
w.WriteStartObject();
if (quantity is > 0)
{
w.WriteString("qty", FormatQuantity(quantity.Value));
}
if (limitPrice is > 0)
{
w.WriteString("limit_price", FormatPrice(limitPrice.Value));
}
if (stopPrice is > 0)
{
w.WriteString("stop_price", FormatPrice(stopPrice.Value));
}
if (!string.IsNullOrEmpty(clientOrderId))
{
w.WriteString("client_order_id", clientOrderId);
}
w.WriteEndObject();
}
using JsonDocument doc = await _http
.PatchAsync($"v2/orders/{Uri.EscapeDataString(orderId)}", buffer.WrittenMemory, ct)
.ConfigureAwait(false);
return AlpacaOrder.FromJson(doc.RootElement);
}
public async Task<bool> CancelOrderAsync(string orderId, CancellationToken ct)
{
try
{
using JsonDocument _ = await _http
.DeleteAsync($"v2/orders/{Uri.EscapeDataString(orderId)}", ct)
.ConfigureAwait(false);
return true;
}
catch (AlpacaApiException ex) when (ex.StatusCode is 404 or 422)
{
// 404 = gone, 422 = already in a terminal state. Both mean "not working any more".
return false;
}
}
public async Task CancelAllOrdersAsync(CancellationToken ct)
{
using JsonDocument _ = await _http.DeleteAsync("v2/orders", ct).ConfigureAwait(false);
}
/// <summary>Serialises an order to Alpaca's wire format. Public so it can be asserted on in tests.</summary>
public static byte[] WriteOrderJson(NewOrder order)
{
ArrayBufferWriter<byte> buffer = new(384);
using (Utf8JsonWriter w = new(buffer))
{
w.WriteStartObject();
w.WriteString("symbol", order.Symbol);
w.WriteString("qty", FormatQuantity(order.Quantity));
w.WriteString("side", order.Side.ToAlpaca());
w.WriteString("type", order.Type.ToAlpaca());
w.WriteString("time_in_force", order.TimeInForce.ToAlpaca());
if (order.Type is OrderType.Limit or OrderType.StopLimit && !double.IsNaN(order.LimitPrice))
{
w.WriteString("limit_price", FormatPrice(order.LimitPrice));
}
if (order.Type is OrderType.Stop or OrderType.StopLimit && !double.IsNaN(order.StopPrice))
{
w.WriteString("stop_price", FormatPrice(order.StopPrice));
}
if (!string.IsNullOrEmpty(order.ClientOrderId))
{
w.WriteString("client_order_id", order.ClientOrderId);
}
if (order.ExtendedHours)
{
w.WriteBoolean("extended_hours", true);
}
if (order.HasBracket)
{
w.WriteString("order_class", order.OrderClass);
if (!double.IsNaN(order.TakeProfitLimitPrice))
{
w.WriteStartObject("take_profit");
w.WriteString("limit_price", FormatPrice(order.TakeProfitLimitPrice));
w.WriteEndObject();
}
if (!double.IsNaN(order.StopLossStopPrice))
{
w.WriteStartObject("stop_loss");
w.WriteString("stop_price", FormatPrice(order.StopLossStopPrice));
if (!double.IsNaN(order.StopLossLimitPrice))
{
w.WriteString("limit_price", FormatPrice(order.StopLossLimitPrice));
}
w.WriteEndObject();
}
}
w.WriteEndObject();
}
return buffer.WrittenSpan.ToArray();
}
/// <summary>
/// Alpaca rejects prices that are not a valid sub-penny increment: two decimals at
/// or above $1, four decimals below it.
/// </summary>
public static string FormatPrice(double price)
{
double rounded = price >= 1.0
? Math.Round(price, 2, MidpointRounding.AwayFromZero)
: Math.Round(price, 4, MidpointRounding.AwayFromZero);
return rounded.ToString(price >= 1.0 ? "0.##" : "0.####", CultureInfo.InvariantCulture);
}
/// <summary>Whole shares stay integral; fractional sizes get at most 9 decimals.</summary>
public static string FormatQuantity(double quantity)
{
double abs = Math.Abs(quantity);
return abs == Math.Floor(abs)
? abs.ToString("0", CultureInfo.InvariantCulture)
: Math.Round(abs, 9, MidpointRounding.ToZero).ToString("0.#########", CultureInfo.InvariantCulture);
}
public void Dispose() => _http.Dispose();
}
@@ -1,486 +0,0 @@
using System.Buffers;
using System.Globalization;
using System.Text.Json;
using Encelado.Alpaca.Internal;
using Encelado.Core.Market;
namespace Encelado.Alpaca.Streaming;
/// <summary>Which side crossed the spread on a print. Unknown when the feed omits it.</summary>
public enum Aggressor : byte
{
Unknown = 0,
Buy = 1,
Sell = 2,
}
public delegate void TickHandler(int symbolId, string symbol, in Tick tick, Aggressor aggressor);
public delegate void QuoteHandler(int symbolId, string symbol, in Quote quote);
public delegate void BarHandler(int symbolId, string symbol, in Bar bar);
/// <summary>
/// Alpaca's real-time market data socket. Frames are decoded straight out of the
/// receive buffer with <see cref="Utf8JsonReader"/> and symbols are resolved through
/// a <see cref="SymbolTable"/>, so a live tape produces no garbage per tick.
/// </summary>
public sealed class MarketDataStream : WebSocketChannel
{
private enum MsgKind : byte
{
Unknown = 0,
Trade,
Quote,
Bar,
UpdatedBar,
DailyBar,
Status,
Success,
Error,
Subscription,
}
private readonly byte[] _authPayload;
private readonly byte[] _subscribePayload;
private readonly SymbolTable _symbols;
private CancellationToken _channelToken;
public MarketDataStream(
AlpacaOptions options,
IReadOnlyList<string> symbols,
AssetClass assetClass,
bool subscribeTrades = true,
bool subscribeQuotes = true,
bool subscribeBars = true)
: base(options.MarketDataStreamUri(assetClass), $"data:{(assetClass == AssetClass.Crypto ? "crypto" : options.DataFeed)}")
{
ArgumentNullException.ThrowIfNull(options);
ArgumentNullException.ThrowIfNull(symbols);
_symbols = new SymbolTable(symbols);
AssetClass = assetClass;
_authPayload = BuildAuth(options.KeyId, options.SecretKey);
_subscribePayload = BuildSubscribe(symbols, subscribeTrades, subscribeQuotes, subscribeBars);
}
public AssetClass AssetClass { get; }
public SymbolTable Symbols => _symbols;
/// <summary>Fired for every print on the tape.</summary>
public TickHandler? OnTrade { get; set; }
/// <summary>Fired on every top-of-book change.</summary>
public QuoteHandler? OnQuote { get; set; }
/// <summary>Fired when a minute bar closes — the engine's main decision trigger.</summary>
public BarHandler? OnBar { get; set; }
/// <summary>Fired for Alpaca's rolling daily bar.</summary>
public BarHandler? OnDailyBar { get; set; }
public long TradesReceived { get; private set; }
public long QuotesReceived { get; private set; }
public long BarsReceived { get; private set; }
protected override async ValueTask OnOpenAsync(CancellationToken ct)
{
_channelToken = ct;
// Alpaca accepts the auth frame immediately; the "connected" greeting and the
// "authenticated" acknowledgement both arrive on the receive loop.
await SendAsync(_authPayload, ct).ConfigureAwait(false);
}
protected override void OnMessage(ReadOnlySpan<byte> payload, bool isText)
{
if (!isText)
{
Log($"[{Name}] ignoring a binary frame ({payload.Length} bytes); expected JSON.");
return;
}
Utf8JsonReader reader = new(payload, isFinalBlock: true, state: default);
if (!reader.Read())
{
return;
}
if (reader.TokenType == JsonTokenType.StartArray)
{
while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
{
if (reader.TokenType == JsonTokenType.StartObject)
{
DecodeObject(ref reader);
}
else
{
reader.Skip();
}
}
}
else if (reader.TokenType == JsonTokenType.StartObject)
{
DecodeObject(ref reader);
}
}
private void DecodeObject(ref Utf8JsonReader r)
{
MsgKind kind = MsgKind.Unknown;
int symbolId = -1;
double open = 0, high = 0, low = 0, close = 0, volume = 0, vwap = 0;
double price = 0, size = 0, bidPrice = 0, bidSize = 0, askPrice = 0, askSize = 0;
int tradeCount = 0;
DateTime timestamp = default;
string? message = null;
int code = 0;
Aggressor aggressor = Aggressor.Unknown;
while (r.Read() && r.TokenType != JsonTokenType.EndObject)
{
if (r.TokenType != JsonTokenType.PropertyName)
{
r.Skip();
continue;
}
if (r.ValueTextEquals("T"u8))
{
r.Read();
kind = ParseKind(r.ValueSpan);
}
else if (r.ValueTextEquals("S"u8))
{
r.Read();
symbolId = _symbols.Resolve(r.ValueSpan);
}
else if (r.ValueTextEquals("t"u8))
{
r.Read();
timestamp = Rfc3339.ParseUtc(r.ValueSpan);
}
else if (r.ValueTextEquals("p"u8))
{
r.Read();
price = ReadNumber(ref r);
}
else if (r.ValueTextEquals("s"u8))
{
r.Read();
size = ReadNumber(ref r);
}
else if (r.ValueTextEquals("bp"u8))
{
r.Read();
bidPrice = ReadNumber(ref r);
}
else if (r.ValueTextEquals("bs"u8))
{
r.Read();
bidSize = ReadNumber(ref r);
}
else if (r.ValueTextEquals("ap"u8))
{
r.Read();
askPrice = ReadNumber(ref r);
}
else if (r.ValueTextEquals("as"u8))
{
r.Read();
askSize = ReadNumber(ref r);
}
else if (r.ValueTextEquals("o"u8))
{
r.Read();
open = ReadNumber(ref r);
}
else if (r.ValueTextEquals("h"u8))
{
r.Read();
high = ReadNumber(ref r);
}
else if (r.ValueTextEquals("l"u8))
{
r.Read();
low = ReadNumber(ref r);
}
else if (r.ValueTextEquals("c"u8))
{
r.Read();
// On a bar "c" is the close; on a trade/quote it is the condition array.
if (r.TokenType == JsonTokenType.Number)
{
close = r.GetDouble();
}
else
{
r.Skip();
}
}
else if (r.ValueTextEquals("v"u8))
{
r.Read();
volume = ReadNumber(ref r);
}
else if (r.ValueTextEquals("vw"u8))
{
r.Read();
vwap = ReadNumber(ref r);
}
else if (r.ValueTextEquals("n"u8))
{
r.Read();
tradeCount = (int)ReadNumber(ref r);
}
else if (r.ValueTextEquals("tks"u8))
{
r.Read();
// Alpaca's crypto feed reports the taker side as "B" or "S". It is the
// only way to know whether a print lifted an offer or hit a bid, which
// is what the volume delta is built from.
if (r.TokenType == JsonTokenType.String && r.ValueSpan.Length > 0)
{
aggressor = r.ValueSpan[0] switch
{
(byte)'B' or (byte)'b' => Aggressor.Buy,
(byte)'S' or (byte)'s' => Aggressor.Sell,
_ => Aggressor.Unknown,
};
}
}
else if (r.ValueTextEquals("msg"u8))
{
r.Read();
message = r.TokenType == JsonTokenType.String ? r.GetString() : null;
}
else if (r.ValueTextEquals("code"u8))
{
r.Read();
code = (int)ReadNumber(ref r);
}
else
{
r.Read();
r.Skip();
}
}
Dispatch(kind, symbolId, timestamp, message, code,
open, high, low, close, volume, vwap, tradeCount,
price, size, bidPrice, bidSize, askPrice, askSize, aggressor);
}
private void Dispatch(
MsgKind kind, int symbolId, DateTime timestamp, string? message, int code,
double open, double high, double low, double close, double volume, double vwap, int tradeCount,
double price, double size, double bidPrice, double bidSize, double askPrice, double askSize,
Aggressor aggressor)
{
switch (kind)
{
case MsgKind.Trade when symbolId >= 0:
{
TradesReceived++;
Tick tick = new(timestamp, price, size);
OnTrade?.Invoke(symbolId, _symbols.Name(symbolId), in tick, aggressor);
break;
}
case MsgKind.Quote when symbolId >= 0:
{
QuotesReceived++;
Quote quote = new(timestamp, bidPrice, bidSize, askPrice, askSize);
OnQuote?.Invoke(symbolId, _symbols.Name(symbolId), in quote);
break;
}
case MsgKind.Bar when symbolId >= 0:
{
BarsReceived++;
Bar bar = new(timestamp, open, high, low, close, volume, vwap, tradeCount);
OnBar?.Invoke(symbolId, _symbols.Name(symbolId), in bar);
break;
}
case MsgKind.DailyBar when symbolId >= 0:
{
Bar bar = new(timestamp, open, high, low, close, volume, vwap, tradeCount);
OnDailyBar?.Invoke(symbolId, _symbols.Name(symbolId), in bar);
break;
}
case MsgKind.Success:
if (string.Equals(message, "authenticated", StringComparison.Ordinal))
{
Log($"[{Name}] authenticated; subscribing to {_symbols.Count} symbol(s)");
_ = SendSubscribeAsync();
}
else
{
Log($"[{Name}] {message}");
}
break;
case MsgKind.Subscription:
SetState(ChannelState.Live);
Log($"[{Name}] subscription confirmed");
break;
case MsgKind.Error:
OnServerError(code, message);
break;
case MsgKind.Status:
case MsgKind.UpdatedBar:
case MsgKind.Unknown:
default:
break;
}
}
/// <summary>
/// Turns an Alpaca stream error into either a refusal or a note.
/// <para>
/// The distinction is the whole point. Codes in the 400s here mean the server has
/// decided about this session: reconnecting straight away cannot change its mind,
/// and — because an unauthenticated socket keeps the account's single market-data
/// slot busy for ten seconds — trying again quickly is what keeps the refusal true.
/// Treating these as informational is what produced an endless connect / 406 /
/// auth-timeout loop that never recovered on its own.
/// </para>
/// </summary>
private void OnServerError(int code, string? message)
{
string? refusal = code switch
{
406 => "un'altra connessione sta già usando i dati di mercato di questo conto " +
"(Alpaca ne consente una sola). Chiudi l'altra istanza di Encelado, oppure " +
"attendi: una sessione interrotta male viene liberata dal server dopo poco.",
401 or 403 => "credenziali rifiutate dallo stream dati. Controlla le chiavi in " +
"Impostazioni e che siano quelle dell'ambiente giusto (paper o live).",
409 => "abbonamento dati insufficiente per i simboli richiesti.",
_ => null,
};
if (refusal is null)
{
Log($"[{Name}] server error {code}: {message}");
return;
}
Log($"[{Name}] {code}: {refusal}");
Reject(refusal);
}
private async Task SendSubscribeAsync()
{
try
{
await SendAsync(_subscribePayload, _channelToken).ConfigureAwait(false);
}
catch (Exception ex) when (ex is not OperationCanceledException)
{
Log($"[{Name}] subscribe failed: {ex.Message}", ex);
}
}
private static double ReadNumber(ref Utf8JsonReader r) => r.TokenType switch
{
JsonTokenType.Number => r.GetDouble(),
JsonTokenType.String => double.TryParse(
r.ValueSpan, NumberStyles.Float, CultureInfo.InvariantCulture, out double d) ? d : 0,
_ => 0,
};
private static MsgKind ParseKind(ReadOnlySpan<byte> value)
{
if (value.Length == 1)
{
return value[0] switch
{
(byte)'t' => MsgKind.Trade,
(byte)'q' => MsgKind.Quote,
(byte)'b' => MsgKind.Bar,
(byte)'u' => MsgKind.UpdatedBar,
(byte)'d' => MsgKind.DailyBar,
(byte)'s' => MsgKind.Status,
_ => MsgKind.Unknown,
};
}
if (value.SequenceEqual("success"u8))
{
return MsgKind.Success;
}
if (value.SequenceEqual("error"u8))
{
return MsgKind.Error;
}
return value.SequenceEqual("subscription"u8) ? MsgKind.Subscription : MsgKind.Unknown;
}
private static byte[] BuildAuth(string key, string secret)
{
ArrayBufferWriter<byte> buffer = new(160);
using (Utf8JsonWriter w = new(buffer))
{
w.WriteStartObject();
w.WriteString("action", "auth");
w.WriteString("key", key);
w.WriteString("secret", secret);
w.WriteEndObject();
}
return buffer.WrittenSpan.ToArray();
}
private static byte[] BuildSubscribe(IReadOnlyList<string> symbols, bool trades, bool quotes, bool bars)
{
ArrayBufferWriter<byte> buffer = new(256);
using (Utf8JsonWriter w = new(buffer))
{
w.WriteStartObject();
w.WriteString("action", "subscribe");
if (trades)
{
WriteArray(w, "trades", symbols);
}
if (quotes)
{
WriteArray(w, "quotes", symbols);
}
if (bars)
{
WriteArray(w, "bars", symbols);
}
w.WriteEndObject();
}
return buffer.WrittenSpan.ToArray();
static void WriteArray(Utf8JsonWriter w, string name, IReadOnlyList<string> values)
{
w.WriteStartArray(name);
foreach (string v in values)
{
w.WriteStringValue(v);
}
w.WriteEndArray();
}
}
}
@@ -1,62 +0,0 @@
namespace Encelado.Alpaca.Streaming;
/// <summary>
/// Maps a symbol's UTF-8 bytes to a stable integer id and a single interned string
/// instance. The market-data decoder resolves symbols straight from the receive
/// buffer, so a busy tape does not allocate one string per tick.
/// </summary>
public sealed class SymbolTable
{
private readonly Dictionary<string, int> _ids;
private readonly Dictionary<string, int>.AlternateLookup<ReadOnlySpan<char>> _lookup;
private readonly List<string> _names = [];
public SymbolTable(IEnumerable<string> symbols)
{
ArgumentNullException.ThrowIfNull(symbols);
_ids = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
foreach (string s in symbols)
{
string symbol = s.Trim();
if (symbol.Length > 0 && _ids.TryAdd(symbol, _names.Count))
{
_names.Add(symbol);
}
}
_lookup = _ids.GetAlternateLookup<ReadOnlySpan<char>>();
}
public int Count => _names.Count;
public IReadOnlyList<string> Names => _names;
/// <summary>Resolves a symbol from raw UTF-8. Returns -1 when it is not subscribed.</summary>
public int Resolve(ReadOnlySpan<byte> utf8)
{
// Symbols are short ASCII (crypto pairs like BTC/USD included), so a stack
// buffer covers every real case without touching the heap.
if (utf8.Length is 0 or > 32)
{
return -1;
}
Span<char> chars = stackalloc char[32];
for (int i = 0; i < utf8.Length; i++)
{
byte b = utf8[i];
if (b > 127)
{
return -1;
}
chars[i] = (char)b;
}
return _lookup.TryGetValue(chars[..utf8.Length], out int id) ? id : -1;
}
public int Resolve(string symbol) => _ids.TryGetValue(symbol, out int id) ? id : -1;
public string Name(int id) => (uint)id < (uint)_names.Count ? _names[id] : string.Empty;
}
Loaded 100 of 412 files, more files were not shown because too many files have changed in this diff. Show more