CASP mantiene un'immagine sempre vera di dove si trova davvero ciascuno dei tuoi progetti — in qualsiasi momento, validata rispetto a git. Torna dopo una settimana o dopo mesi, su qualunque stack, attraverso un numero qualunque di agenti, sessioni o colleghi: aprila e lo stato è vero — oppure casp check blocca il push finché non lo è.
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
}
CASP è la base deterministica del ciclo di auto-verifica — l'unico controllo di « verifica il tuo lavoro » che non è il modello che verifica se stesso: lo stato rispetto a git, alla frontiera del push, dove il controllo interno al ciclo non può arrivare. Lo spazio adiacente — Mem0, Letta, Zep, i nuovi progetti di « memoria » nativi git — immagazzinano tutto ciò che è successo; quasi nessuno verifica che lo stato immagazzinato corrisponda ancora a git. Quel controllo è casp check — obbligatorio 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.Trasforma la tua specifica in una coda di prompt di sessione — ognuno un file nel tuo repository che dichiara che cosa lo precede. casp next consegna al tuo agente la testa di quella coda, e si rifiuta di consegnargli una fetta già consegnata.
casp next stampa il prompt. Non lo esegue mai — lo fa il tuo agente. CASP è ciò che rende affidabile il passaggio di consegne, non un orchestratore.
Alla fine di ogni sessione il tuo agente aggiunge il registro, incrementa lo stato e redige il prompt successivo della coda — tu aggiusti una riga invece di scrivere da zero. E il quadro delle fasi resta in roadmap.md, così qualsiasi agente conosce l’ordine del lavoro.
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