Latent

Italiano▾

• English
• 한국어
• 日本語
• 简体中文
• 繁體中文
• Español
• Français
• Deutsch
• Italiano
• Português
• Polski

Come decide Latent #

Le tre fasce di sicurezza #

Ogni elemento tracciato da Latent porta uno di tre badge, che dice cosa succede se lo elimini:

• R · Recuperabile — torna: o riscaricato dalla sua fonte (provato contro il registry al momento dell'eliminazione, dove conta) o ricostruito dallo strumento proprietario al prossimo uso. Come torna lo vedi al passaggio del mouse; non è una decisione che spetta a te. Un segno verde significa esattamente questo: provato e pronto da spuntare.
• I · Nelle tue mani — ciò che sparisce non torna, quindi la scelta è tua. Qui finiscono due tipi di riga: il tuo lavoro (trascrizioni delle chat, immagini generate, record delle release) e qualsiasi cache il cui ritorno nessuno ha provato per questa cartella. Mostrata, bloccata, mai preselezionata.
• P · Protetto — ciò che Latent si rifiuta di toccare: chiavi di firma, backup dei dispositivi, binari CLI installati.

Tre lettere, tre significati — e nient'altro. Non c'è un quarto stato sullo schermo. Una cache che il catalogo crede tornerà, ma che nessuno ha provato per la tua cartella, non è "probabilmente a posto": è I, ambra, con lucchetto, finché una misurazione o la documentazione del vendor stesso non la rende R. La lettera dice cosa succede se la riga sparisce; il colore lo ripete — verde significa che Latent può agire sulla propria prova, ambra che la decisione è tua, grigio che non è di nessuno.

Dove va una lettera. Le lettere valutano ciò che se ne va insieme a una rimozione — una cache, una cartella di dati, un pacchetto, il bundle di un'app elencato sotto l'app. L'unità che scegli di rimuovere (una riga di app in App) non porta lettera; la portano le sue parti. Tutto ciò che è solo uno stato — in uso, trattenuto da una dipendenza, in attesa in quarantena — è scritto in grigio accanto alla lettera, mai come quarta lettera.

La scala delle prove #

"Sicuro da eliminare" si guadagna, non si presume mai. Latent usa quattro tipi di prova, dalla più forte:

Alcune cartelle vengono valutate pezzo per pezzo anziché in blocco: i simboli dei dispositivi di Xcode sono R per una build che un dispositivo ancora abbinato a questo Mac esegue e I per il resto; una cartella di pesi Keras è R solo finché ogni file al suo interno è un peso di Keras Applications.

Quando uno store mescola contenuto provabile e non provabile, Latent elimina solo la parte provata e ti dice esattamente cosa ha conservato e perché. Un fine-tune personale accanto ai modelli scaricati resta al suo posto, sempre.

Il lucchetto #

Ogni riga I porta un lucchetto. Aprirlo è un atto deliberato di consenso: la riga diventa selezionabile, l'eliminazione viene marcata come forzata nel registro, e il foglio di conferma la segnala in rosso. Il consenso ha un perimetro — una nuova scansione richiude ogni lucchetto aperto. Latent non apre mai un lucchetto al posto tuo, e gli assistenti AI collegati non possono aprirne affatto. Le righe P non hanno un lucchetto da aprire: Latent semplicemente non le propone.

Perché gli altri pulitori promettono numeri più grandi? #

Perché contano tutto ciò che sembra una cache. Il numero di Latent è più piccolo di proposito: ogni byte al suo interno porta una prova — una risposta del registry, un'origine registrata, un contratto del vendor o una rigenerazione osservata. I byte senza prove vengono comunque mostrati; sono solo tuoi da decidere, con il lucchetto in mano.

Dove avvengono le cose #

Ottimizza in un clic #

Il pannello Latent è l'azione a un clic: il logo stesso è il pulsante, un anello di avanzamento lo circonda mentre lavora, e il totale liberato arriva alla fine. Ciò che elimina supera due asticelle, non una: il recupero deve essere già provato, e l'elemento deve essere del genere di cui non ti accorgeresti nemmeno della perdita — cache dei pacchetti il cui vendor fornisce il proprio comando di pulizia, cache HTTP del browser, store di miniature. Tutto ciò che dovresti riguadagnarti (modelli scaricati, toolchain, plugin che hai installato) resta fuori da Ottimizza e aspetta in Space un clic deliberato. È volutamente la stessa allowlist a cui è limitato un assistente AI collegato, così un clic non può mai arrivare più lontano di quanto sia consentito a un assistente.

Ottimizza non tocca mai le righe non verificate, i tuoi file o i percorsi protetti; non apre mai un lucchetto al posto tuo; non disinstalla mai app o pacchetti, non scarica modelli dalla memoria, non svuota il Cestino. Se alcuni bersagli sono tenuti aperti da un'app in esecuzione, Ottimizza chiede prima — una checklist delle app che bloccano, ciascuna chiusa con garbo (compaiono le richieste di salvataggio dell'app stessa) solo se la lasci spuntata; togli la spunta a una e i suoi file vengono semplicemente saltati. Tutto ciò che si sposta va nel Cestino sotto un unico manifest di annullamento, e le guardie si rieseguono al momento dell'eliminazione. Il foglio di conferma elenca anche ciò che viene deliberatamente lasciato stare, così il numero che vedi è un minimo, non una vanteria.

