npm - @dogfood-lab/study-swarm - Versions diffs - 1.3.0 → 2.1.0 - Mend

@dogfood-lab/study-swarm 1.3.0 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/CHANGELOG.md +61 -0
package/PROTOCOL.md +5 -5
package/README.es.md +18 -11
package/README.fr.md +23 -16
package/README.hi.md +19 -12
package/README.it.md +25 -18
package/README.ja.md +23 -16
package/README.md +15 -8
package/README.pt-BR.md +18 -11
package/README.zh.md +19 -12
package/SECURITY.md +6 -5
package/bin/study-swarm.mjs +631 -87
package/examples/study-swarm-canon-rollback.dispatch.md +8 -9
package/examples/study-swarm-canon-rollback.lock.json +20 -20
package/examples/study-swarm-ci.yml +3 -2
package/examples/study-swarm-lock.dispatch.md +12 -12
package/examples/study-swarm-lock.lock.json +15 -15
package/examples/study-swarm-v1_1.dispatch.md +1 -1
package/package.json +1 -1

package/README.it.md CHANGED Viewed

@@ -23,18 +23,18 @@ Applica la propria "medicina". Il protocollo prevede l'utilizzo di verificatori
 1. **Identificare** 3-5 domande progettuali fondamentali su cui le prove empiriche potrebbero cambiare la risposta.
 2. **Attivare** un agente di ricerca per ogni domanda, in parallelo. Ognuno deve restituire titoli degli articoli + autori + anni + URL + una breve sintesi (una frase) — dare priorità alla specificità rispetto all'ampiezza ("6-8 risultati ben documentati sono meglio di 20 affermazioni vaghe").
-3. **Sintetizzare** i risultati in una sezione "Fondamento della ricerca": `N. **<risultato>.** <Autori> <anno> (<arXiv/DOI>). <implicazione progettuale>.`
-4. **Verificare esternamente** — una *famiglia di modelli diversa*, priva di capacità di ragionamento, controlla ogni citazione in due fasi: un **oracolo di recupero** conferma che l'articolo esiste (non si basa mai sulla memoria del modello), quindi una "lente di fondatezza" verifica che il risultato corrisponda alla fonte. **Interrompere** se la citazione è fabbricata o attribuita in modo errato; **interrompere e segnalare** se il verificatore o l'oracolo di recupero non sono disponibili (non interpretare mai l'assenza come "le citazioni sono corrette").
+3. **Sintetizzare** i risultati in una sezione "Research grounding" (fondamento della ricerca): `N. **<risultato>.** <Autori> <anno> (<arXiv/DOI>). <implicazione progettuale>.`
+4. **Verificare esternamente** — una *famiglia di modelli diversa*, con il ragionamento del generatore nascosto, controlla ogni citazione in due fasi: un **oracolo di recupero** conferma che l'articolo esiste (non si basa mai sulla memoria del modello), quindi una "lente di fondatezza" verifica che il risultato corrisponda alla fonte. **Scartare** un risultato fabbricato; **correggere un'attribuzione errata una volta** e riverificare (un secondo verdetto non pulito lo scarta). **Interrompere e segnalare** solo se il verificatore o l'oracolo di recupero non sono disponibili (non interpretare mai l'assenza come "le citazioni sono corrette").
 5. **Collegare** ogni scelta architettonica a un risultato specifico, tramite numero. Le citazioni prive di implicazioni progettuali sono rumore.
 I dettagli completi e eseguibili — la tabella di interruzione, lo standard per le fonti, la regola dell'insieme — si trovano in **[PROTOCOL.md](PROTOCOL.md)**.
