I nuovi modelli portano avanti la tua intera roadmap per ore, persino giorni, senza perdere il filo. È proprio per questo che la deriva dello stato conta di più, non di meno: più un agente fa tra un tuo checkpoint e l'altro, più lo stato che ha registrato può smettere di corrispondere a git, in silenzio. casp check è la barriera deterministica che blocca il push nel momento in cui ciò accade — con Claude Code oggi, e con ogni modello che uscirà domani.
Torni su un progetto dopo una settimana — o ne porti avanti cinque alla volta. L'agente legge un file di stato che non corrisponde più alla realtà, si lancia con sicurezza in un lavoro già consegnato, e tu bruci un pomeriggio a disfarlo.
Bacheche, schede e fogli di calcolo non ti salvano: ricostruire il contesto è manuale, e l'agente non riesce a leggerne nulla. Lo stato deve essere leggibile dalla macchina, nativo git — e vero in modo dimostrabile.
CASP dà a ogni progetto un filo unico che sopravvive da una sessione all'altra — e non può deviare in silenzio.{
"phase": "13 — camera streaming",
"next_prompt": "phases/14-camera.md",
// shipped in v13.4
"last_commit": "a1f3c9",
// not in git history
"migrations": ["0001"…"0007"],
// git stops at 0006
}
Lo spazio adiacente — Mem0, Letta, Zep, i nuovi progetti di « memoria » nativi git — immagazzina tutto ciò che è successo. Quasi nessuno verifica che lo stato immagazzinato corrisponda ancora alla realtà di git. Quella verifica è casp check — ed è obbligatoria prima di ogni push.
Il tuo next_prompt punta a un file già consegnato — o che non esiste. CASP si rifiuta di avviare la sessione sbagliata.
last_commit assente dalla cronologia, elenco delle migrazioni non sincronizzato, stato non committato — confrontato con git stesso, non con una stima.
Nessun punteggio di similarità approssimativo. Una barriera pass/fail netta e ripetibile che ferma il push finché lo stato mente.
CASP non sostituisce nulla nel tuo workflow. Colma l'unica lacuna che nient'altro copre — il presente validato di un progetto, in una forma che il tuo agente può leggere e su cui può agire.
Nessun database. Nessun servizio. Nessun archivio vettoriale. Tre semplici file che un agente può leggere alla prima riga di qualsiasi sessione.
Leggibile dalla macchina, per progetto: fase attuale, fase successiva, il next-prompt esatto da eseguire, le fasi consegnate, le migrazioni applicate, l'ultimo commit, l'ultimo identificativo di sessione.
Il « a che punto sono adesso » su una sola schermata. Aprilo, recupera il filo in cinque secondi — niente archeologia.
Le prossime 3 da consegnare più un tabellone delle fasi. L'agente conosce sempre l'ordine del lavoro.
session-prompt, session-log e audit-brief fanno sì che ogni sessione — umana o agente — produca artefatti della stessa forma. La struttura è imposta, non suggerita.Un prodotto vero non è una sola funzionalità. È decine di fasi distribuite tra API, client web e mobile, consegnate nell'arco di settimane da sessioni e agenti che si alternano. CASP mantiene un ordine validato unico su tutto l'insieme — così qualsiasi agente sa quale fase viene dopo, e non riconsegna mai una fase già consegnata.
E il ciclo si chiude da sé: alla fine di ogni sessione l'agente scrive per te il prompt della sessione successiva — tu aggiusti una riga, non scrivi da zero — aggiunge un registro di sessione e incrementa lo stato. Apri la sessione successiva e riprende esattamente da dove si era fermata la precedente. La roadmap si esegue; tu supervisioni.
Ogni cifra qui sotto è letta direttamente dallo state.json di ciascun progetto — lo stesso file che legge l'agente, validato rispetto a git all'ultimo push. Nessun calcolo di marketing.
Un ERP di gestione flotta rivolto ai clienti di un'azienda di trasporti in Costa d'Avorio — web + mobile, multi-modulo, multi-ruolo: autisti, veicoli, conformità, cassa, officina, contenzioso, contabilità.
Ogni modulo è una fase validata. L'agente legge il cockpit, avvia la fase successiva da next_prompt, e non ha mai riconsegnato un modulo già consegnato — nemmeno in una giornata da sei sessioni.
La piattaforma interna di ops & orchestrazione dei lanci di ZeroSuite — una roadmap su più mesi portata avanti da un vero team, con gating in modalità lancio e un backlog post-lancio tracciato.
Un filo validato unico su 40+ fasi e tre persone — più 58 elementi esplicitamente rinviati dopo il lancio, nessuno perso. È il caso del « grande progetto multi-utente » per cui CASP è stato concepito.
Stesso protocollo, due prodotti molto diversi. Il cockpit è l'unica cosa che condividono.
Gli strumenti di memoria trattengono chi sei. CASP segue a che punto è il tuo progetto — e lo dimostra. Artefatto diverso, operazione diversa, guasto diverso che previene.
Una sillaba, nessun omografo, gli stessi in inglese, francese o spagnolo.
state.next_prompt.CASP fornisce slash-command Claude Code perché lo stato viva là dove già lavori.
Stato in sola lettura — l'agente legge il filo attuale prima di scrivere una sola riga.
Avvia automaticamente la sessione successiva direttamente da state.next_prompt. Nessun copia-incolla, nessuna supposizione.
Compatibile con Claude Code · Cursor · Aider · Continue — qualsiasi cosa legga file.
Un agente che fa la cosa sbagliata costa un pomeriggio. Cento agenti che la fanno su cento repo costano un trimestre. CASP è il guardrail deterministico che inserisci nel ciclo di automazione — la stessa forma in ogni progetto.
casp check occupa lo stesso posto del lint e dei test. Uno stato che mente non può essere mergiato — la deriva è bloccata a livello di organizzazione, non lasciata alla disciplina di ciascuno.
Gli agenti autonomi moltiplicano gli errori. CASP consegna a ciascuno di essi lo stesso filo validato da leggere e la stessa barriera netta prima che faccia il push. L'automazione senza la tassa del lavoro doppio.
Ogni transizione di stato è un commit git. Un registro completo, confrontabile e reversibile di come ogni progetto è avanzato — git log è la tua traccia di conformità.
Solo locale, zero telemetria, niente cloud, niente account. Niente da verificare, niente da esfiltrare. La revisione di sicurezza sta in una riga: non lascia mai la macchina.
jobs: state-check: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: { fetch-depth: 0 } # casp checks against full git history - run: npx @justethales/casp check # ✗ fails the build the moment state drifts
Un protocollo, ogni repo. La stessa forma validata, in tutta l'organizzazione.
Un protocollo si guadagna l'adozione essendo prevedibile. Queste regole non si piegano.
CASP controlla ciò che il tuo repo è, mai ciò che avevi intenzione di fare. I fatti rispetto a git, ogni volta.
Gli artefatti canonici sono imposti, non suggeriti. Ogni sessione esce con la stessa forma.
Il validatore non è opzionale. Uno stato che mente non raggiunge mai il tuo remote.
Deterministico, nativo git, solo locale. Zero telemetria. Niente cloud, niente account, niente fattura.
Installa, inizializza, e il tuo agente legge la verità già dalla prima riga.
$ npm i -g @justethales/casp $ casp init # scaffold the layer $ casp status # where am I right now $ casp check # prove the state is true