Space: un unico elenco #

Space è un unico elenco di proprietari — Xcode, Homebrew, Hugging Face, Chrome e così via — ciascuno con una barra colorata in base a ciò che contiene: verde per la R provata, ambra per la I. Apri un proprietario e le sue righe arrivano prima le R, poi le I, dalla più grande in ciascun gruppo. Ogni riga mostra la sua lettera, il suo percorso (la home come ~, il percorso completo al passaggio del mouse) e una ↗ che la mostra nel Finder. La barra di testa del proprietario porta lo stesso chip ☐ R della cima dell'elenco — seleziona le righe provate di quel proprietario, e nient'altro — e un pulsante Sblocca N bloccate qui sotto… che apre ogni lucchetto sottostante in un unico passo deliberato. Sotto i proprietari vengono le tue cartelle — Documenti, Download, Foto — elencate, mai preselezionate.

I miei file: il fondo dell'elenco di Space #

Le cache sono ciò su cui Latent può dare prove; lo spazio che è davvero tuo richiede un contratto diverso. Sotto i proprietari-strumenti, Space elenca sei tipi di candidati tuoi sotto un divisore che lo dichiara, e ognuno segue la stessa regola: elencato, mai preselezionato, mai toccato da Ottimizza o da un assistente.

• Vecchi e inutilizzati — file oltre 200 MB non toccati da 6+ mesi (data di ultima apertura quando macOS la conosce, altrimenti data di modifica). Le librerie multimediali gestite — Musica, TV, GarageBand — non vengono mai elencate.
• Duplicati — copie identiche byte per byte, provate con checksum completo, non per nome. La copia più vecchia è quella da tenere e non viene mai elencata — eliminare tutte le righe mostrate lascia sempre una copia sul disco.
• Screenshot — trovati tramite il contrassegno che macOS stesso imprime sulle catture, quindi gli screenshot rinominati vengono trovati e le foto che vi somigliano no.
• Download — installer ormai serviti (.dmg/.pkg che hanno già fatto il loro dovere, in Download e sulla Scrivania) e download parziali abbandonati.
• Artefatti di build — node_modules, target di Rust, build/dist, virtualenv dentro le tue cartelle di progetto. Rivendicati solo accanto al loro marcatore di progetto (package.json, Cargo.toml, …), e un virtualenv senza file dei requirements resta bloccato — l'elenco dei pacchetti morirebbe con lui. Ricostruibili, ma una rebuild costa tempo, quindi non entrano mai in Ottimizza.
• iOS — backup dei dispositivi e aggiornamenti iOS scaricati (IPSW). Entrambi sono I di proposito: un vecchio backup non si può rifare, e Apple serve solo le build attualmente firmate.

App: il programma di disinstallazione #

App ha otto sorgenti, ciascuna in una scheda: App Mac, Homebrew, npm -g, Python (pip), Conda, Docker · Simulatori, Ricevute .pkg e Residui. Ogni riga che rappresenta qualcosa di rimovibile porta R, I o P come una riga di Space; la riga dell'app in sé no — è l'unità che scegli, e sono le sue parti sottostanti a essere valutate. La ruota a sinistra mostra le app per dimensione, e la barra a piè sotto di essa dice cosa contengono tutte insieme: i bundle stessi, poi ciò che lasciano dietro di sé, per lettera.