-## Perché una *famiglia diversa*, priva di capacità di ragionamento?
+## Perché una *famiglia diversa*, con il ragionamento del generatore nascosto?
 Perché i modi di errore sono documentati, non ipotetici:
 - **Gli LLM non possono verificare in modo affidabile i propri risultati.** Huang et al. 2023 ([arXiv:2310.01798](https://arxiv.org/abs/2310.01798)); Kambhampati et al. 2024 ([arXiv:2402.01817](https://arxiv.org/abs/2402.01817), LLM-Modulo); Stechly et al. 2024 ([arXiv:2402.08115](https://arxiv.org/abs/2402.08115)) — il verificatore esterno offre i vantaggi; l'autovalutazione è inerte.
-- **I giudici della stessa famiglia tendono a favorire se stessi.** Panickssery, Bowman & Feng 2024 ([arXiv:2404.13076](https://arxiv.org/abs/2404.13076)) — l'autoriconoscimento è correlato *linearmente* all'autopreferenza, quindi un'occlusione parziale non aiuta. Verga et al. 2024 ([arXiv:2404.18796](https://arxiv.org/abs/2404.18796), PoLL) — un gruppo di esperti provenienti da famiglie diverse è meno influenzato, con un costo inferiore di circa il 7%.
+- **I giudici della stessa famiglia tendono a favorire se stessi.** Panickssery, Bowman & Feng 2024 ([arXiv:2404.13076](https://arxiv.org/abs/2404.13076)) — l'autoriconoscimento è correlato *linearmente* all'autopreferenza, quindi un'occlusione parziale non aiuta. Verga et al. 2024 ([arXiv:2404.18796](https://arxiv.org/abs/2404.18796), PoLL) — un gruppo di esperti provenienti da famiglie diverse è meno influenzato, a un costo circa 7 volte inferiore.
 - **Le citazioni sono dove gli LLM mentono.** Walters & Wilder 2023 ([doi:10.1038/s41598-023-41032-5](https://doi.org/10.1038/s41598-023-41032-5)) — il 55% delle citazioni di GPT-3.5 / il 18% di GPT-4 sono fabbricate. Onweller et al. 2026 ([arXiv:2605.06635](https://arxiv.org/abs/2605.06635)) — i collegamenti risolvono oltre il 94% delle volte, ma solo il 39-77% del contenuto citato supporta effettivamente l'affermazione. Pertanto, l'esistenza deve essere verificata tramite **recupero, non richiamo**.
 - **Nascondere il ragionamento del generatore.** Khalifa et al. 2026 ([arXiv:2601.14691](https://arxiv.org/abs/2601.14691), "Gaming the Judge") — la sola manipolazione della catena di pensiero aumenta i falsi positivi del giudice fino al 90%, mantenendo le azioni fisse. Turpin et al. 2023 ([arXiv:2305.04388](https://arxiv.org/abs/2305.04388)) — la catena di pensiero è una razionalizzazione post-hoc. Il verificatore vede solo l'affermazione della citazione, mai il "perché ho incluso questo".
 - **La diversità supera la quantità.** Rajan 2025 ([arXiv:2511.16708](https://arxiv.org/abs/2511.16708)) — quattro verificatori con una correlazione a coppie ρ ∈ [0,05, 0,25] superano qualsiasi singolo verificatore tramite copertura submodulare. Kim et al. 2025 ([arXiv:2506.07962](https://arxiv.org/abs/2506.07962)) — gli errori degli LLM sono *correlati*, quindi la variabile più importante è la diversità delle "lenti", non la quantità assoluta.
@@ -75,12 +75,15 @@ npm i -g @dogfood-lab/study-swarm     # or run ad-hoc: npx @dogfood-lab/study-sw
 |---|---|
 | `study-swarm protocol` | Stampa l'intero protocollo: i cinque passaggi, la tabella di arresto e lo standard di riferimento. |
 | `study-swarm new <slug>` | Crea uno scheletro `<slug>.dispatch.md` con i cinque passaggi da completare. |
-| `study-swarm lint [--json] <path…>` | Verifica la *fondatezza della ricerca* di un sistema rispetto allo standard di riferimento: ogni risultato deve avere un autore, un anno e un identificatore risolvibile (arXiv / DOI / URL); le affermazioni generiche del tipo "gli studi dimostrano..." vengono rifiutate. In caso di violazioni, il programma termina con codice `1`, in modo da bloccare l'integrazione continua (CI). Un `<path>` può essere un file, una directory (analizzata ricorsivamente per i file `*.dispatch.md`) o `-` per l'input standard; `--json` emette un report leggibile dalla macchina. |
-| `study-swarm lock <dispatch> --from <orchestration.json>` | Blocca un sistema per la riproduzione: scrive il contenuto di `<dispatch>.lock.json`, che, per ogni agente del passaggio 2, include l'**ID del modello risolto**, l'**SHA-256 del prompt esatto in byte** e l'**SHA-256 dello schema dello strumento**, oltre alla **ricevuta del verificatore** del passaggio 4, tutto racchiuso in un unico `lock_sha256`. |
+| `study-swarm lint [--json] [--strict] <path…>` | Verifica l'attendibilità delle *fonti* di un documento rispetto agli standard di riferimento: ogni affermazione deve avere un autore, un anno e un identificatore univoco (arXiv / DOI / URL / RFC); le affermazioni generiche del tipo "gli studi dimostrano..." non sono accettate. In caso di violazioni, il processo termina con codice `1`, interrompendo così l'esecuzione continua (CI). Un `<path>` può essere un file, una directory (analizzata ricorsivamente per i file `*.dispatch.md`) o `-` per l'input standard; `--json` genera un report leggibile da macchina. L'opzione `--strict` contrassegna inoltre le **citazioni orfane** (un'affermazione che non è citata in nessuno dei passaggi), poiché "le citazioni senza una connessione sono irrilevanti" (questa opzione è facoltativa, quindi l'impostazione predefinita per il processo CI rimane invariata). |
+| `study-swarm return <dispatch> [--check]` | Scrive i risultati: `<stem>.results.md` è il foglio da consegnare, e `<stem>.results.json` conserva gli stessi fatti accanto al dispatch per l'esecuzione successiva. `--check` fallisce se una delle due copie non corrisponde più al dispatch. |
+| `study-swarm lock --init <dispatch>` | Crea il file `<dispatch>.orchestration.json`: un modello di configurazione da completare con i dati necessari (un passaggio per ogni agente del Passo 2) e che verrà utilizzato con il comando `lock … --from`. |
+| `study-swarm lock <dispatch> --from <orchestration.json>` | Blocca un sistema per la riproduzione: scrive il contenuto di `<dispatch>.lock.json`, che, per ogni agente del passaggio 2, include l'**ID del modello risolto**, l'**SHA-256 del prompt normalizzato (BOM rimosso, a capo in LF, NFC)** e l'**SHA-256 dello schema dello strumento**, oltre alla **ricevuta del verificatore** del passaggio 4, tutto racchiuso in un unico `lock_sha256`. |
 | `study-swarm lock --verify <dispatch> [--from …]` | Ricalcola questi hash e verifica che corrispondano al blocco; qualsiasi discrepanza fa terminare il programma con codice `1`, in modo da bloccare l'integrazione continua (CI) come farebbe un file di blocco dei pacchetti. Senza `--from`, controlla l'integrità del blocco stesso. |
-| `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **Meccanismo di compensazione per il rollback canonico.** Segnala ogni elemento nel corpus la cui *base di ricerca* cita `<id>` come `evidenza ritirata` (un file "tombstone" associato `<slug>.withdrawn.json" — segnala, non eliminare mai) ed emette una ricevuta di ritiro basata sul contenuto. `--reason` ∈ `fabbricato · attribuito erroneamente · ritrattato · verificatore modificato · altro`. |
-| `study-swarm requalify --check <corpus-dir>` | In caso di errore, interrompe l'esecuzione (esce con codice `1`) per qualsiasi elemento che contenga un flag `evidenza ritirata` non risolto: questo è il segnale che **interrompe** le dipendenze di una scoperta ritirata fino a quando non viene rimossa o rielaborata. Attiva il CI. |
-| `study-swarm requalify --resolve <dispatch> <id> --mode removed\ | regrounded [--note …]` | Cancella un flag una volta che la scoperta è stata rimossa (la citazione non è più presente) o rielaborata (riverificata e convalidata dal processo parallelo; `--note` registra l'attestazione). È idempotente; aggiunge al registro di controllo del file associato. |
+| `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **Meccanismo di compensazione per il rollback.** Contrassegna ogni documento nel corpus in cui la sezione *Research grounding* (attendibilità delle fonti) cita `<id>` come `evidence-withdrawn` (un file "tombstone" aggiuntivo `<slug>.withdrawn.json": contrassegna, ma non elimina) e genera una ricevuta di rimozione basata sul contenuto. `--reason` ∈ `fabricated · misattributed · retracted · verifier-flipped · other`. |
+| `study-swarm requalify --check <corpus-dir>` | In caso di errori, il processo termina con codice `1` per qualsiasi documento che contenga un flag `evidence-withdrawn` non risolto: questo è l'indicatore (andon) che **interrompe** i processi dipendenti da un'affermazione rimossa fino a quando questa non viene eliminata o rielaborata. Interrompe il processo CI. |
+| `study-swarm requalify --status <corpus-dir> [--json]` | Visualizza in sola lettura lo stato di attendibilità delle fonti del corpus: numero di documenti rimossi rispetto a quelli risolti, suddivisione per motivo e modalità di risoluzione, informazioni per ogni documento. Informazioni generali (il processo termina con codice `0`), a differenza dell'opzione `--check`. |
+| `study-swarm requalify --resolve <dispatch> <id> --mode removed\|regrounded [--note …]` | Rimuove il flag una volta che l'affermazione è stata eliminata (la citazione non esiste più) o rielaborata (verificata nuovamente dal processo parallelo; `--note` registra la conferma). L'operazione può essere eseguita più volte; aggiunge informazioni al registro di controllo del file aggiuntivo. |
 `lint` è deterministico: non effettua chiamate al modello, quindi è sicuro da utilizzare nell'integrazione continua (CI). Applica **lo standard di riferimento del passaggio 3** a livello locale; la verifica basata sul modello del **passaggio 4** si basa ancora su [`roleos verify-citations`](https://github.com/mcp-tool-shop-org/role-os) → prism.
@@ -93,7 +96,7 @@ study-swarm lint my-decision.dispatch.md         # enforce the sourcing standard
 roleos verify-citations my-decision.dispatch.md  # model-based Step 4 (different family, via prism)
 ```
-Quattro elementi completi, puliti e funzionanti vengono pubblicati come riferimento: [`examples/study-swarm-self.dispatch.md`](examples/study-swarm-self.dispatch.md) (la decisione centrale del protocollo, in forma compatta), [`examples/study-swarm-v1_1.dispatch.md`](examples/study-swarm-v1_1.dispatch.md) (il design completo della versione 1.1 — 27 citazioni, tutte verificate esternamente), [`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md) (il design del blocco della versione 1.2 — 39 citazioni, gestito tramite il processo parallelo e il primo elemento a pubblicare il proprio blocco) e [`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md) (il design del rollback canonico della versione 1.3 — 27 citazioni relative alla revoca, al ritiro, alle sequenze di eventi e all'invalidazione della build, ed è il primo elemento ad essere ritirato e quindi riqualificato).
+Quattro documenti completi e validati vengono utilizzati come riferimento: [`examples/study-swarm-self.dispatch.md`](examples/study-swarm-self.dispatch.md) (la decisione centrale del protocollo, in forma compatta), [`examples/study-swarm-v1_1.dispatch.md`](examples/study-swarm-v1_1.dispatch.md) (l'implementazione completa della versione 1.1: 27 citazioni, tutte verificate esternamente), [`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md) (il design della versione 1.2 con il meccanismo di blocco: 39 citazioni, gestite tramite il processo parallelo, ed è il primo documento a includere il proprio meccanismo di blocco) e [`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md) (il design della versione 1.3 con il meccanismo di rollback: 27 citazioni relative alla revoca, al ritiro, alle sequenze di eventi e all'invalidazione della build, ed è il primo documento ad essere rimosso e poi riqualificato).
 ### Bloccalo nell'integrazione continua (CI)
@@ -104,7 +107,7 @@ Quattro elementi completi, puliti e funzionanti vengono pubblicati come riferime
 name: study-swarm lint
 on:
   pull_request:
-    paths: ['**/*.dispatch.md', '.github/workflows/dispatches.yml']
+    paths: ['**/*.dispatch.md', '**/*.withdrawn.json', '.github/workflows/dispatches.yml']
   workflow_dispatch:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -112,22 +115,26 @@ concurrency:
 jobs:
   lint:
     runs-on: ubuntu-latest
+    timeout-minutes: 5
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with: { node-version: '20' }
-      - run: npx @dogfood-lab/study-swarm@latest lint dispatches/
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 lint dispatches/
+      # Halt the build while any finding that became canon is withdrawn and not yet
+      # removed or re-grounded — the canon-rollback andon (exit 1 on any unresolved flag).
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 requalify --check dispatches/
 ```
 ### Blocca un sistema per la riproduzione (`dispatch.lock.json`)
-Un sistema fondato e verificato è auditabile solo se si può dire *cosa lo ha prodotto*. `study-swarm lock` scrive un file di blocco complementare che, per ogni agente di ricerca, include l'**ID del modello risolto** (mai un alias fluttuante), l'**SHA-256 del prompt esatto in byte** e l'**SHA-256 dello schema dello strumento** fornito, oltre alla **ricevuta del verificatore esterno**, tutto racchiuso in un unico `lock_sha256`. `study-swarm lock --verify` ricalcola questi hash e fallisce se rileva discrepanze, quindi una modifica al prompt, uno scambio di modello o una variazione della superficie dello strumento vengono rilevati: lo standard di riproducibilità [PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm), reso eseguibile. Il sistema emette il record; l'interfaccia a riga di comando rimane senza dipendenze e indipendente dalla rete, limitandosi alla normalizzazione (RFC 8785), all'hashing e alla convalida.
+Un sistema fondato e verificato è auditabile solo se si può dire *cosa lo ha prodotto*. `study-swarm lock` scrive un file di blocco complementare che, per ogni agente di ricerca, include l'**ID del modello risolto** (mai un alias fluttuante), l'**SHA-256 del prompt normalizzato (BOM rimosso, a capo in LF, NFC)** e l'**SHA-256 dello schema dello strumento** fornito, oltre alla **ricevuta del verificatore esterno**, tutto racchiuso in un unico `lock_sha256`. `study-swarm lock --verify` ricalcola questi hash e fallisce se rileva discrepanze, quindi una modifica al prompt, uno scambio di modello o una variazione della superficie dello strumento vengono rilevati: lo standard di riproducibilità [PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm), reso eseguibile. Il sistema emette il record; l'interfaccia a riga di comando rimane senza dipendenze e indipendente dalla rete, limitandosi alla normalizzazione (RFC 8785), all'hashing e alla convalida.
 **Blocca gli input, non gli output.** Bloccare il modello + prompt + temperatura *non* rende l'output di un LLM identico bit per bit: l'invarianza del batch, la non associatività dei numeri in virgola mobile, il routing a esperti multipli e la deriva silenziosa del provider sono tutti elementi al di fuori del controllo di uno strumento offline. Pertanto, il blocco fornisce **input riproducibili e output con rilevamento della deriva**, mai una "riproduzione deterministica". Il progetto è basato su evidenze, citazione per citazione, in [`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md) — la prima implementazione che include il proprio blocco ([`examples/study-swarm-lock.lock.json`](examples/study-swarm-lock.lock.json)).
-### Esegue il rollback di una scoperta ritirata (`withdraw` / `requalify`)
+### Esegue il rollback di un'affermazione rimossa (`withdraw` / `requalify`)
-Una scoperta verificata diventa **canonica**: fornisce informazioni per una decisione successiva. Quindi, cosa succede quando viene successivamente **ritirata** (una citazione si rivela fabbricata o attribuita erroneamente durante una nuova esecuzione, un documento citato viene ritrattato o il meccanismo di controllo la modifica)? Un `git revert` non è sufficiente, perché la scoperta è già stata propagata. Il meccanismo di compensazione per il rollback canonico rende possibile l'esecuzione della correzione:
+Un'affermazione verificata diventa **canonica**: fornisce informazioni per una decisione successiva. Quindi, cosa succede quando viene successivamente **rimossa** (una citazione si rivela falsa/errata durante una nuova esecuzione, un articolo citato viene ritirato o il meccanismo di controllo la contrassegna)? Un comando `git revert` non è sufficiente, perché l'affermazione è già stata propagata. Il meccanismo di compensazione per il rollback rende possibile questa operazione:
 ```bash
 study-swarm withdraw arXiv:2402.15089 --reason misattributed --from dispatches/ --receipt rollback.json
@@ -137,7 +144,7 @@ study-swarm requalify --check dispatches/          # exit 1 while any flag is un
 study-swarm requalify --resolve d.dispatch.md arXiv:2402.15089 --mode removed   # or: --mode regrounded --note "<attestation>"
 ```
-`requalify --check` **interrompe l'esecuzione** fino a quando ogni scoperta contrassegnata non viene rimossa o **rielaborata** (riverificata e convalidata dal processo parallelo; la CLI registra l'attestazione, ma non esegue essa stessa una nuova verifica). Il ritiro viene evidenziato in modo **contraddittorio**, mai come un semplice annullamento silenzioso. Tutto — il file "tombstone" e la ricevuta — è basato sul contenuto ed è rilevabile nel tempo, e opera solo sullo strato di *evidenza*: `lock --verify` non viene influenzato da un ritiro. Il design si basa su [`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md), e il [PROTOCOL.md](PROTOCOL.md) §"Compensating a withdrawn finding" rappresenta la forma eseguibile. Questo è lo standard **NAMED_COMPENSATORS** reso eseguibile: un'operazione di annullamento denominata e idempotente che lascia uno stato post-operazione noto e una ricevuta.
+`requalify --check` **termina con errore** finché ogni affermazione contrassegnata non viene rimossa o **rielaborata** (verificata nuovamente dal processo parallelo; la CLI registra la conferma, ma non esegue essa stessa la verifica). La rimozione viene evidenziata in modo **contraddittorio**, e non semplicemente eliminando l'elemento. Tutto (il file "tombstone" e la ricevuta) è basato sul contenuto ed è rilevabile nel tempo, e opera solo sullo strato delle *fonti*: `lock --verify` non viene influenzato dalla rimozione. Il design si basa su [`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md), e il documento [PROTOCOL.md](PROTOCOL.md) §"Compensating a withdrawn finding" rappresenta l'implementazione pratica. Questo è lo standard **NAMED_COMPENSATORS** reso eseguibile: un meccanismo di annullamento denominato e idempotente che lascia uno stato finale noto e una ricevuta.
 ## Perché funziona, in sintesi:
@@ -145,11 +152,11 @@ study-swarm requalify --resolve d.dispatch.md arXiv:2402.15089 --mode removed
 ## Sicurezza
-`study-swarm` include una **CLI leggera, senza dipendenze** (`study-swarm`) insieme alla metodologia. Non effettua **nessuna chiamata di rete o al modello** e non raccoglie **dati di telemetria**; non ci sono segreti o credenziali nel codice sorgente. In fase di esecuzione legge solo il file che si passa a `lint` e scrive un singolo file `<slug>.dispatch.md` nella directory corrente per `new` (rifiutando di sovrascriverlo e operando sempre all'interno della directory di lavoro). La verifica basata sul modello descritta dalla metodologia (Passaggio 4) viene eseguita dagli strumenti correlati, non da questo pacchetto. Vedere [SECURITY.md](SECURITY.md).
+`study-swarm` include una **CLI leggera, senza dipendenze** (`study-swarm`) insieme alla metodologia. Non effettua **nessuna chiamata di rete o al modello** e non raccoglie **dati di telemetria**; non ci sono segreti o credenziali nel codice sorgente. In fase di esecuzione legge i file che nomini. `new` scrive un solo `<slug>.dispatch.md` nella directory di lavoro (senza sovrascrivere e senza uscirne). `lock`, `withdraw` e `requalify` scrivono anche un lock, un sidecar tombstone e, con `--receipt`, una ricevuta nel percorso indicato. La verifica basata sul modello descritta dalla metodologia (Passaggio 4) viene eseguita dagli strumenti correlati, non da questo pacchetto. Vedere [SECURITY.md](SECURITY.md).
 ## Stato
-Un protocollo funzionante, verificato esternamente dai propri meccanismi: una famiglia diversa di modelli verifica le sue citazioni (vedere la prova sopra). La **versione 1.1** affina il verificatore rispetto alla prima versione, che era silenziosa: base di ricerca scomposta/ternaria, base di ricerca al momento della generazione, cascata controllata da un oracolo per combinare le diverse prospettive e astensione calibrata — ciascuna basata sulla scoperta verificata della versione 1.1. La **versione 1.2** rende un elemento riproducibile: `study-swarm lock` fissa il modello, il prompt e lo schema degli strumenti risolti per ogni passaggio, oltre alla ricevuta del verificatore, e `lock --verify` interrompe l'esecuzione in caso di modifiche. La **versione 1.3** rende eseguibile il rollback: quando una scoperta che è già diventata canonica viene ritirata, `study-swarm withdraw` contrassegna tutte le dipendenze e `requalify --check` le interrompe, bloccandole fino a quando non vengono rimosse o rielaborate — un meccanismo di compensazione denominato, con ricevuta e idempotente. Questo repository è il riferimento pubblico; [PROTOCOL.md](PROTOCOL.md) rappresenta la forma eseguibile. Fa parte della famiglia [dogfood-lab](https://github.com/dogfood-lab): metodi ed esempi per lo sviluppo nell'era dell'IA.
+Un protocollo funzionante, verificato esternamente dai suoi stessi strumenti: una famiglia diversa di modelli verifica le sue citazioni (vedi la prova sopra). La **versione 1.1** migliora il meccanismo di verifica rispetto alla prima versione, che era silenziosa: attendibilità delle fonti decomposta/ternaria, verifica al momento della generazione, una cascata controllata da un oracolo per combinare le diverse prospettive e astensione calibrata: ogni elemento è basato sull'affermazione verificata nella versione 1.1. La **versione 1.2** rende un documento riproducibile: `study-swarm lock` memorizza il modello, il prompt e lo schema degli strumenti risolti per ogni passaggio, oltre alla ricevuta del meccanismo di verifica, e `lock --verify` termina con errore in caso di modifiche non autorizzate. La **versione 1.3** rende eseguibile il rollback: quando un'affermazione che è già diventata canonica viene rimossa, `study-swarm withdraw` contrassegna tutti gli elementi dipendenti e `requalify --check` li interrompe, terminando con errore finché non vengono rimossi o rielaborati: un meccanismo di compensazione denominato, dotato di ricevuta e idempotente. La **versione 2.0** rende più parti del protocollo eseguibili e rafforza il meccanismo di blocco: `lint --strict` contrassegna le citazioni orfane (l'unico tipo di errore che la CLI non riusciva a rilevare), `lock --init` crea il modello di configurazione, `requalify --status` legge lo stato delle fonti del corpus e l'indirizzamento basato sul contenuto del blocco è separato per dominio (schema degli artefatti versione 2: un blocco da una versione precedente viene rigenerato anziché essere contrassegnato erroneamente come manomesso; la superficie dei comandi della CLI rimane compatibile con le versioni precedenti). Questo repository è il riferimento pubblico; [PROTOCOL.md](PROTOCOL.md) rappresenta l'implementazione pratica. Fa parte della famiglia [dogfood-lab](https://github.com/dogfood-lab): metodi e esempi per lo sviluppo nell'era dell'intelligenza artificiale.
 Con licenza MIT.

package/README.ja.md CHANGED Viewed

@@ -23,8 +23,8 @@
 1. **特定する：** 実証的な証拠によって回答が変わる可能性のある、3〜5個の重要な設計上の質問を特定する。
 2. **派遣する：** 各質問に対して、並行して1つの研究エージェントを派遣する。各エージェントは、論文タイトル＋著者＋年＋URL＋一文の調査結果を返す必要がある（広範囲よりも具体性重視。「6〜8件の信頼できる調査結果が、20件の曖昧な情報よりも優れている」）。
-3. **統合する：** 調査結果を「研究による根拠」セクションに統合する：「N.**<調査結果>。<著者><年>(<arXiv/DOI>)。<設計への影響>。」
-4. **外部で検証する：** *別のモデルファミリー*（推論機能を削除したもの）を使用して、すべての引用を2つの段階でチェックする。まず、**検索オラクル**が論文が存在することを確認する（モデルの記憶ではなく）。次に、「根拠」レンズが、調査結果が情報源と一致することを確認する。**捏造または誤った帰属の場合、処理を停止する。検証者または検索オラクルが利用できない場合は、処理を停止してエスカレーションする（不在を「引用は問題ない」と解釈しないこと）。
+3. **統合する：** 調査結果を「Research grounding」（研究による根拠）セクションに統合する：「N.**<調査結果>。<著者><年>(<arXiv/DOI>)。<設計への影響>。」
+4. **外部で検証する：** *別のモデルファミリー*（推論機能を削除したもの）を使用して、すべての引用を2つの段階でチェックする。まず、**検索オラクル**が論文が存在することを確認する（モデルの記憶ではなく）。次に、「根拠」レンズが、調査結果が情報源と一致することを確認する。捏造された知見は**捨てる**。誤帰属は**一度だけ直し**、再検証する（二度目の不合格で捨てる）。検証者または検索オラクルが使えないときだけ**停止してエスカレーションする**（不在を「引用は問題ない」と解釈しない）。
 5. **関連付ける：** 各アーキテクチャの選択を、番号を使って調査結果に関連付ける。設計への影響がない引用はノイズである。
 完全な実行可能な詳細（停止テーブル、情報源に関する標準、アンサンブルルール）は、**[PROTOCOL.md](PROTOCOL.md)**に記載されている。
@@ -75,12 +75,15 @@ npm i -g @dogfood-lab/study-swarm     # or run ad-hoc: npx @dogfood-lab/study-sw
 |---|---|
 | `study-swarm protocol` | 完全なプロトコル（5つのステップ、停止テーブル、ソース標準）を出力します。 |
 | `study-swarm new <slug>` | 5つのステップのスケルトンを含む`<slug>.dispatch.md`を作成し、それを埋めるためのテンプレートを提供します。 |
-| `study-swarm lint [--json] <path…>` | ディスパッチの*研究根拠*をソース標準と比較してチェックします。すべての発見には、著者、年、および解決可能な識別子（arXiv / DOI / URL）が必要です。「研究によると…」という曖昧な表現は拒否されます。違反があった場合、終了コード`1`を返し、CIでゲートとして機能します。`<path>`はファイル、ディレクトリ（`.dispatch.md`ファイルを再帰的にlint）、または`-`（標準入力）のいずれかになります。`--json`オプションを使用すると、機械可読形式のレポートが出力されます。 |
-| `study-swarm lock <dispatch> --from <orchestration.json>` | ディスパッチをリプレイ用に固定します。`<dispatch>.lock.json`ファイルに、ステップ2のエージェントごとに、**解決されたモデルID** + **正確なバイト単位のプロンプトのSHA-256ハッシュ** + **ツールスキーマのSHA-256ハッシュ**、およびステップ4の**検証レシート**をまとめて書き込みます。これらを1つの`lock_sha256`にまとめます。 |
+| `study-swarm lint [--json] [--strict] <path…>` | ディスパッチの「Research grounding」（研究根拠）を、ソースの標準と比較して確認します。すべての調査結果には、著者、年、および解決可能な識別子（arXiv / DOI / URL / RFC）が必要です。「研究では～と示されています…」という曖昧な表現は認められません。違反があった場合は `1` を返して処理を停止し、CI のゲートとして機能します。`<path>` は、ファイル、ディレクトリ（`*.dispatch.md` に対して再帰的にチェックされます）、または標準入力 (`-`) にすることができます。`--json` オプションを使用すると、機械可読のレポートが出力されます。`--strict` オプションを追加すると、**孤立した引用**（Step 5 のいずれかの選択肢で参照されていない調査結果）がフラグ付けされます。「関連性のない引用はノイズである」ためです（オプションであり、デフォルトの CI ゲートは変更されません）。 |
+| `study-swarm return <dispatch> [--check]` | 結果を書き出します。`<stem>.results.md` は渡すシート、`<stem>.results.json` は同じ内容を dispatch の横に残す記録です。`--check` はどちらかが dispatch からずれると失敗します。 |
+| `study-swarm lock --init <dispatch>` | `<dispatch>.orchestration.json` を作成します。これは、`lock … --from` に渡すための、穴埋め形式のハーネスレコードです（Step-2 のエージェントごとに1つのステップ）。 |
+| `study-swarm lock <dispatch> --from <orchestration.json>` | ディスパッチをリプレイ用に固定します。`<dispatch>.lock.json`ファイルに、ステップ2のエージェントごとに、**解決されたモデルID** + **テキスト正規化したプロンプトのSHA-256（BOM除去、改行をLF、NFC）** + **ツールスキーマのSHA-256ハッシュ**、およびステップ4の**検証レシート**をまとめて書き込みます。これらを1つの`lock_sha256`にまとめます。 |
 | `study-swarm lock --verify <dispatch> [--from …]` | これらのハッシュを再計算し、ロックファイルと一致することを確認します。いずれかのハッシュが異なる場合、終了コード`1`を返し、CIでゲートとして機能します（パッケージのロックファイルと同様）。`--from`オプションがない場合は、ロックファイルの整合性をチェックします。 |
-| `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **正準ロールバック補償機能。** コーパス内のすべてのディスパッチについて、*調査根拠*が`<id>`を`証拠の撤回`として引用している場合にフラグを設定します（墓石サイドカー`<slug>.withdrawn.json`—フラグを設定し、削除は行わない）。また、コンテンツアドレス指定された撤回レシートを出力します。`--reason` ∈ `fabricated · misattributed · retracted · verifier-flipped · other`。 |
-| `study-swarm requalify --check <corpus-dir>` | 未解決の`証拠の撤回`フラグを持つすべてのディスパッチに対して、処理を停止（終了コード`1`で終了）します。これは、撤回された調査結果に依存する要素が削除または再検証されるまで、その処理を一時停止させるための仕組みです。CIゲートとして機能します。 |
-| `study-swarm requalify --resolve <dispatch> <id> --mode removed\ | regrounded [--note …]` | 調査結果が削除されたとき（引用がなくなったとき）または再検証されたときに、フラグをクリアします（兄弟ランナーによって再検証され、問題がないことが確認されます。`--note`にはその証拠が記録されます）。べき等性があり、サイドカーの監査ログに追加されます。 |
+| `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **カノンロールバック補正器**。コーパス内のすべてのディスパッチについて、「Research grounding」（研究根拠）で `<id>` を引用しているものを `evidence-withdrawn` としてフラグ付けします（墓石のようなサイドカーファイル `<slug>.withdrawn.json` で、フラグを立てますが削除はしません）。また、コンテンツアドレス指定された取り下げレシートを出力します。`--reason` は `fabricated · misattributed · retracted · verifier-flipped · other` のいずれかです。 |
+| `study-swarm requalify --check <corpus-dir>` | 未解決の `evidence-withdrawn` フラグを持つディスパッチがある場合、処理を停止してエラー (`1`) を返します。これは、取り下げられた調査結果に依存するものを、削除または再検証されるまで停止させるための「アンドン」です。CI のゲートとしても機能します。 |
+| `study-swarm requalify --status <corpus-dir> [--json]` | コーパスの読み取り専用の証拠健全性**ビュー**を提供します。取り下げられたものと解決されたものの数、理由および解決モードごとの内訳、ディスパッチごとの行を表示します。これは情報提供のみを目的としており（`0` を返します）、`--check` ゲートとは異なります。 |
+| `study-swarm requalify --resolve <dispatch> <id> --mode removed\|regrounded [--note …]` | 調査結果が削除されたとき（引用がなくなったとき）または再検証されたときに、フラグをクリアします（兄弟ランナーによって再度検証され、問題がないことが確認されます。`--note` には証拠が記録されます）。べき等であり、サイドカーの監査ログに追加されます。 |
 `lint`は決定論的であり、モデル呼び出しはゼロであるため、CIでの使用に安全です。ローカルで**ステップ3のソース標準**を適用し、モデルベースの**ステップ4**検証は引き続き[`roleos verify-citations`](https://github.com/mcp-tool-shop-org/role-os) → prismに委ねます。
@@ -93,7 +96,7 @@ study-swarm lint my-decision.dispatch.md         # enforce the sourcing standard
 roleos verify-citations my-decision.dispatch.md  # model-based Step 4 (different family, via prism)
 ```
-4つの完全で、lintチェックに合格したディスパッチをリファレンスとして公開します：[`examples/study-swarm-self.dispatch.md`](examples/study-swarm-self.dispatch.md)（プロトコルの中心的な決定事項、コンパクト）、[`examples/study-swarm-v1_1.dispatch.md`](examples/study-swarm-v1_1.dispatch.md)（完全なv1.1設計パス—27件の引用。すべて外部で検証済み）、[`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md)（v1.2ロック設計—39件の引用、ランナーを通じてゲート処理され、独自のロックを公開する最初のディスパッチ）、および[`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md)（v1.3正準ロールバック設計—撤回、取り下げ、サガ、ビルド無効化にわたる27件の引用。また、最初に撤回され、その後再検証されるディスパッチ）。
+4つの完全で、lint チェックに合格したディスパッチを参考として提供します：[`examples/study-swarm-self.dispatch.md`](examples/study-swarm-self.dispatch.md)（プロトコルの中心的な決定であり、コンパクト）、[`examples/study-swarm-v1_1.dispatch.md`](examples/study-swarm-v1_1.dispatch.md)（完全な v1.1 の設計パスであり、27件の引用があり、そのすべてが外部で検証されています）、[`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md)（v1.2 のロック設計であり、39件の引用があり、ランナーを通じてゲートされ、独自のロックを最初に提供するディスパッチです）、および [`examples/study-swarm-canon-rollback.取り消し、撤回、サガ、ビルド無効化など、27件の引用が含まれており、最初に取り下げられてから再検証されるディスパッチです）。
 ### CIでゲートとして使用する
@@ -104,7 +107,7 @@ roleos verify-citations my-decision.dispatch.md  # model-based Step 4 (different
 name: study-swarm lint
 on:
   pull_request:
-    paths: ['**/*.dispatch.md', '.github/workflows/dispatches.yml']
+    paths: ['**/*.dispatch.md', '**/*.withdrawn.json', '.github/workflows/dispatches.yml']
   workflow_dispatch:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -112,22 +115,26 @@ concurrency:
 jobs:
   lint:
     runs-on: ubuntu-latest
+    timeout-minutes: 5
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with: { node-version: '20' }
-      - run: npx @dogfood-lab/study-swarm@latest lint dispatches/
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 lint dispatches/
+      # Halt the build while any finding that became canon is withdrawn and not yet
+      # removed or re-grounded — the canon-rollback andon (exit 1 on any unresolved flag).
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 requalify --check dispatches/
 ```
 ### ディスパッチをリプレイ用に固定する（`dispatch.lock.json`）
-根拠があり、検証されたディスパッチは、それがどのように生成されたかを説明できれば、監査可能になります。`study-swarm lock`は、コンパニオンのロックファイルを書き込みます。このファイルには、研究エージェントごとに、**解決されたモデルID**（浮動するエイリアスではありません）、**正確なバイト単位のプロンプトのSHA-256ハッシュ**、および与えられた**ツールスキーマのSHA-256ハッシュ**、さらに外部の**検証レシート**が記録されます。これらはすべて1つの`lock_sha256`にまとめられます。`study-swarm lock --verify`は、これらのハッシュを再計算し、いずれかのハッシュが異なる場合、エラーを表示します。したがって、プロンプトが変更されたり、モデルが切り替えられたり、ツールのバージョンが変更されたりすると、検知されます。[PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm)再現性標準を実際に実行できます。この処理は、レコードを出力し、CLIはゼロ依存でネットワークにアクセスする必要がなく、単に正規化（RFC 8785）、ハッシュ化、および検証を行います。
+根拠があり、検証されたディスパッチは、それがどのように生成されたかを説明できれば、監査可能になります。`study-swarm lock`は、コンパニオンのロックファイルを書き込みます。このファイルには、研究エージェントごとに、**解決されたモデルID**（浮動するエイリアスではありません）、**テキスト正規化したプロンプトのSHA-256（BOM除去、改行をLF、NFC）**、および与えられた**ツールスキーマのSHA-256ハッシュ**、さらに外部の**検証レシート**が記録されます。これらはすべて1つの`lock_sha256`にまとめられます。`study-swarm lock --verify`は、これらのハッシュを再計算し、いずれかのハッシュが異なる場合、エラーを表示します。したがって、プロンプトが変更されたり、モデルが切り替えられたり、ツールのバージョンが変更されたりすると、検知されます。[PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm)再現性標準を実際に実行できます。この処理は、レコードを出力し、CLIはゼロ依存でネットワークにアクセスする必要がなく、単に正規化（RFC 8785）、ハッシュ化、および検証を行います。
 **入力は固定し、出力は固定しません。** モデル、プロンプト、温度を固定しても、LLMの出力が完全に同一になるわけではありません。バッチ不変性、浮動小数点演算の非結合性、混合エキスパートルーティング、およびサイレントプロバイダドリフトなど、オフラインツールで制御できない要素が存在するためです。したがって、この仕組みは、**再現可能な入力とドリフトを検出可能な出力を提供し、「決定的な再現」を実現するものではありません。** この設計は、[`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md) に記載されているように、個々の要素に基づいて構築されており、独自のロック機能を備えた最初のバージョン ([`examples/study-swarm-lock.lock.json`](examples/study-swarm-lock.lock.json)) として提供されます。
-### 撤回された調査結果をロールバックします（`withdraw`/`requalify`）
+### 取り下げられた調査結果をロールバックします（`withdraw` / `requalify`）
-検証済みの調査結果は**正準**となります。これは、後続の意思決定に影響を与えます。したがって、後で**撤回**された場合（再実行時に引用が捏造または誤って帰属されていることが判明した場合、引用された論文が取り下げられた場合、またはゲートがそれを却下した場合）どうなるでしょうか？`git revert`だけでは不十分です。なぜなら、調査結果はすでに伝播しているからです。正準ロールバック補償機能により、クリーンアップを実行できるようになります。
+検証された調査結果は**カノン**になります。これは、後続の決定に影響を与えます。では、後で**取り下げられた**場合（再実行時に引用が捏造または誤って帰属されていることが判明した場合、引用された論文が撤回された場合、またはゲートがそれを反転させた場合）はどうなるでしょうか？ `git revert` だけでは不十分です。なぜなら、調査結果はすでに伝播しているからです。カノンロールバック補正器を使用すると、クリーンアップを確実に実行できます。
 ```bash
 study-swarm withdraw arXiv:2402.15089 --reason misattributed --from dispatches/ --receipt rollback.json
@@ -137,7 +144,7 @@ study-swarm requalify --check dispatches/          # exit 1 while any flag is un
 study-swarm requalify --resolve d.dispatch.md arXiv:2402.15089 --mode removed   # or: --mode regrounded --note "<attestation>"
 ```
-`requalify --check`は、フラグが設定されたすべての調査結果が削除または**再検証**されるまで、処理を停止します（兄弟ランナーによって再検証され、問題がないことが確認されます。CLIは証拠を記録しますが、それ自体で再検証は行いません）。撤回は**対照的**に表示され、サイレントな削除とはなりません。すべて—墓石とレシート—はコンテンツアドレス指定されており、ドリフト検出が可能であり、*証拠*レイヤーでのみ動作します：`lock --verify`は撤回によって影響を受けません。この設計は[`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md)に基づいており、[PROTOCOL.md](PROTOCOL.md)の§「撤回された調査結果を補償する」が実行可能な形式です。これは、**NAMED_COMPENSATORS**標準を実行可能にしたものです：名前付きでべき等なアンドゥ処理であり、既知のポスト状態とレシートを残します。
+`requalify --check` は、フラグが立てられたすべての調査結果が削除されるか、**再検証されるまで**（兄弟ランナーによって再度検証され、問題がないことが確認されます。CLI は証拠を記録しますが、それ自体で再検証は行いません）、**処理を停止してエラーを返します**。取り下げは、静かにドロップするのではなく、**対照的に**表示されます。すべて（墓石とレシート）がコンテンツアドレス指定され、ドリフト検出が可能であり、*証拠* レイヤーでのみ動作します：`lock --verify` は取り消しによって影響を受けません。この設計は [`examples/study-swarm-canon-rollback.dispatch.md`](examples/study-swarm-canon-rollback.dispatch.md) に基づいており、[PROTOCOL.md](PROTOCOL.md) の「Compensating a withdrawn finding」セクションが実行可能な形式です。これは、**NAMED_COMPENSATORS** 標準を実行可能にしたものです。名前付きでべき等なアンドゥ操作であり、既知のポスト状態とレシートを残します。
 ## その仕組みを簡潔に説明します
@@ -145,11 +152,11 @@ study-swarm requalify --resolve d.dispatch.md arXiv:2402.15089 --mode removed
 ## セキュリティ
-`study-swarm` は、この手法とともに、**軽量で依存関係のないCLI（コマンドラインインターフェース）** (`study-swarm`) を提供します。**ネットワーク接続やモデルへのアクセスは行わず、テレメトリデータも収集しません。** ソースコードには、秘密情報や認証情報は含まれていません。実行時には、`lint` に渡されたファイルのみを読み取り、現在のディレクトリに `<slug>.dispatch.md` という名前のファイルを1つだけ書き込みます（上書きは行わず、作業ディレクトリ外への書き込みも行いません）。この手法で説明されているモデルベースの検証（ステップ4）は、このパッケージではなく、関連するツールによって実行されます。詳細は [SECURITY.md](SECURITY.md) を参照してください。
+`study-swarm` は、この手法とともに、**軽量で依存関係のないCLI（コマンドラインインターフェース）** (`study-swarm`) を提供します。**ネットワーク接続やモデルへのアクセスは行わず、テレメトリデータも収集しません。** ソースコードには、秘密情報や認証情報は含まれていません。実行時には、指定したファイルを読み取ります。`new` は作業ディレクトリに `<slug>.dispatch.md` を1つだけ書き込みます（上書きせず、ディレクトリの外にも書きません）。`lock`、`withdraw`、`requalify` は lock ファイルと墓標 sidecar も書き、`--receipt` を渡すとそのパスにレシートを書きます。この手法で説明されているモデルベースの検証（ステップ4）は、このパッケージではなく、関連するツールによって実行されます。詳細は [SECURITY.md](SECURITY.md) を参照してください。
 ## ステータス
-独自のメカニズムによって外部検証された、動作するプロトコル—別のモデルファミリーがその引用をチェックします（上記の証拠を参照）。**v1.1**は、最初のリリースではサイレントだった検証機能を強化しました：分解/三値の根拠付け、生成時の根拠付け、レンズを組み合わせるためのオラクルゲート付きカスケード、および調整された棄権—それぞれが検証済みのv1.1ディスパッチに基づいて行われます。**v1.2**は、ディスパッチをバイト単位で再現可能にします：`study-swarm lock`は、各ステップと検証レシートごとに解決されたモデル、プロンプト、およびツールスキーマを固定し、`lock --verify`はドリフトが発生した場合に処理を停止します。**v1.3**は、ロールバックを実行可能にします：すでに正準となった調査結果が撤回されると、`study-swarm withdraw`はすべての依存関係にフラグを設定し、`requalify --check`はそれらを削除または再検証されるまで処理を停止します—名前付きで、レシート付きの、べき等な補償機能です。このリポジトリは公開リファレンスであり、[PROTOCOL.md](PROTOCOL.md)が実行可能な形式です。[dogfood-lab](https://github.com/dogfood-lab)ファミリーの一部であり、AI時代におけるビルドのための方法とショーケースを提供します。
+独自のメカニズムによって外部検証された動作するプロトコルです。別のモデルファミリーがその引用をチェックします（上記の証拠を参照）。**v1.1** では、最初のリリースでは静的だった検証器が強化されています：分解/三値の根拠付け、生成時の根拠付け、レンズを組み合わせるためのオラクルゲート付きカスケード、および調整された棄権。これらはすべて、検証済みの v1.1 ディスパッチに基づいています。**v1.2** では、ディスパッチがバイト単位で再現可能になります：`study-swarm lock` は、ステップごとの解決済みモデル、プロンプト、ツールスキーマと、検証器レシートを固定します。また、`lock --verify` はドリフトが発生すると処理を停止してエラーを返します。**v1.3** では、ロールバックを実行可能にします：すでにカノンになった調査結果が取り下げられた場合、`study-swarm withdraw` はすべての依存関係にフラグを立て、`requalify --check` はそれらを削除または再検証されるまで処理を停止してエラーを返します。これは、名前付きでレシート付きのべき等な補正器です。**v2.0** では、プロトコルのより多くの部分を実行可能にし、ロックを強化します：`lint --strict` は孤立した引用にフラグを立てます（CLI が検出できなかった唯一の失敗モード）、`lock --init` はハーネスレコードを作成し、`requalify --status` はコーパスの証拠健全性を読み取り、ロックのコンテンツアドレス指定はドメインで分離されます（アーティファクトスキーマ v2。以前のバージョンのロックは再生成され、改ざんされたと誤ってフラグが立てられることはありません。CLI のコマンドサーフェスは後方互換性を維持します）。このリポジトリは公開参照であり、[PROTOCOL.md](PROTOCOL.md) が実行可能な形式です。これは、[dogfood-lab](https://github.com/dogfood-lab) ファミリーの一部であり、AI 時代に構築するための方法とデモンストレーションを提供します。
 MITライセンス。

package/README.md CHANGED Viewed

@@ -24,7 +24,7 @@ It applies its own medicine. The protocol prescribes verifier-protected envelope
 1. **Identify** 3–5 load-bearing design questions where empirical evidence would change the answer.
 2. **Dispatch** one research agent per question, in parallel. Each must return paper titles + authors + years + URLs + a one-sentence finding — specificity over breadth ("6–8 well-sourced findings beat 20 vague gestures").
 3. **Synthesize** the findings into a *Research grounding* section: `N. **<finding>.** <Authors> <year> (<arXiv/DOI>). <design implication>.`
-4. **Verify externally** — a *different model family*, reasoning-stripped, checks every citation in two stages: a **retrieval oracle** confirms the paper exists (never the model's memory), then a **groundedness** lens confirms the finding matches the source. **Halt** on fabricated/misattributed; **halt-and-escalate** if the verifier or retrieval oracle is unavailable (never read absence as "citations fine").
+4. **Verify externally** — a *different model family*, reasoning-stripped, checks every citation in two stages: a **retrieval oracle** confirms the paper exists (never the model's memory), then a **groundedness** lens confirms the finding matches the source. **Drop** a fabricated finding; **correct a misattribution once** and re-verify (a second non-clean verdict drops it). **Halt-and-escalate** only when the verifier or the retrieval oracle is unavailable (never read absence as "citations fine").
 5. **Connect** each architectural choice back to a finding by number. Citations without a design implication are noise.
 The full executable detail — the halt table, the sourcing standard, the ensemble rule — is in **[PROTOCOL.md](PROTOCOL.md)**.
@@ -75,11 +75,14 @@ npm i -g @dogfood-lab/study-swarm     # or run ad-hoc: npx @dogfood-lab/study-sw
 |---|---|
 | `study-swarm protocol` | Print the full protocol — the five steps, the halt table, the sourcing standard. |
 | `study-swarm new <slug>` | Scaffold a `<slug>.dispatch.md` with the five-step skeleton to fill in. |
-| `study-swarm lint [--json] <path…>` | Check a dispatch's *Research grounding* against the sourcing standard — every finding needs an author, a year, and a resolvable identifier (arXiv / DOI / URL); "studies show…" hand-waving is rejected. Exit `1` on violations, so it gates CI. A `<path>` may be a file, a directory (linted recursively for `*.dispatch.md`), or `-` for stdin; `--json` emits a machine-readable report. |
-| `study-swarm lock <dispatch> --from <orchestration.json>` | Pin a dispatch for replay — write `<dispatch>.lock.json` content-addressing, per Step-2 agent, the **resolved model id** + the **SHA-256 of the byte-exact prompt** + the **SHA-256 of the tool schema**, plus the Step-4 **verifier receipt**, rolled into one `lock_sha256`. |
+| `study-swarm lint [--json] [--strict] <path…>` | Check a dispatch's *Research grounding* against the sourcing standard — every finding needs an author, a year, and a resolvable identifier (arXiv / DOI / URL / RFC); "studies show…" hand-waving is rejected. Exit `1` on violations, so it gates CI. A `<path>` may be a file, a directory (linted recursively for `*.dispatch.md`), or `-` for stdin; `--json` emits a machine-readable report. `--strict` additionally flags **orphan citations** — a finding no Step-5 choice references — since "citations without a connection are noise" (opt-in, so the default CI gate is unchanged). |
+| `study-swarm return <dispatch> [--check]` | Write the results of a dispatch: `<stem>.results.md` is the sheet you hand someone, and `<stem>.results.json` is the same facts kept beside it for the next run to open. `--check` fails if either copy has drifted from the dispatch. |
+| `study-swarm lock --init <dispatch>` | Scaffold `<dispatch>.orchestration.json` — a fill-in-the-blanks harness record (one step per Step-2 agent) to feed to `lock … --from`. |
+| `study-swarm lock <dispatch> --from <orchestration.json>` | Pin a dispatch for replay — write `<dispatch>.lock.json` content-addressing, per Step-2 agent, the **resolved model id** + the **SHA-256 of the text-normalized prompt** (BOM stripped, newlines folded to LF, NFC) + the **SHA-256 of the tool schema**, plus the Step-4 **verifier receipt**, rolled into one `lock_sha256`. |
 | `study-swarm lock --verify <dispatch> [--from …]` | Re-derive those hashes and assert they match the lock; any drift exits `1`, so it gates CI like a package lockfile. Without `--from`, checks the lock's own integrity. |
 | `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **Canon-rollback compensator.** Flag every dispatch in the corpus whose *Research grounding* cites `<id>` as `evidence-withdrawn` (a tombstone sidecar `<slug>.withdrawn.json` — flag, never delete) and emit a content-addressed withdrawal receipt. `--reason` ∈ `fabricated · misattributed · retracted · verifier-flipped · other`. |
 | `study-swarm requalify --check <corpus-dir>` | Fail closed (exit `1`) for any dispatch carrying an unresolved `evidence-withdrawn` flag — the andon that **halts** a withdrawn finding's dependents until it is removed or re-grounded. Gates CI. |
+| `study-swarm requalify --status <corpus-dir> [--json]` | Read-only evidence-health **view** of a corpus — withdrawn vs resolved counts, a breakdown by reason and resolution mode, per-dispatch lines. Informational (exit `0`), unlike the `--check` gate. |
 | `study-swarm requalify --resolve <dispatch> <id> --mode removed\|regrounded [--note …]` | Clear a flag once the finding is removed (the citation is gone) or re-grounded (re-verified clean by the sibling runner; `--note` records the attestation). Idempotent; appends to the sidecar's audit trail. |
 `lint` is deterministic — zero model calls — so it's safe in CI. It enforces **Step 3's sourcing standard** locally; the model-based **Step 4** verification still defers to [`roleos verify-citations`](https://github.com/mcp-tool-shop-org/role-os) → prism.
@@ -104,7 +107,7 @@ Four complete, lint-clean worked dispatches ship as references: [`examples/study
 name: study-swarm lint
 on:
   pull_request:
-    paths: ['**/*.dispatch.md', '.github/workflows/dispatches.yml']
+    paths: ['**/*.dispatch.md', '**/*.withdrawn.json', '.github/workflows/dispatches.yml']
   workflow_dispatch:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -112,16 +115,20 @@ concurrency:
 jobs:
   lint:
     runs-on: ubuntu-latest
+    timeout-minutes: 5
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with: { node-version: '20' }
-      - run: npx @dogfood-lab/study-swarm@latest lint dispatches/
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 lint dispatches/
+      # Halt the build while any finding that became canon is withdrawn and not yet
+      # removed or re-grounded — the canon-rollback andon (exit 1 on any unresolved flag).
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 requalify --check dispatches/
 ```
 ### Pin a dispatch for replay (`dispatch.lock.json`)
-A grounded, verified dispatch is only auditable if you can say *what produced it*. `study-swarm lock` writes a companion lockfile that content-addresses, per research agent, the **resolved model id** (never a floating alias), the **SHA-256 of the byte-exact prompt**, and the **SHA-256 of the tool schema** it was given, plus the external **verifier receipt** — rolled into one `lock_sha256`. `study-swarm lock --verify` re-derives those hashes and fails closed on any drift, so a changed prompt, a swapped model, or a shifted tool surface is caught — the [PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm) reproducibility standard, made executable. The harness emits the record; the CLI stays zero-dependency and network-free, only canonicalizing (RFC 8785), hashing, and validating it.
+A grounded, verified dispatch is only auditable if you can say *what produced it*. `study-swarm lock` writes a companion lockfile that content-addresses, per research agent, the **resolved model id** (never a floating alias), the **SHA-256 of the text-normalized prompt** (BOM stripped, newlines folded to LF, NFC), and the **SHA-256 of the tool schema** it was given, plus the external **verifier receipt** — rolled into one `lock_sha256`. `study-swarm lock --verify` re-derives those hashes and fails closed on any drift, so a changed prompt, a swapped model, or a shifted tool surface is caught — the [PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm) reproducibility standard, made executable. The harness emits the record; the CLI stays zero-dependency and network-free, only canonicalizing (RFC 8785), hashing, and validating it.
 **It pins inputs, not outputs.** Pinning model + prompt + temperature does *not* make an LLM's output bit-identical — batch-invariance, floating-point non-associativity, mixture-of-experts routing, and silent provider drift are all outside an offline tool's control. So the lock gives you **replayable inputs and drift-detectable outputs**, never "deterministic replay." The design is grounded, citation by citation, in [`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md) — the first dispatch to ship its own lock ([`examples/study-swarm-lock.lock.json`](examples/study-swarm-lock.lock.json)).
@@ -145,11 +152,11 @@ study-swarm requalify --resolve d.dispatch.md arXiv:2402.15089 --mode removed
 ## Security
-`study-swarm` ships a **thin, zero-dependency CLI** (`study-swarm`) alongside the methodology. It makes **no network or model calls** and collects **no telemetry**; there are no secrets or credentials in the source. At runtime it only reads the file you pass to `lint` and writes a single `<slug>.dispatch.md` in the current directory for `new` (refusing to overwrite, and never outside the working directory). The model-based verification the methodology describes (Step 4) is run by the sibling tools, not by this package. See [SECURITY.md](SECURITY.md).
+`study-swarm` ships a **thin, zero-dependency CLI** (`study-swarm`) alongside the methodology. It makes **no network or model calls** and collects **no telemetry**; there are no secrets or credentials in the source. At runtime it reads the files you name. `new` writes a single `<slug>.dispatch.md` in the current directory (refusing to overwrite, and never outside that directory). `lock`, `withdraw`, and `requalify` also write a lock file, a tombstone sidecar, and — when you pass `--receipt` — a receipt at the path you give. The model-based verification the methodology describes (Step 4) is run by the sibling tools, not by this package. See [SECURITY.md](SECURITY.md).
 ## Status
-A working protocol, externally verified by its own machinery — a different model family checks its citations (see the proof above). **v1.1** sharpens the verifier where the first release was silent: decomposed/ternary groundedness, generation-time grounding, an oracle-gated cascade for combining lenses, and calibrated abstention — each grounded in the verified v1.1 dispatch. **v1.2** makes a dispatch byte-replayable: `study-swarm lock` pins the resolved model, prompt, and tool schema per step plus the verifier receipt, and `lock --verify` fails closed on drift. **v1.3** makes the rollback executable: when a finding that already became canon is withdrawn, `study-swarm withdraw` flags every dependent and `requalify --check` halts them fail-closed until they're removed or re-grounded — a named, receipted, idempotent compensator. This repo is the public reference; [PROTOCOL.md](PROTOCOL.md) is the executable shape. Part of the [dogfood-lab](https://github.com/dogfood-lab) family — methods and showcases for building in the AI era.
+A working protocol, externally verified by its own machinery — a different model family checks its citations (see the proof above). **v1.1** sharpens the verifier where the first release was silent: decomposed/ternary groundedness, generation-time grounding, an oracle-gated cascade for combining lenses, and calibrated abstention — each grounded in the verified v1.1 dispatch. **v1.2** makes a dispatch byte-replayable: `study-swarm lock` pins the resolved model, prompt, and tool schema per step plus the verifier receipt, and `lock --verify` fails closed on drift. **v1.3** makes the rollback executable: when a finding that already became canon is withdrawn, `study-swarm withdraw` flags every dependent and `requalify --check` halts them fail-closed until they're removed or re-grounded — a named, receipted, idempotent compensator. **v2.0** makes more of the protocol executable and hardens the lock: `lint --strict` flags orphan citations — the one named failure mode the CLI couldn't catch — `lock --init` scaffolds the harness record, `requalify --status` reads a corpus's evidence health, and the lock's content-addressing is domain-separated (artifact schema v2 — a lock from an earlier version is regenerated rather than mis-flagged as tampered; the CLI's command surface stays backward-compatible). This repo is the public reference; [PROTOCOL.md](PROTOCOL.md) is the executable shape. Part of the [dogfood-lab](https://github.com/dogfood-lab) family — methods and showcases for building in the AI era.
 MIT licensed.

package/README.pt-BR.md CHANGED Viewed

@@ -23,8 +23,8 @@ Ele aplica sua própria abordagem. O protocolo prescreve "envelopes" protegidos
 1. **Identifique** 3 a 5 questões de projeto cruciais, nas quais evidências empíricas mudariam a resposta.
 2. **Envie** um agente de pesquisa por questão, em paralelo. Cada um deve retornar títulos de artigos + autores + anos + URLs + uma descoberta em uma frase — especificidade em vez de amplitude ("6 a 8 descobertas bem fundamentadas superam 20 observações vagas").
-3. **Sintetize** as descobertas em uma seção de *fundamentação da pesquisa*: `N. **<descoberta>.** <Autores> <ano> (<arXiv/DOI>). <implicação para o projeto>.`
-4. **Verifique externamente** — uma *família de modelos diferente*, sem raciocínio, verifica cada citação em duas etapas: um **oráculo de recuperação** confirma que o artigo existe (nunca a memória do modelo) e, em seguida, uma lente de **validação** confirma que a descoberta corresponde à fonte. **Interrompa** se for fabricada/atribuída incorretamente; **interrompa e alerte** se o verificador ou o oráculo de recuperação não estiverem disponíveis (nunca interprete a ausência como "citações válidas").
+3. **Sintetize** as descobertas em uma seção de *Research grounding* (fundamentação da pesquisa): `N. **<descoberta>.** <Autores> <ano> (<arXiv/DOI>). <implicação para o projeto>.`
+4. **Verifique externamente** — uma *família de modelos diferente*, sem raciocínio, verifica cada citação em duas etapas: um **oráculo de recuperação** confirma que o artigo existe (nunca a memória do modelo) e, em seguida, uma lente de **validação** confirma que a descoberta corresponde à fonte. **Descarte** um achado fabricado; **corrija uma atribuição incorreta uma vez** e verifique de novo (um segundo veredito não limpo descarta). **Interrompa e alerte** somente quando o verificador ou o oráculo de recuperação não estiverem disponíveis (nunca interprete a ausência como "citações válidas").
 5. **Conecte** cada escolha arquitetural a uma descoberta por meio de um número. Citações sem implicação para o projeto são ruído.
 Os detalhes completos e executáveis — a tabela de interrupção, o padrão de referência e a regra do conjunto — estão em **[PROTOCOL.md](PROTOCOL.md)**.
@@ -75,12 +75,15 @@ npm i -g @dogfood-lab/study-swarm     # or run ad-hoc: npx @dogfood-lab/study-sw
 |---|---|
 | `study-swarm protocol` | Imprime o protocolo completo – as cinco etapas, a tabela de interrupção e o padrão de referência. |
 | `study-swarm new <slug>` | Cria um arquivo `<slug>.dispatch.md` com o esqueleto das cinco etapas para preencher. |
-| `study-swarm lint [--json] <path…>` | Verifica a *fundamentação da pesquisa* de uma análise em relação ao padrão de referência – cada achado precisa de um autor, um ano e um identificador resolvível (arXiv / DOI / URL); “estudos mostram…” sem embasamento é rejeitado. Sai com `1` em caso de violações, para que valide o CI. Um `<path>` pode ser um arquivo, um diretório (analisado recursivamente para `*.dispatch.md`) ou `-` para stdin; `--json` emite um relatório legível por máquina. |
-| `study-swarm lock <dispatch> --from <orchestration.json>` | Fixe um envio para reprodução – crie o arquivo `<dispatch>.lock.json` com informações de conteúdo, conforme o agente da Etapa 2, incluindo o **ID do modelo resolvido** + o **SHA-256 do prompt exato em bytes** + o **SHA-256 do esquema da ferramenta**, mais o **comprovante do verificador** da Etapa 4, tudo reunido em um único arquivo `lock_sha256`. |
+| `study-swarm lint [--json] [--strict] <path…>` | Verifique a *Research grounding* (base de pesquisa) de um relatório em relação ao padrão de fontes – cada conclusão deve ter um autor, um ano e um identificador que possa ser localizado (arXiv / DOI / URL / RFC); argumentos vagos do tipo "estudos mostram…" são rejeitados. Retorne `1` em caso de violações, para que isso impeça a execução do CI. Um `<caminho>` pode ser um arquivo, um diretório (verificado recursivamente para `*.dispatch.md`) ou `-` para entrada padrão; `--json` gera um relatório legível por máquina. `--strict` também sinaliza **citações órfãs** – uma conclusão que nenhuma escolha da Etapa 5 referencia –, já que "citações sem conexão são ruído" (opcional, portanto, a configuração padrão do CI permanece inalterada). |
+| `study-swarm return <dispatch> [--check]` | Escreve os resultados: `<stem>.results.md` é a folha que se entrega, e `<stem>.results.json` guarda os mesmos fatos ao lado do dispatch para a próxima execução. `--check` falha se alguma das cópias tiver desviado do dispatch. |
+| `study-swarm lock --init <dispatch>` | Crie o arquivo `<dispatch>.orchestration.json` – um modelo de registro para preencher os campos (uma etapa por agente da Etapa 2) para fornecer ao comando `lock … --from`. |
+| `study-swarm lock <dispatch> --from <orchestration.json>` | Fixe um envio para reprodução – crie o arquivo `<dispatch>.lock.json` com informações de conteúdo, conforme o agente da Etapa 2, incluindo o **ID do modelo resolvido** + o **SHA-256 do prompt normalizado (BOM removido, quebras de linha em LF, NFC)** + o **SHA-256 do esquema da ferramenta**, mais o **comprovante do verificador** da Etapa 4, tudo reunido em um único arquivo `lock_sha256`. |
 | `study-swarm lock --verify <dispatch> [--from …]` | Recalcule esses hashes e verifique se correspondem ao bloqueio; qualquer desvio resulta em saída `1`, portanto, controla o CI como um arquivo de bloqueio de pacote. Sem `--from`, verifica a própria integridade do bloqueio. |
-| `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **Mecanismo de compensação para reversão do canon.** Marcar cada registro no corpus cujo *fundamento da pesquisa* cite `<id>` como `evidência-retirada` (um arquivo auxiliar `<slug>.withdrawn.json` — marcar, nunca excluir) e emitir um comprovante de retirada com base no conteúdo. `--reason` ∈ `fabricado · atribuído incorretamente · revogado · verificador alterado · outro`. |
+| `study-swarm withdraw <id> --reason <reason> [--from <dir>] [--receipt <path>]` | **Mecanismo de compensação para reversão do canon.** Marcar cada registro no corpus cuja seção *Research grounding* (fundamento da pesquisa) cite `<id>` como `evidência-retirada` (um arquivo auxiliar `<slug>.withdrawn.json` — marcar, nunca excluir) e emitir um comprovante de retirada com base no conteúdo. `--reason` ∈ `fabricated · misattributed · retracted · verifier-flipped · other` (fabricado, atribuído incorretamente, revogado, verificador alterado, outro). |
 | `study-swarm requalify --check <corpus-dir>` | Falhar em modo fechado (sair com código `1`) para qualquer registro que contenha uma marcação `evidência-retirada` não resolvida — o sinalizador que **interrompe** os elementos dependentes de um resultado retirado até que seja removido ou reavaliado. Gates CI. |
-| `study-swarm requalify --resolve <registro> <id> --mode removed\ | regrounded [--note …]` | Remover uma marcação assim que o resultado for removido (a citação desaparecer) ou reavaliado (reverificado e validado pelo executor irmão; `--note` registra a confirmação). Idempotente; adiciona ao histórico de auditoria do arquivo auxiliar. |
+| `study-swarm requalify --status <corpus-dir> [--json]` | Visualização somente leitura do estado de validade das evidências de um corpus – contagem de conclusões retiradas versus resolvidas, uma divisão por motivo e modo de resolução, linhas por relatório. Informativo (retorna `0`), diferente da verificação `--check`. |
+| `study-swarm requalify --resolve <registro> <id> --mode removed\|regrounded [--note …]` | Remover uma marcação assim que o resultado for removido (a citação desaparecer) ou reavaliado (reverificado e validado pelo executor irmão; `--note` registra a confirmação). Idempotente; adiciona ao histórico de auditoria do arquivo auxiliar. |
 `lint` é determinístico – sem chamadas de modelo – portanto, é seguro no CI. Ele aplica o **padrão de referência da Etapa 3** localmente; a verificação baseada em modelo da **Etapa 4** ainda depende de [`roleos verify-citations`](https://github.com/mcp-tool-shop-org/role-os) → prism.
@@ -104,7 +107,7 @@ Quatro registros completos, limpos e funcionais são enviados como referência:
 name: study-swarm lint
 on:
   pull_request:
-    paths: ['**/*.dispatch.md', '.github/workflows/dispatches.yml']
+    paths: ['**/*.dispatch.md', '**/*.withdrawn.json', '.github/workflows/dispatches.yml']
   workflow_dispatch:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -112,16 +115,20 @@ concurrency:
 jobs:
   lint:
     runs-on: ubuntu-latest
+    timeout-minutes: 5
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with: { node-version: '20' }
-      - run: npx @dogfood-lab/study-swarm@latest lint dispatches/
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 lint dispatches/
+      # Halt the build while any finding that became canon is withdrawn and not yet
+      # removed or re-grounded — the canon-rollback andon (exit 1 on any unresolved flag).
+      - run: npx --yes @dogfood-lab/study-swarm@2.1.0 requalify --check dispatches/
 ```
 ### Fixe um envio para reprodução (`dispatch.lock.json`)
-Um envio validado e comprovado só pode ser auditado se você puder dizer *o que o gerou*. `study-swarm lock` cria um arquivo de bloqueio complementar que, por meio do agente de pesquisa, contém informações sobre o **ID do modelo resolvido** (nunca um alias flutuante), o **SHA-256 do prompt exato em bytes** e o **SHA-256 do esquema da ferramenta** fornecido, mais o **comprovante externo do verificador** – tudo reunido em um único arquivo `lock_sha256`. `study-swarm lock --verify` recalcula esses hashes e falha se houver qualquer desvio, portanto, um prompt alterado, um modelo substituído ou uma ferramenta modificada são detectados – o padrão de reprodutibilidade [PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm), que pode ser executado. O sistema emite o registro; a CLI permanece sem dependências e independente da rede, apenas normalizando (RFC 8785), calculando hashes e validando.
+Um envio validado e comprovado só pode ser auditado se você puder dizer *o que o gerou*. `study-swarm lock` cria um arquivo de bloqueio complementar que, por meio do agente de pesquisa, contém informações sobre o **ID do modelo resolvido** (nunca um alias flutuante), o **SHA-256 do prompt normalizado (BOM removido, quebras de linha em LF, NFC)** e o **SHA-256 do esquema da ferramenta** fornecido, mais o **comprovante externo do verificador** – tudo reunido em um único arquivo `lock_sha256`. `study-swarm lock --verify` recalcula esses hashes e falha se houver qualquer desvio, portanto, um prompt alterado, um modelo substituído ou uma ferramenta modificada são detectados – o padrão de reprodutibilidade [PIN_PER_STEP](https://github.com/dogfood-lab/study-swarm), que pode ser executado. O sistema emite o registro; a CLI permanece sem dependências e independente da rede, apenas normalizando (RFC 8785), calculando hashes e validando.
 **Ele fixa as entradas, não as saídas.** Fixar modelo + prompt + temperatura *não* torna a saída de um LLM bit a bit idêntica – invariância em lote, não associatividade de ponto flutuante, roteamento de mistura de especialistas e desvio silencioso do provedor estão todos fora do controle de uma ferramenta offline. Portanto, o bloqueio fornece **entradas reproduzíveis e saídas com detecção de desvio**, nunca "reprodução determinística". O design é fundamentado, citação por citação, em [`examples/study-swarm-lock.dispatch.md`](examples/study-swarm-lock.dispatch.md) – o primeiro envio a incluir seu próprio bloqueio ([`examples/study-swarm-lock.lock.json`](examples/study-swarm-lock.lock.json)).
@@ -145,11 +152,11 @@ study-swarm requalify --resolve d.dispatch.md arXiv:2402.15089 --mode removed
 ## Segurança
-`study-swarm` fornece uma **CLI fina e com poucas dependências** (`study-swarm`) junto com a metodologia. Ele não faz **chamadas de rede ou modelo** e não coleta **telemetria**; não há segredos ou credenciais no código-fonte. Em tempo de execução, ele lê apenas o arquivo que você passa para `lint` e grava um único arquivo `<slug>.dispatch.md` no diretório atual para `new` (recusando-se a sobrescrever e nunca fora do diretório de trabalho). A verificação baseada em modelo descrita na metodologia (Etapa 4) é executada pelas ferramentas complementares, não por este pacote. Consulte [SECURITY.md](SECURITY.md).
+`study-swarm` fornece uma **CLI fina e sem dependências de runtime** (`study-swarm`) junto com a metodologia. Ele não faz **chamadas de rede ou modelo** e não coleta **telemetria**; não há segredos ou credenciais no código-fonte. Em tempo de execução, ele lê os arquivos que você nomeia. `new` grava um único `<slug>.dispatch.md` no diretório de trabalho (sem sobrescrever e sem sair dele). `lock`, `withdraw` e `requalify` também gravam um lock, um sidecar de lápide e, com `--receipt`, um recibo no caminho indicado. A verificação baseada em modelo descrita na metodologia (Etapa 4) é executada pelas ferramentas complementares, não por este pacote. Consulte [SECURITY.md](SECURITY.md).
 ## Status
-Um protocolo funcional, verificado externamente por sua própria infraestrutura — uma família diferente de modelos verifica suas citações (veja a prova acima). **v1.1** aprimora o verificador, onde a primeira versão era silenciosa: fundamentação decomposta/ternária, fundamentação no momento da geração, cascata controlada por um oráculo para combinar lentes e abstinência calibrada — cada um baseado no registro verificado da versão 1.1. **v1.2** torna um registro reproduzível: `study-swarm lock` fixa o modelo resolvido, o prompt e o esquema de ferramentas por etapa, além do comprovante do verificador, e `lock --verify` falha em modo fechado em caso de desvio. **v1.3** torna a reversão executável: quando um resultado que já se tornou canon é retirado, `study-swarm withdraw` marca todos os elementos dependentes e `requalify --check` os interrompe, fazendo com que falhem até que sejam removidos ou reavaliados — um compensador nomeado, com comprovante e idempotente. Este repositório é a referência pública; [PROTOCOL.md](PROTOCOL.md) é a forma executável. Faz parte da família [dogfood-lab](https://github.com/dogfood-lab) — métodos e demonstrações para construir na era da IA.
+Um protocolo funcional, verificado externamente por seu próprio mecanismo – uma família de modelos diferente verifica suas citações (veja a prova acima). A **versão 1.1** aprimora o verificador, onde a primeira versão estava silenciosa: base de pesquisa decomposta/ternária, base de pesquisa no momento da geração, um sistema em cascata controlado por um oráculo para combinar lentes e abstinência calibrada – cada um baseado na verificação da versão 1.1 do relatório. A **versão 1.2** torna um relatório reproduzível: `study-swarm lock` fixa o modelo, o prompt e o esquema de ferramentas resolvidos por etapa, além do recibo do verificador, e `lock --verify` falha se houver desvio. A **versão 1.3** torna a reversão executável: quando uma conclusão que já se tornou um padrão é retirada, `study-swarm withdraw` sinaliza todas as dependências e `requalify --check` interrompe sua execução até que sejam removidas ou reavaliadas – um compensador nomeado, com recibo e idempotente. A **versão 2.0** torna mais partes do protocolo executáveis e reforça o bloqueio: `lint --strict` sinaliza citações órfãs – a única falha detectável pela CLI –, `lock --init` cria o modelo de registro, `requalify --status` lê o estado de validade das evidências de um corpus e o endereçamento de conteúdo do bloqueio é separado por domínio (esquema de artefato v2 – um bloqueio de uma versão anterior é regenerado em vez de ser sinalizado incorretamente como adulterado; a interface de linha de comando permanece compatível com versões anteriores). Este repositório é a referência pública; [PROTOCOL.md](PROTOCOL.md) é a forma executável. Parte da família [dogfood-lab](https://github.com/dogfood-lab) – métodos e demonstrações para construir na era da IA.
 Licenciado sob MIT.