Fai clic su un'app per vedere ogni file posseduto dal suo bundle identifier — bundle, cache, preferenze, container, launch agent — prima le R, poi le I, dalla più grande. Il bundle in sé è una riga I (riavere l'app è una reinstallazione, e quella spetta a te). Le cartelle che Space elenca già come store vengono ripiegate in un'unica riga Store di Space: con i nomi degli store, una spunta per tutti. Latent prespunta solo ciò che può attribuire con certezza; due tipi di righe non vengono mai prespuntati:

• Righe che contengono dati tuoi — la cartella contiene documenti o database, come la cronologia chat di un'app di messaggistica — o qualsiasi cosa il catalogo di Latent classifichi come asset dell'utente, immagini disco opache incluse: la VM di Docker (ogni container e volume vive dentro un unico file) non viene mai prespuntata, per quanto certa sia l'attribuzione. Spuntarne una chiede una volta.
• Righe trovate per nome — elencate sotto un divisore che dice trovate per nome — potrebbero appartenere a un'altra app; corrispondenza solo per nome visualizzato, che un'altra app potrebbe condividere. Aprine una nel Finder prima di decidere.

Spuntare la casella dell'app stessa seleziona tutto ciò che sta sotto — dopo una sola domanda se qualcosa contiene dati tuoi, e la tua risposta viene ricordata per la sessione. Una disinstallazione è un unico manifest: un solo Annulla ripristina tutto. Se macOS esige diritti di amministratore per il bundle, Latent passa il compito al Finder — vedrai la richiesta di autenticazione standard. Ricevute .pkg elenca i residui degli installer in posizioni di proprietà dell'amministratore e lì non elimina nulla: mostra ciò che resta, esegue il programma di disinstallazione del vendor quando la ricevuta ne indica uno, e altrimenti mostra i file perché sia tu a rimuoverli nel Finder. Residui elenca dati la cui app non c'è più — tutto I, spuntato da te.

Docker e runtime dei simulatori: dove niente passa dal Cestino

Docker tiene immagini, container, volumi e cache di build dentro un unico disco VM opaco, quindi un'eliminazione a livello di file sarebbe un ripristino totale — Latent elenca quel disco come dati tuoi e non lo preseleziona mai. Ciò che il riquadro Docker offre invece è la rimozione propria di Docker di singoli elementi: un'immagine, o la cache di build. Quella rimozione è irreversibile — non passa dal Cestino e non c'è annullamento — quindi ha un foglio di conferma che lo dice con quelle parole, e Latent scrive il record prima di eseguire il comando: cosa se n'è andato, quanto era grande, e la riga docker pull esatta che lo riporta indietro. Le immagini usate da un container vengono rifiutate, e i volumi non vengono mai elencati — un volume è il database di qualcuno.

I runtime dei simulatori iOS funzionano allo stesso modo e per lo stesso motivo: un runtime è un'immagine disco firmata da Apple, montata dal vivo e tracciata nel registro di Apple stessa, quindi solo simctl può rimuoverlo. Stesso contratto — il foglio dice che non si può annullare, il record conserva xcodebuild -downloadPlatform iOS, un runtime con un simulatore avviato viene rifiutato, e quello incluso in Xcode non viene mai offerto. Le righe parlano le stesse tre lettere di ovunque altrove: un runtime che Apple può riscaricare è R, quello che Apple marca come non eliminabile è P, un'immagine con un registry alle spalle è R e un layer orfano è I. "In uso" è uno stato scritto in grigio accanto alla lettera, e il pulsante aspetta finché il simulatore o il container non è sparito.

Homebrew, npm, pip e Conda

Quattro delle sorgenti gestiscono ciò che brew, npm -g, pip --user e conda hanno installato — la roba che si accumula in silenzio per anni. I symlink di un keg e i file sparsi di un wheel renderebbero uno spostamento nel Cestino una bugia, quindi la rimozione esegue l'uninstall proprio del vendor, e il manifest di annullamento registra invece il comando esatto di reinstallazione. Vale la stessa regola di prova: prima di rimuovere qualsiasi cosa, Latent verifica che il registry (formulae.brew.sh / npm / PyPI) serva ancora quel nome e quella versione — nessuna risposta, nessuna rimozione. Ogni riga di pacchetto porta una lettera: R quando il gestore può reinstallarlo; R ma trattenuta quando un altro pacchetto ne dipende (i dipendenti vengono nominati, e un clic su uno ti porta lì); I quando nessuno ha potuto provarlo o l'hai fissato tu con un pin; P quando è il corpo stesso del gestore — pip e setuptools, node e npm, l'installazione di conda, qualsiasi cosa fuori dalla tua home o di proprietà di un altro account. Un user-site Python il cui interprete non c'è più (il classico residuo ~/Library/Python/3.x) viene offerto come un unico spostamento dell'intera cartella nel Cestino, con un normale annullamento.

Memoria #

Niente pulsanti di purga, niente punteggi di salute — macOS già comprime e pagina la memoria inattiva, quindi "liberare la RAM" per lo più significa pagare per rileggerla. Ciò che è reale è un'app dimenticata che trattiene gigabyte, quindi la scheda Memoria delle app elenca le tue app per footprint effettivo, con un pulsante Esci che è esattamente Cmd-Q: l'app mostra la propria richiesta di salvataggio, e niente viene mai terminato a forza. I processi di sistema non vengono mai elencati. Il pannello mostra anche cosa sta facendo la memoria unificata e quali daemon dei modelli (Ollama, LM Studio, llama.cpp, ComfyUI…) tengono i pesi residenti. Ogni pulsante esegue il comando proprio del vendor — ollama stop, lms unload --all, il /free di ComfyUI, l'unload del router di llama.cpp — così i modelli si ricaricano semplicemente al prossimo uso. Latent non termina mai niente a forza. La ruota mostra solo le tue app; la quota del sistema, lo swap e la compressione stanno nei piccoli anelli sotto di essa. I grafici dal vivo qui e in Panoramica iniziano a campionare nel momento in cui Latent si apre, quindi passando al pannello vedi la cronologia, non un grafico vuoto.

Barra dei menu e piccole abitudini #

• L'icona nella barra dei menu apre Latent e salta direttamente a Space, App o Memoria; Latent → Lingua cambia la lingua dell'interfaccia.
• Trascina le schede in Panoramica e Memoria per riordinarle; clic destro per nasconderle; passa il mouse sulle ruote e su ogni grafico per i dettagli.
• Trascina una ruota per farla girare, trascina il suo mozzo per inclinarla; fai clic su uno spicchio per aprire quel proprietario o quell'app al suo fianco.

Recuperare ciò che è stato eliminato #

Quarantena #

Ad alcune eliminazioni viene offerta una via più sicura del Cestino — una quarantena di 7 giorni — ma solo dove la perdita sarebbe opaca o difficile da invertire: elementi protetti e store illeggibili di "dati tuoi". Tutto il resto (cache non verificate, i tuoi file elencati) va dritto nel Cestino, dove la riga di Ripristino dichiara già il rischio. È una raccomandazione, mai un'imposizione. Durante la finestra, il ripristino è un clic dal pannello Ripristino. Alla scadenza l'elemento prosegue verso il Cestino — e Latent registra se lo strumento proprietario ha ricreato il percorso, costruendo la prova che l'affermazione non aveva mai avuto. Preferisci la via diretta? Scegli "Direttamente nel Cestino" nel foglio di conferma; la tua decisione vince.

Riavere le cose: il pannello Ripristino #

Tutto ciò che può tornare vive in un'unica tabella ordinabile, con la data della rimozione:

• In quarantena — uno store protetto o opaco che hai scelto di far passare per la finestra di 7 giorni (lì consigliata, mai imposta); un clic lo rimette esattamente dov'era.
• Nel Cestino — spostato sotto un manifest di annullamento; un solo Annulla ripristina un'intera pulizia.
• Sparito — i byte non ci sono più, ma il comando esatto che li riporta indietro è stato registrato nel momento in cui se ne sono andati: un'immagine Docker, un runtime dei simulatori, un modello Ollama, un pacchetto Homebrew o pip. Latent lo esegue per te — al meglio delle possibilità, onestamente: se il registry non lo ha più, serve un login o la rete è giù, l'errore lo dice in parole semplici e il comando registrato resta nell'elenco.

Le righe verdi — un comando registrato per riscaricare, o uno store verificato che lo strumento proprietario ricostruisce da sé — si possono anche svuotare direttamente da Ripristino — una riga o tutte insieme, dietro una conferma esplicita senza annullamento — perché la loro via del ritorno sopravvive ai byte. Le righe che sparirebbero per sempre non ricevono mai quel pulsante; quella decisione resta al Finder.

Le righe sono raggruppate per stadio — quarantena, Cestino, sparito — le più recenti in alto, con la data in cui un elemento è entrato in ciascuno stadio nella colonna di quello stadio; ordina per nome, origine o dimensione, filtra per stadio, cerca per nome, origine o comando. Ogni riga porta anche la lettera con cui è stata valutata al momento della rimozione — R o I — perché la via del ritorno dipende da quella. L'ultimo gruppo è il punto: il registro sopravvive al Cestino, quindi svuotare il Cestino non ti costa nulla che tu non possa deliberatamente riavere. I comandi girano solo in forme ristrette e validate; tutto il resto viene mostrato perché sia tu a copiarlo.

Altri elementi nel Cestino. Ciò che il Finder ha messo nel Cestino — non Latent — è elencato sotto un'intestazione propria, in sola lettura, con un pulsante Rimetti che lo riporta nel punto registrato dal Finder quando ce n'è uno. Latent non svuota né scarta mai quegli elementi; ti lascia solo vederli accanto ai propri record.

Il Cestino resta tuo #

Latent sposta le cose nel Cestino e non lo svuota mai alle tue spalle. Non tocca nulla che non abbia messo lui, e non scarta nulla che non abbia una via di ritorno. La scheda Cestino in Panoramica mostra cosa contiene e un pulsante lo apre nel Finder.

Ci sono però due punti che si offrono di finire il lavoro. Ripristino svuota le righe una alla volta, o tutte quelle sicure in un colpo — dove "sicura" significa che la riga porta ancora un comando di riacquisizione registrato, o la prova verificata che lo strumento la ricostruisce. E Ottimizza lo propone subito dopo un'esecuzione, solo per quell'esecuzione. Ottimizza rimuove soltanto elementi di sicurezza dimostrata, quindi ogni riga che ha spostato si riscarica o si rigenera da sé; mandarti nel Finder a recuperare lo spazio sarebbe l'app che si tira indietro da una decisione che aveva già preso. Il pulsante dichiara quanti elementi e quanto pesano, e chiede una volta.

Tutto il resto nel Cestino — compreso quello che hai scelto tu in Space — resta al tuo giudizio, in Ripristino o nel Finder.

Tutto è reversibile #

Le eliminazioni vanno nel Cestino, mai dritte nell'oblio, e ogni esecuzione scrive un manifest di annullamento che ripristina esattamente ciò che si è spostato. Prima che una pulizia in Space sposti qualcosa, girano quattro guardie: lo strumento proprietario non è in esecuzione, nessun binario in esecuzione vive dentro il bersaglio, nessun file al suo interno è tenuto aperto da un processo, e niente è cambiato negli ultimi 10 minuti. Le guardie ricontrollano al momento dell'eliminazione, non solo in fase di pianificazione. Il programma di disinstallazione in App esegue la propria coppia — l'app non deve essere in esecuzione, e nessun file dentro il bersaglio può essere tenuto aperto.

Assistenti IA (MCP) #

Latent include un server MCP, quindi qualsiasi assistente con supporto MCP può leggere il quadro del tuo disco e proporre pulizie. Il server è il binario dell'app stesso:

Una riga #

Latent può collegarsi da solo a ogni assistente su questo Mac. Incolla questo nel Terminale:

Scrive solo dove il client c'è davvero: esegue il mcp add del client quando esiste (Claude Code, Codex, Gemini, Grok) e modifica la configurazione JSON quando non esiste (Cursor, Claude Desktop, VS Code, Windsurf). Le configurazioni JSON che modifica vengono prima copiate in .bak (un client con una CLI propria gestisce la sua). Non inventa configurazioni per client che non hai e lascia stare quello che conosce già Latent. Aggiungi --dry-run per vedere prima cosa farebbe.

Collegare un client #

Oppure collega un client a mano:

Claude Code

Codex CLI

Gemini CLI

Grok CLI

Il -- conta: passa --mode mcp a Latent invece di lasciare che Grok lo legga come un proprio flag. Grok può anche controllare per te il suo lato del cablaggio — grok mcp doctor riferisce se il server parte, se l'handshake si completa e quanti strumenti ha trovato.

Cursor, Claude Desktop, Windsurf, VS Code e qualsiasi altro client con una configurazione JSON

Aggiungi questo nella sezione dei server MCP del client — ~/.cursor/mcp.json per Cursor, claude_desktop_config.json per Claude Desktop, .vscode/mcp.json per VS Code (VS Code lo annida sotto "servers" invece di "mcpServers"):

{
  "mcpServers": {
    "latent": {
      "command": "/Applications/Latent.app/Contents/MacOS/Latent",
      "args": ["--mode", "mcp"]
    }
  }
}

Il trasporto è semplice stdio — nessuna porta, nessun daemon, niente da tenere in esecuzione; il client avvia il server su richiesta. Vengono servite entrambe le generazioni del protocollo: quella attuale (2026-07-28, con server/discover e una versione su ogni richiesta) e il vecchio handshake, così qualsiasi client dal 2024 in poi si collega.

Cosa chiedergli #

Il server offre sei strumenti, e non li chiami mai per nome — chiedi con parole tue e l'assistente sceglie:

• latent_overview — "dov'è finito il mio disco?" Totali per proprietario e per fascia.
• latent_items — "cosa potrei liberare sopra i 500 MB?" Singoli elementi con dimensione, fascia e prova.
• latent_clean — "svuota le cache di download di pip e npm". È lo strumento che sposta le cose nel Cestino, e prende chiavi di elementi che l'assistente ha ottenuto da latent_items — mai una cartella che hai nominato di sfuggita.
• latent_free — "adesso ridammi davvero lo spazio". Svuota dal Cestino solo ciò che Latent ci ha messo, così il numero sul disco si muove davvero. Questo non si annulla, e il pannello nomina ciò che non tornerà prima che tu approvi.
• latent_duplicates — "ci sono pesi di modelli duplicati?"
• latent_memory — "cosa sta trattenendo la RAM in questo momento?" Solo lettura; chiudere un'app non spetta mai all'assistente.

Fin dove arrivare #

Quasi tutto ciò che riempie il disco di chi sviluppa non è pericoloso da eliminare. È solo costoso da riavere, e quanto di quel costo sei disposto ad accettare è una domanda a cui puoi rispondere solo tu. Per questo ogni riga che l'assistente legge porta un livello, e dovrebbe mostrarti i quattro totali prima di proporre qualcosa:

• Livello 1: torna da solo, senza che nessuno se ne accorga. È il valore predefinito, lo stesso insieme che prende Ottimizza in un clic.
• Livello 2: torna, ma ricostruirlo o riscaricarlo costa tempo vero. Non si perde nulla. DerivedData sta qui.
• Livello 3: nessuno ha provato che torni. Probabilmente sì, ma Latent non lo dice senza prove.
• Livello 4: i tuoi file e l'insieme protetto. Elencati e misurati così sai cosa c'è, e a nessun livello un assistente può eliminarli. Quella decisione si prende nell'app, riga per riga.

Tu dici fin dove, l'assistente passa quel numero e il piano che riceve indica il livello di ogni riga, così puoi controllare prima di accettare che sia rimasto entro la tua scelta. Non può alzare il tetto da solo: il server arriva a 3, qualunque cosa chieda.

Cosa lascia questo Mac #

Un assistente vede percorsi, dimensioni, fasce ed etichette delle prove — mai il contenuto dei file. Ma un percorso è un'informazione: se il tuo assistente gira nel cloud, i nomi delle cartelle sotto la tua home viaggiano fino a lui, come qualsiasi file che incolli in una chat. Un modello locale li tiene sulla macchina. Latent in sé non invia nulla da nessuna parte; risponde al client che lo ha avviato, attraverso una pipe, e quel client decide dove va la risposta.

Cosa può e non può fare un assistente #

I poteri dell'assistente sono strettamente più piccoli dei tuoi: per impostazione predefinita può toccare solo elementi verificati riscaricabili/ricostruibili (la stessa allowlist di Ottimizza in un clic), e va oltre solo quando dici tu fin dove (vedi Fin dove arrivare). Una regola è assoluta: un assistente non può eliminare nulla che non ti abbia mostrato e che tu non abbia accettato. È Latent stesso a decidere quali elementi rientrano in una richiesta, consegna all'assistente quell'elenco esatto e poi agisce solo su quello: una volta sola, entro pochi minuti, rifiutando qualunque elemento cambiato nel frattempo. Nessuna risposta significa nessuna eliminazione. Gli assistenti non possono mai aprire un lucchetto, mai raggiungere i tuoi file, e mai vedere il contenuto dei file — solo dimensioni, percorsi ed etichette delle prove. Ogni elemento che l'assistente non può prendere dice perché nell'elenco stesso — non provato, costa tempo reale da ricostruire, file tuoi, protetto — così non deve mai indovinare, e la panoramica riporta sia la cifra che può spostare sia il totale R provato, più grande, che l'app mostra.

Licenza e supporto #

Guardare è gratis, rimuovere richiede la licenza #

Latent senza licenza è un visualizzatore a piena potenza: scansiona quanto vuoi, esplora ruote e anelli, osserva la crescita nel tempo, leggi il log. Niente scade. Ciò che la licenza sblocca è la rimozione dei file — e il recupero (annullamento, ripristino dalla quarantena) funziona sempre e comunque, perché l'unica cosa che questa app non farà mai è tenere i tuoi file in ostaggio.

Attivare una licenza o una chiave beta #

Barra dei menu → Latent → Inserisci licenza…, incolla la chiave, fatto. Una chiave copre più di un Mac (una chiave beta si attiva su un massimo di 2). La scansione non ha mai avuto bisogno della chiave; l'eliminazione si sblocca nel momento in cui la chiave arriva. Nessun account, nessuna email, nient'altro a cui accedere. Sotto il cofano la chiave viene scambiata con un token di licenza firmato dal server per questo Mac; l'app verifica la firma da sé e rinnova il token all'avvio, così un file di impostazioni copiato non può sbloccare un secondo Mac, e un Mac offline continua a funzionare per settimane prima di chiedere di rivedere il server. Senza licenza, ogni foglio di conferma mostra comunque cosa farebbe e propone Ottieni una licenza… al posto del pulsante.

Passare a un altro Mac, e rimborsi #

Una chiave acquistata si attiva su un massimo di 3 Mac. Se ne vendi o ne dismetti uno, apri lì Latent → Inserisci licenza… e premi Rilascia — il posto torna subito alla tua chiave e puoi usarlo altrove. Su quel Mac non viene eliminato nulla, e puoi riattivarlo in qualsiasi momento.

Se un acquisto viene rimborsato o stornato, la chiave smette di valere per l'eliminazione al successivo avvio dell'app. Il ripristino non smette mai di funzionare. Annulla, il ripristino dalla quarantena e Rimetti sono del tutto fuori dalla licenza — un rimborso può portarti via il prodotto, ma non può mai lasciare i tuoi file a piedi.

Verificare che il download sia davvero nostro #

Latent è firmata con un Developer ID e autenticata da Apple, e il ticket è pinzato all'immagine disco: macOS lo controlla alla prima apertura, anche offline. Se il file fosse stato alterato tra la nostra build e il suo Mac, non si aprirebbe affatto.

Per verificarlo di persona, dopo aver spostato l'app in Applicazioni:

spctl -a -vv /Applications/Latent.app

accepted
source=Notarized Developer ID
origin=Developer ID Application: FatTail Labs (BUS4S7XFQV)

L'identificativo del team BUS4S7XFQV è il nostro e non può essere falsificato; è ciò che un checksum su questa pagina non potrebbe darle, perché chi potesse sostituire il download sostituirebbe anche il checksum accanto.

Gli aggiornamenti affrontano la stessa prova. Prima di sostituire qualsiasi cosa, Latent verifica la firma, controlla l'identificativo del team e interroga Gatekeeper. Se uno fallisce, l'aggiornamento si ferma e resta la copia che ha.

Rimuovere Latent #

Latent è un bundle app e una cartella. Per rimuoverlo, esci da Latent (l’icona nella barra dei menu se ne va con lui) e trascina Latent.app nel Cestino. Non installa helper, elementi di login né estensioni del kernel, e non conserva alcuna password.

I tuoi record vivono in ~/.latent: record di annullamento, la cartella di quarantena (elementi ancora nel periodo di osservazione), la lista di esclusione e il log delle attività. Lasciala se potresti reinstallare — sono le vie del ritorno. Eliminala solo quando hai davvero finito: ciò che è ancora in quarantena se ne va con lei, quindi prima ripristinalo o svuotalo dalla scheda Ripristino.

Latent elenca se stesso in App come P — non si rimuove mai dall’interno.

Domande? #

Nell'app: Aiuto → Invia feedback…. Invia il tuo messaggio più la versione dell'app e di macOS; il log attività viene allegato solo se spunti la sua casella, con il nome della tua cartella Inizio rimosso prima. Niente viene mai inviato in background — invia solo quel pulsante. Oppure scrivi a fattaillabs.ceo@gmail.com — leggiamo tutto.