dsh-doublecheck 0.7.3 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to dsh-doublecheck are recorded here, newest first.
 
+## [0.9.0] - 2026-08-26
+
+### Added
+
+- **Headless CI gate report (JSON/SARIF).** `/gate run` now also writes a `gate-report.json` next to `gate-report.md` — the same settled `GateState` as lossless JSON. The new `doublecheck-gate` CLI serializes that state to JSON or SARIF 2.1.0 for GitHub Actions PR comments/status checks (`doublecheck-gate --format json|sarif --input gate-report.json`), exiting `0` on `deliverable` and `1` on `rework`. The CLI never re-runs the four-phase gate or the evidence folds — it only serializes the already-settled state.
+
+## [0.8.0] - 2026-08-23
+
+### Added
+
+- **dsh-eval evidence in the test-evidence phase**: the new `gate.tests.evalReports.*` config block (weak dependency, `enabled: false` by default) folds the dsh-auto-review eval engine's `dsh-eval` report file — its prompt-regression / stress / fairness suites — into the gate's test evidence as one audit-safe counts check. A present report whose suite passed every case is a pass; a report with failing/erroring/cancelled cases is a red light with a rework suggestion; a missing or malformed report degrades to an honest skip (or a red light when `required: true`). The folded counts ride the durable `doublecheck/gate` record, so a settled run still replays even though the source file is not part of the session log.
+
 ## v0.7.3 — 2026-08-22
 
 ### Changed

package/README.es.md

@@ -116,6 +116,10 @@ Todos los ajustes son campos `Config` de Schemastery (modificables desde cordis.
 | `gate.tests.allowFailingRuns` | `0` | Ejecuciones fallidas tras el último verde permitidas antes del rojo. |
 | `gate.tests.requireCoverage` | `false` | Encendido exige evidencia de cobertura en la salida de prueba. |
 | `gate.tests.minCoveragePct` | `80` | Porcentaje mínimo de cobertura (0–100). |
+| `gate.tests.evalReports.enabled` | `false` | Encendido pliega el informe dsh-eval (el motor de evaluación de dsh-auto-review) en la evidencia de prueba. |
+| `gate.tests.evalReports.dir` | `'.eval-reports'` | Directorio relativo al espacio de trabajo que contiene el informe del motor. |
+| `gate.tests.evalReports.file` | `'report.json'` | Nombre del archivo de informe dentro del directorio. |
+| `gate.tests.evalReports.required` | `false` | Un informe ausente es una luz roja exactamente cuando es true (un salto en caso contrario). |
 | `gate.consistency.*` | `provider: 'fork'`, `model: null`, `tools: ['read','glob','grep']`, `timeoutMs: 120000`, `maxFindings: 5` | Ajustes del revisor local de consistencia (`model: null` = modelo principal). |
 | `gate.review.engine` | `'auto'` | `auto` = registros de veredicto de dsh-auto-review cuando están presentes, si no el revisor local; `local` = siempre local. |
 | `gate.review.provider` | `'fork'` | Proveedor del revisor local de revisión (su `model`/`tools`/`timeoutMs`/`maxFindings` coinciden con `gate.consistency.*`). |
@@ -143,11 +147,11 @@ La puerta de entrega agrega la evidencia durable de la sesión en una lista conf
 | Fase | Comprobaciones | Fuente de evidencia | Costo de modelo |
 |---|---|---|---|
 | Interrogatorio de requisitos | Lista de preguntas clave confirmadas una a una (seis preguntas de dimensión de spec por defecto) | `doublecheck_spec` confirmado + llamadas `ask_user_question` | ninguno |
-| Evidencia de prueba | Color de la última ejecución, ejecuciones fallidas tras el verde, umbral de cobertura opcional | Ejecuciones de prueba shell en el registro de sesión (`[exit code: N]`, porcentajes de cobertura) | ninguno |
+| Evidencia de prueba | Color de la última ejecución, ejecuciones fallidas tras el verde, umbral de cobertura opcional, informe dsh-eval opcional | Ejecuciones de prueba shell en el registro de sesión (`[exit code: N]`, porcentajes de cobertura); el archivo de informe dsh-eval cuando `gate.tests.evalReports.enabled` | ninguno |
 | Consistencia de implementación | Mapeo diff ↔ requisito: cada edición debe servir a una dimensión de spec | Revisor bifurcado local (hallazgos estructurados, herramientas de solo lectura) | un subagente |
 | Conclusión de revisión | El veredicto de entrega; `engine: auto` consume los registros de veredicto durables de dsh-auto-review cuando están presentes, si no el revisor local | Eventos `autoReview/verdict` / `autoReview/rejection`, o el revisor bifurcado local | un subagente (local) |
 
-Las luces rojas son comprobaciones fallidas (un spec ausente, una última ejecución fallida, cobertura bajo el mínimo, una edición sin mapear, hallazgos blocker/major) — cada una lleva una sugerencia de retrabajo. Las advertencias y los saltos nunca invierten la decisión. La puerta integra [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) como dependencia débil: `review.engine: auto` pliega sus registros de veredicto cuando están presentes y degrada al revisor local en caso contrario; la puerta nunca sintetiza solicitudes de aprobación.
+Las luces rojas son comprobaciones fallidas (un spec ausente, una última ejecución fallida, cobertura bajo el mínimo, una edición sin mapear, hallazgos blocker/major) — cada una lleva una sugerencia de retrabajo. Las advertencias y los saltos nunca invierten la decisión. La puerta integra [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) como dependencia débil: `review.engine: auto` pliega sus registros de veredicto cuando están presentes y degrada al revisor local en caso contrario; `gate.tests.evalReports.enabled` pliega el informe dsh-eval de su motor de evaluación (suites de regresión de prompt / estrés / equidad) en la evidencia de prueba y salta honestamente cuando no existe informe. La puerta nunca sintetiza solicitudes de aprobación.
 
 ## Informe de ejemplo
 
@@ -188,6 +192,19 @@ Las luces rojas son comprobaciones fallidas (un spec ausente, una última ejecuc
 - counts, ids, and verdicts only: no file contents or session text are embedded, and recognized secrets are redacted.
 ````
 
+## Salida de CI
+
+`/gate run` también escribe un `gate-report.json` (el mismo estado asentado que el JSON sin pérdida, junto a `gate-report.md`). El CLI `doublecheck-gate` convierte ese archivo en salida legible por máquina para GitHub Actions:
+
+```sh
+# JSON (comentario de PR / payload de estado)
+doublecheck-gate --format json --input gate-report.json
+# SARIF 2.1.0 (subida de code-scanning / verificación de estado)
+doublecheck-gate --format sarif < gate-report.json
+```
+
+El CLI solo serializa el `GateState` ya asentado — nunca vuelve a ejecutar la puerta de cuatro fases ni los pliegues de evidencia. Su código de salida mapea el veredicto: `0` = entregable, `1` = retrabajo, `2` = error de uso/análisis.
+
 ## Permisos y datos
 
 - **Lee**: el registro de sesión (`tool/call` / `tool/result` / `tool/code-dispatch`, fuentes `user/message` inyectadas y los registros de veredicto ajenos `autoReview/*`) solo en proceso; el estado opcional del servicio de modo plan.
@@ -208,6 +225,7 @@ Las luces rojas son comprobaciones fallidas (un spec ausente, una última ejecuc
 - **Escrituras durables.** `/doublecheck on\|off` → `doublecheck/state` y `/gate run` → `doublecheck/gate` necesitan la superficie de append `ignorable` del host (post-rc.6), que todo host compatible (≥ `0.1.1-rc.2`) proporciona.
 - **Interfaces opcionales.** El espacio de ajustes `doublecheck.gate` se registra solo cuando el servicio de ajustes está montado; la línea de modo plan de `/gate status` lee el `ctx.planMode` opcional (muestra `unknown` sin él); la revisión adversarial necesita `ctx.subagents`; la verificación necesita `workflowEngine`.
 - **Degradación local.** `gate.review.engine: auto` degrada al revisor local cuando dsh-auto-review está ausente o no tiene registros de veredicto en esta sesión — el informe nombra la razón en lugar de inventar un veredicto.
+- **La evidencia dsh-eval se basa en archivos.** El motor de evaluación de dsh-auto-review (`dsh-eval`) escribe sus resultados de regresión de prompt / estrés / equidad en un archivo de informe del espacio de trabajo, no en el registro de sesión. `gate.tests.evalReports.enabled` pliega ese archivo (desactivado por defecto; salta cuando está ausente) y los recuentos pliegados viajan en el registro duradero `doublecheck/gate` para que una ejecución asentada siga siendo reproducible.
 
 ## Desarrollo
 

package/README.hi.md

@@ -116,6 +116,10 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 | `gate.tests.allowFailingRuns` | `0` | नवीनतम हरे के बाद लाल से पहले अनुमत असफल रन। |
 | `gate.tests.requireCoverage` | `false` | चालू करने पर परीक्षण आउटपुट में कवरेज साक्ष्य आवश्यक। |
 | `gate.tests.minCoveragePct` | `80` | न्यूनतम कवरेज प्रतिशत (0–100)। |
+| `gate.tests.evalReports.enabled` | `false` | चालू करने पर dsh-eval रिपोर्ट (dsh-auto-review का मूल्यांकन इंजन) परीक्षण साक्ष्य में मोड़ी जाती है। |
+| `gate.tests.evalReports.dir` | `'.eval-reports'` | इंजन की रिपोर्ट रखने वाली कार्यक्षेत्र-सापेक्ष निर्देशिका। |
+| `gate.tests.evalReports.file` | `'report.json'` | निर्देशिका के भीतर रिपोर्ट फ़ाइल का नाम। |
+| `gate.tests.evalReports.required` | `false` | true होने पर अनुपस्थित रिपोर्ट लाल बत्ती होती है (अन्यथा छोड़ दी जाती है)। |
 | `gate.consistency.*` | `provider: 'fork'`, `model: null`, `tools: ['read','glob','grep']`, `timeoutMs: 120000`, `maxFindings: 5` | स्थानीय संगति समीक्षक के नॉब (`model: null` = मुख्य मॉडल)। |
 | `gate.review.engine` | `'auto'` | `auto` = उपस्थित होने पर dsh-auto-review के निर्णय रिकॉर्ड, अन्यथा स्थानीय समीक्षक; `local` = हमेशा स्थानीय। |
 | `gate.review.provider` | `'fork'` | स्थानीय समीक्षा समीक्षक का प्रदाता (इसके `model`/`tools`/`timeoutMs`/`maxFindings` `gate.consistency.*` से मेल खाते हैं)। |
@@ -143,11 +147,11 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 | चरण | जाँचें | साक्ष्य स्रोत | मॉडल लागत |
 |---|---|---|---|
 | आवश्यकता पूछताछ | मुख्य-प्रश्न सूची एक-एक करके पुष्ट (डिफ़ॉल्ट रूप से छह spec-आयाम प्रश्न) | प्रतिबद्ध `doublecheck_spec` + `ask_user_question` कॉलें | कोई नहीं |
-| परीक्षण साक्ष्य | नवीनतम रन रंग, हरे के बाद असफल रन, वैकल्पिक कवरेज थ्रेशोल्ड | सत्र लॉग में शेल परीक्षण रन (`[exit code: N]`, कवरेज प्रतिशत) | कोई नहीं |
+| परीक्षण साक्ष्य | नवीनतम रन रंग, हरे के बाद असफल रन, वैकल्पिक कवरेज थ्रेशोल्ड, वैकल्पिक dsh-eval रिपोर्ट | सत्र लॉग में शेल परीक्षण रन (`[exit code: N]`, कवरेज प्रतिशत); `gate.tests.evalReports.enabled` होने पर dsh-eval रिपोर्ट फ़ाइल | कोई नहीं |
 | कार्यान्वयन संगति | diff ↔ आवश्यकता मैपिंग: हर एडिट को किसी spec आयाम की सेवा करनी चाहिए | स्थानीय फ़ोर्क समीक्षक (संरचित निष्कर्ष, केवल-पढ़ने वाले उपकरण) | एक subagent |
 | समीक्षा निष्कर्ष | डिलीवरी निर्णय; `engine: auto` उपस्थित होने पर dsh-auto-review के टिकाऊ निर्णय रिकॉर्ड का उपभोग करता है, अन्यथा स्थानीय समीक्षक | `autoReview/verdict` / `autoReview/rejection` इवेंट, या स्थानीय फ़ोर्क समीक्षक | एक subagent (स्थानीय) |
 
-लाल बत्तियाँ असफल जाँचें हैं (अनुपस्थित spec, असफल नवीनतम रन, न्यूनतम से कम कवरेज, अनमैप एडिट, blocker/major निष्कर्ष) — हर एक पुनः-कार्य सुझाव रखता है। चेतावनियाँ और छोड़े जाने कभी निर्णय नहीं बदलते। द्वार [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) को कमज़ोर निर्भरता के रूप में एकीकृत करता है: `review.engine: auto` उपस्थित होने पर उसके निर्णय रिकॉर्ड मोड़ता है और अन्यथा स्थानीय समीक्षक पर घट जाता है; द्वार कभी अनुमोदन अनुरोध संश्लेषित नहीं करता।
+लाल बत्तियाँ असफल जाँचें हैं (अनुपस्थित spec, असफल नवीनतम रन, न्यूनतम से कम कवरेज, अनमैप एडिट, blocker/major निष्कर्ष) — हर एक पुनः-कार्य सुझाव रखता है। चेतावनियाँ और छोड़े जाने कभी निर्णय नहीं बदलते। द्वार [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) को कमज़ोर निर्भरता के रूप में एकीकृत करता है: `review.engine: auto` उपस्थित होने पर उसके निर्णय रिकॉर्ड मोड़ता है और अन्यथा स्थानीय समीक्षक पर घट जाता है; `gate.tests.evalReports.enabled` उसके मूल्यांकन इंजन की dsh-eval रिपोर्ट (prompt-regression / stress / fairness सूट) परीक्षण साक्ष्य में मोड़ता है और रिपोर्ट न होने पर ईमानदारी से छोड़ देता है। द्वार कभी अनुमोदन अनुरोध संश्लेषित नहीं करता।
 
 ## उदाहरण रिपोर्ट
 
@@ -188,6 +192,19 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 - counts, ids, and verdicts only: no file contents or session text are embedded, and recognized secrets are redacted.
 ````
 
+## CI आउटपुट
+
+`/gate run` एक `gate-report.json` भी लिखता है (दोषरहित JSON जैसी ही स्थापित स्थिति, `gate-report.md` के पास)। `doublecheck-gate` CLI उस फ़ाइल को GitHub Actions के लिए मशीन-पठनीय आउटपुट में बदलता है:
+
+```sh
+# JSON (PR टिप्पणी / स्थिति पेलोड)
+doublecheck-gate --format json --input gate-report.json
+# SARIF 2.1.0 (code-scanning अपलोड / स्थिति जाँच)
+doublecheck-gate --format sarif < gate-report.json
+```
+
+CLI केवल पहले से स्थापित `GateState` को क्रमबद्ध करता है — यह कभी चार-चरणीय द्वार या साक्ष्य तहों को दोबारा नहीं चलाता। इसका निकास कोड निर्णय को मैप करता है: `0` = डिलीवर करने योग्य, `1` = पुनः कार्य, `2` = उपयोग/पार्स त्रुटि।
+
 ## अनुमतियाँ और डेटा
 
 - **पढ़ता है**: सत्र लॉग (`tool/call` / `tool/result` / `tool/code-dispatch`, इंजेक्ट किए गए `user/message` स्रोत, और बाहरी `autoReview/*` निर्णय रिकॉर्ड) केवल प्रक्रिया के भीतर; वैकल्पिक प्लान-मोड सेवा स्थिति।
@@ -208,6 +225,7 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 - **टिकाऊ लेखन।** `/doublecheck on\|off` → `doublecheck/state` और `/gate run` → `doublecheck/gate` को host की `ignorable` append सतह (rc.6 के बाद) चाहिए, जो हर समर्थित host (≥ `0.1.1-rc.2`) प्रदान करता है।
 - **वैकल्पिक इंटरफ़ेस।** `doublecheck.gate` सेटिंग्स नेमस्पेस केवल तब पंजीकृत होता है जब सेटिंग्स सेवा माउंट हो; `/gate status` की प्लान-मोड पंक्ति वैकल्पिक `ctx.planMode` पढ़ती है (इसके बिना `unknown` दिखाती है); प्रतिकूल समीक्षा को `ctx.subagents` चाहिए; सत्यापन को `workflowEngine` चाहिए।
 - **स्थानीय अवनति।** जब dsh-auto-review अनुपस्थित हो या इस सत्र में उसके कोई निर्णय रिकॉर्ड न हों, तो `gate.review.engine: auto` स्थानीय समीक्षक पर घट जाता है — रिपोर्ट निर्णय गढ़ने के बजाय कारण बताती है।
+- **dsh-eval साक्ष्य फ़ाइल-आधारित है।** dsh-auto-review का मूल्यांकन इंजन (`dsh-eval`) अपने prompt-regression / stress / fairness परिणाम कार्यक्षेत्र रिपोर्ट फ़ाइल में लिखता है, सत्र लॉग में नहीं। `gate.tests.evalReports.enabled` उस फ़ाइल को मोड़ता है (डिफ़ॉल्ट रूप से बंद; अनुपस्थित होने पर छोड़ देता है) और मोड़ी गई गणनाएँ टिकाऊ `doublecheck/gate` रिकॉर्ड पर चलती हैं, ताकि तयशुदा रन फिर भी रीप्ले हो सके।
 
 ## विकास
 

package/README.md

@@ -117,6 +117,10 @@ All tunables are Schemastery `Config` fields (changeable from cordis.yml). An id
 | `gate.tests.allowFailingRuns` | `0` | Failing runs after the latest green allowed before red. |
 | `gate.tests.requireCoverage` | `false` | On requires coverage evidence in the test output. |
 | `gate.tests.minCoveragePct` | `80` | Minimum coverage percentage (0–100). |
+| `gate.tests.evalReports.enabled` | `false` | On folds the dsh-eval report (dsh-auto-review's eval engine) into the test evidence. |
+| `gate.tests.evalReports.dir` | `'.eval-reports'` | Workspace-relative directory holding the engine's report. |
+| `gate.tests.evalReports.file` | `'report.json'` | Report file name inside the directory. |
+| `gate.tests.evalReports.required` | `false` | A missing report is a red light exactly when true (a skip otherwise). |
 | `gate.consistency.*` | `provider: 'fork'`, `model: null`, `tools: ['read','glob','grep']`, `timeoutMs: 120000`, `maxFindings: 5` | The local consistency reviewer's knobs (`model: null` = main model). |
 | `gate.review.engine` | `'auto'` | `auto` = dsh-auto-review verdict records when present, else the local reviewer; `local` = always local. |
 | `gate.review.provider` | `'fork'` | The local review reviewer's provider (its `model`/`tools`/`timeoutMs`/`maxFindings` match `gate.consistency.*`). |
@@ -144,11 +148,11 @@ The delivery gate aggregates the session's durable evidence into a configurable
 | Phase | Checks | Evidence source | Model cost |
 |---|---|---|---|
 | Requirements interrogation | Key-question checklist confirmed item by item (six spec-dimension questions by default) | Committed `doublecheck_spec` + `ask_user_question` calls | none |
-| Test evidence | Latest run color, failing runs after green, optional coverage threshold | Shell test runs in the session log (`[exit code: N]`, coverage percentages) | none |
+| Test evidence | Latest run color, failing runs after green, optional coverage threshold, optional dsh-eval report | Shell test runs in the session log (`[exit code: N]`, coverage percentages); the dsh-eval report file when `gate.tests.evalReports.enabled` | none |
 | Implementation consistency | Diff ↔ requirement mapping: every edit must serve a spec dimension | Local forked reviewer (structured findings, read-only tools) | one subagent |
 | Review conclusion | The delivery verdict; `engine: auto` consumes dsh-auto-review's durable verdict records when present, else the local reviewer | `autoReview/verdict` / `autoReview/rejection` events, or the local forked reviewer | one subagent (local) |
 
-Red lights are failed checks (a missing spec, a failing latest run, coverage below minimum, an unmapped edit, blocker/major findings) — each carries a rework suggestion. Warnings and skips never flip the decision. The gate integrates [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) as a weak dependency: `review.engine: auto` folds its verdict records when present and degrades to the local reviewer otherwise; the gate never synthesizes approval requests.
+Red lights are failed checks (a missing spec, a failing latest run, coverage below minimum, an unmapped edit, blocker/major findings) — each carries a rework suggestion. Warnings and skips never flip the decision. The gate integrates [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) as a weak dependency: `review.engine: auto` folds its verdict records when present and degrades to the local reviewer otherwise; `gate.tests.evalReports.enabled` folds its eval engine's dsh-eval report (prompt-regression / stress / fairness suites) into the test evidence and skips honestly when no report exists. The gate never synthesizes approval requests.
 
 ## Example report
 
@@ -189,10 +193,23 @@ Red lights are failed checks (a missing spec, a failing latest run, coverage bel
 - counts, ids, and verdicts only: no file contents or session text are embedded, and recognized secrets are redacted.
 ````
 
+## CI output
+
+`/gate run` also writes a `gate-report.json` (the same settled state as lossless JSON, next to `gate-report.md`). The `doublecheck-gate` CLI turns that file into machine-readable output for GitHub Actions:
+
+```sh
+# JSON (PR comment / status payload)
+doublecheck-gate --format json --input gate-report.json
+# SARIF 2.1.0 (code-scanning upload / status check)
+doublecheck-gate --format sarif < gate-report.json
+```
+
+The CLI only serializes the already-settled `GateState` — it never re-runs the four-phase gate or the evidence folds. Its exit code maps the verdict: `0` = deliverable, `1` = rework, `2` = usage/parse error.
+
 ## Permissions & data
 
 - **Reads**: the session log (`tool/call` / `tool/result` / `tool/code-dispatch`, injected `user/message` sources, and the foreign `autoReview/*` verdict records) in-process only; the optional plan-mode service state.
-- **Writes**: `doublecheck-spec.md`, `doublecheck-report.md`, and `gate-report.md` in the session workspace (paths configurable) through the `ctx.fs` seam; the durable `doublecheck/state` and `doublecheck/gate` session events.
+- **Writes**: `doublecheck-spec.md`, `doublecheck-report.md`, `gate-report.md`, and `gate-report.json` in the session workspace (paths configurable) through the `ctx.fs` seam; the durable `doublecheck/state` and `doublecheck/gate` session events.
 - **Model calls**: the gate's consistency and local-review phases (one subagent each per `/gate run`), the optional adversary review, and the `doublecheck_report` verification workflow start subagent runs; nothing else calls a model or the network.
 - **Never touched**: credentials, environment variables, or any file outside the session workspace. The workshop manifest declares `filesystem:read` and `filesystem:write` only. Gate reports carry counts, ids, and verdicts only; recognized secrets in reviewer texts are redacted before storage or display.
 
@@ -209,6 +226,7 @@ Red lights are failed checks (a missing spec, a failing latest run, coverage bel
 - **Durable writes.** `/doublecheck on\|off` → `doublecheck/state` and `/gate run` → `doublecheck/gate` ride the host's `ignorable` append surface (post-rc.6), which every supported host (≥ `0.1.1-rc.2`) provides.
 - **Optional seams.** The `doublecheck.gate` settings namespace registers only when the settings service is mounted; the `/gate status` plan-mode line reads the optional `ctx.planMode` (shows `unknown` without it); the adversary review needs `ctx.subagents`; verification needs `workflowEngine`.
 - **Local degrade.** `gate.review.engine: auto` degrades to the local reviewer when dsh-auto-review is absent or has no verdict records this session — the report names the reason instead of inventing a verdict.
+- **dsh-eval evidence is file-based.** The dsh-auto-review eval engine (`dsh-eval`) writes its prompt-regression / stress / fairness results to a workspace report file, not the session log. `gate.tests.evalReports.enabled` folds that file (off by default; skips when absent) and the folded counts ride the durable `doublecheck/gate` record so a settled run still replays.
 
 ## Development
 

package/README.pt.md

@@ -116,6 +116,10 @@ Todos os ajustes são campos `Config` do Schemastery (alteráveis a partir do co
 | `gate.tests.allowFailingRuns` | `0` | Execuções que falham após o último verde permitidas antes do vermelho. |
 | `gate.tests.requireCoverage` | `false` | Ligado exige evidência de cobertura na saída do teste. |
 | `gate.tests.minCoveragePct` | `80` | Percentual mínimo de cobertura (0–100). |
+| `gate.tests.evalReports.enabled` | `false` | Ligado dobra o relatório dsh-eval (o motor de avaliação do dsh-auto-review) na evidência de teste. |
+| `gate.tests.evalReports.dir` | `'.eval-reports'` | Diretório relativo ao espaço de trabalho que contém o relatório do motor. |
+| `gate.tests.evalReports.file` | `'report.json'` | Nome do arquivo de relatório dentro do diretório. |
+| `gate.tests.evalReports.required` | `false` | Um relatório ausente é uma luz vermelha exatamente quando true (um pulo caso contrário). |
 | `gate.consistency.*` | `provider: 'fork'`, `model: null`, `tools: ['read','glob','grep']`, `timeoutMs: 120000`, `maxFindings: 5` | Ajustes do revisor local de consistência (`model: null` = modelo principal). |
 | `gate.review.engine` | `'auto'` | `auto` = registros de veredicto do dsh-auto-review quando presentes, senão o revisor local; `local` = sempre local. |
 | `gate.review.provider` | `'fork'` | Provedor do revisor local de revisão (seu `model`/`tools`/`timeoutMs`/`maxFindings` coincidem com `gate.consistency.*`). |
@@ -143,11 +147,11 @@ O portão de entrega agrega a evidência durável da sessão em uma lista config
 | Fase | Verificações | Fonte de evidência | Custo de modelo |
 |---|---|---|---|
 | Interrogação de requisitos | Lista de perguntas-chave confirmadas item a item (seis perguntas de dimensão de spec por padrão) | `doublecheck_spec` confirmado + chamadas `ask_user_question` | nenhum |
-| Evidência de teste | Cor da última execução, execuções que falham após o verde, limite de cobertura opcional | Execuções de teste shell no registro de sessão (`[exit code: N]`, percentuais de cobertura) | nenhum |
+| Evidência de teste | Cor da última execução, execuções que falham após o verde, limite de cobertura opcional, relatório dsh-eval opcional | Execuções de teste shell no registro de sessão (`[exit code: N]`, percentuais de cobertura); o arquivo de relatório dsh-eval quando `gate.tests.evalReports.enabled` | nenhum |
 | Consistência de implementação | Mapeamento diff ↔ requisito: cada edição deve servir a uma dimensão de spec | Revisor bifurcado local (achados estruturados, ferramentas somente leitura) | um subagente |
 | Conclusão de revisão | O veredicto de entrega; `engine: auto` consome os registros de veredicto duráveis do dsh-auto-review quando presentes, senão o revisor local | Eventos `autoReview/verdict` / `autoReview/rejection`, ou o revisor bifurcado local | um subagente (local) |
 
-As luzes vermelhas são verificações que falharam (um spec ausente, uma última execução que falhou, cobertura abaixo do mínimo, uma edição sem mapeamento, achados blocker/major) — cada uma carrega uma sugestão de retrabalho. Avisos e pulos nunca invertem a decisão. O portão integra o [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) como dependência fraca: `review.engine: auto` dobra seus registros de veredicto quando presentes e degrada para o revisor local caso contrário; o portão nunca sintetiza solicitações de aprovação.
+As luzes vermelhas são verificações que falharam (um spec ausente, uma última execução que falhou, cobertura abaixo do mínimo, uma edição sem mapeamento, achados blocker/major) — cada uma carrega uma sugestão de retrabalho. Avisos e pulos nunca invertem a decisão. O portão integra o [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) como dependência fraca: `review.engine: auto` dobra seus registros de veredicto quando presentes e degrada para o revisor local caso contrário; `gate.tests.evalReports.enabled` dobra o relatório dsh-eval de seu motor de avaliação (suítes de regressão de prompt / estresse / equidade) na evidência de teste e pula honestamente quando não há relatório. O portão nunca sintetiza solicitações de aprovação.
 
 ## Relatório de exemplo
 
@@ -188,6 +192,19 @@ As luzes vermelhas são verificações que falharam (um spec ausente, uma últim
 - counts, ids, and verdicts only: no file contents or session text are embedded, and recognized secrets are redacted.
 ````
 
+## Saída do CI
+
+`/gate run` também grava um `gate-report.json` (o mesmo estado assentado que o JSON sem perda, ao lado de `gate-report.md`). O CLI `doublecheck-gate` converte esse arquivo em saída legível por máquina para o GitHub Actions:
+
+```sh
+# JSON (comentário de PR / payload de status)
+doublecheck-gate --format json --input gate-report.json
+# SARIF 2.1.0 (upload de code-scanning / verificação de status)
+doublecheck-gate --format sarif < gate-report.json
+```
+
+O CLI apenas serializa o `GateState` já assentado — nunca reexecuta a porta de quatro fases nem as dobras de evidência. Seu código de saída mapeia o veredicto: `0` = entregável, `1` = retrabalho, `2` = erro de uso/análise.
+
 ## Permissões e dados
 
 - **Lê**: o registro de sessão (`tool/call` / `tool/result` / `tool/code-dispatch`, fontes `user/message` injetadas e os registros de veredicto alheios `autoReview/*`) somente em processo; o estado opcional do serviço de modo plano.
@@ -208,6 +225,7 @@ As luzes vermelhas são verificações que falharam (um spec ausente, uma últim
 - **Escritas duráveis.** `/doublecheck on\|off` → `doublecheck/state` e `/gate run` → `doublecheck/gate` precisam da superfície de append `ignorable` do host (pós-rc.6), que todo host compatível (≥ `0.1.1-rc.2`) fornece.
 - **Interfaces opcionais.** O namespace de configurações `doublecheck.gate` é registrado apenas quando o serviço de configurações está montado; a linha de modo plano de `/gate status` lê o `ctx.planMode` opcional (mostra `unknown` sem ele); a revisão adversarial precisa de `ctx.subagents`; a verificação precisa de `workflowEngine`.
 - **Degradação local.** `gate.review.engine: auto` degrada para o revisor local quando o dsh-auto-review está ausente ou não tem registros de veredicto nesta sessão — o relatório nomeia a razão em vez de inventar um veredicto.
+- **A evidência dsh-eval é baseada em arquivos.** O motor de avaliação do dsh-auto-review (`dsh-eval`) grava seus resultados de regressão de prompt / estresse / equidade em um arquivo de relatório do espaço de trabalho, não no registro de sessão. `gate.tests.evalReports.enabled` dobra esse arquivo (desativado por padrão; pula quando ausente) e as contagens dobradas viajam no registro durável `doublecheck/gate` para que uma execução assentada ainda seja reproduzível.
 
 ## Desenvolvimento
 

package/README.zh.md

@@ -116,6 +116,10 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 | `gate.tests.allowFailingRuns` | `0` | 最近一次绿色之后允许的失败运行次数，超过则红灯。 |
 | `gate.tests.requireCoverage` | `false` | 开启则要求在测试输出中有覆盖率证据。 |
 | `gate.tests.minCoveragePct` | `80` | 最低覆盖率百分比（0–100）。 |
+| `gate.tests.evalReports.enabled` | `false` | 开启则把 dsh-eval 报告（dsh-auto-review 的评测引擎）并入测试证据。 |
+| `gate.tests.evalReports.dir` | `'.eval-reports'` | 存放引擎报告的工作区相对目录。 |
+| `gate.tests.evalReports.file` | `'report.json'` | 目录内的报告文件名。 |
+| `gate.tests.evalReports.required` | `false` | 为 true 时缺失报告即为红灯（否则跳过）。 |
 | `gate.consistency.*` | `provider: 'fork'`、`model: null`、`tools: ['read','glob','grep']`、`timeoutMs: 120000`、`maxFindings: 5` | 本地一致性评审者的旋钮（`model: null` = 主模型）。 |
 | `gate.review.engine` | `'auto'` | `auto` = 存在时使用 dsh-auto-review 的裁决记录，否则使用本地评审者；`local` = 始终使用本地评审者。 |
 | `gate.review.provider` | `'fork'` | 本地评审评审者的提供者（其 `model`/`tools`/`timeoutMs`/`maxFindings` 与 `gate.consistency.*` 相同）。 |
@@ -143,11 +147,11 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 | 阶段 | 检查 | 证据来源 | 模型成本 |
 |---|---|---|---|
 | 需求询问 | 逐项确认的关键问题清单（默认六个 spec 维度问题） | 已提交的 `doublecheck_spec` + `ask_user_question` 调用 | 无 |
-| 测试证据 | 最近运行颜色、绿色后的失败运行、可选覆盖率阈值 | 会话日志中的 shell 测试运行（`[exit code: N]`、覆盖率百分比） | 无 |
+| 测试证据 | 最近运行颜色、绿色后的失败运行、可选覆盖率阈值、可选 dsh-eval 报告 | 会话日志中的 shell 测试运行（`[exit code: N]`、覆盖率百分比）；开启 `gate.tests.evalReports.enabled` 时的 dsh-eval 报告文件 | 无 |
 | 实现一致性 | 差异 ↔ 需求映射：每次改动都必须服务于某个 spec 维度 | 本地分叉评审者（结构化发现、只读工具） | 一个 subagent |
 | 评审结论 | 交付裁决；`engine: auto` 在存在时消费 dsh-auto-review 的持久裁决记录，否则使用本地评审者 | `autoReview/verdict` / `autoReview/rejection` 事件，或本地分叉评审者 | 一个 subagent（本地） |
 
-红灯是失败的检查（缺失 spec、最近运行失败、覆盖率低于下限、未映射的改动、blocker/major 发现）——每一项都附带返工建议。警告与跳过永远不会翻转裁决。门禁将 [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) 作为弱依赖集成：`review.engine: auto` 在存在时折叠其裁决记录，否则降级到本地评审者；门禁从不合成审批请求。
+红灯是失败的检查（缺失 spec、最近运行失败、覆盖率低于下限、未映射的改动、blocker/major 发现）——每一项都附带返工建议。警告与跳过永远不会翻转裁决。门禁将 [dsh-auto-review](https://github.com/PerryLink/dsh-auto-review) 作为弱依赖集成：`review.engine: auto` 在存在时折叠其裁决记录，否则降级到本地评审者；`gate.tests.evalReports.enabled` 把其评测引擎的 dsh-eval 报告（prompt 回归 / 压测 / 公平性套件）并入测试证据，并在报告不存在时如实跳过。门禁从不合成审批请求。
 
 ## 示例报告
 
@@ -188,6 +192,19 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 - counts, ids, and verdicts only: no file contents or session text are embedded, and recognized secrets are redacted.
 ````
 
+## CI 输出
+
+`/gate run` 还会写一个 `gate-report.json`（与无损 JSON 相同的已定状态，位于 `gate-report.md` 旁边）。`doublecheck-gate` CLI 把该文件转成可供 GitHub Actions 使用的机器可读输出：
+
+```sh
+# JSON（PR 评论 / 状态载荷）
+doublecheck-gate --format json --input gate-report.json
+# SARIF 2.1.0（code-scanning 上传 / 状态检查）
+doublecheck-gate --format sarif < gate-report.json
+```
+
+CLI 只序列化已定的 `GateState` —— 它从不重新运行四阶段门禁或证据折叠。其退出码映射裁决：`0` = 可交付，`1` = 返工，`2` = 用法/解析错误。
+
 ## 权限与数据
 
 - **读取**：仅进程内读取会话日志（`tool/call` / `tool/result` / `tool/code-dispatch`、注入的 `user/message` 来源，以及外部的 `autoReview/*` 裁决记录）；可选的计划模式服务状态。
@@ -208,6 +225,7 @@ dsh --profile web --dump-config | grep -E -A3 'id: doublecheck-(grill|guard)'
 - **持久写入。** `/doublecheck on\|off` → `doublecheck/state` 与 `/gate run` → `doublecheck/gate` 需要宿主的 `ignorable` 追加接口（rc.6 之后），受支持宿主（≥ `0.1.1-rc.2`）均具备该接口。
 - **可选接口。** `doublecheck.gate` 设置命名空间仅在挂载设置服务时注册；`/gate status` 的计划模式行读取可选的 `ctx.planMode`（没有则显示 `unknown`）；对抗式评审需要 `ctx.subagents`；验证需要 `workflowEngine`。
 - **本地降级。** 当 dsh-auto-review 缺失或本会话没有裁决记录时，`gate.review.engine: auto` 会降级到本地评审者——报告会写明原因，而不是捏造裁决。
+- **dsh-eval 证据基于文件。** dsh-auto-review 评测引擎（`dsh-eval`）把其 prompt 回归 / 压测 / 公平性结果写入工作区报告文件，而非会话日志。`gate.tests.evalReports.enabled` 折叠该文件（默认关闭；缺失时跳过），折叠出的计数随持久 `doublecheck/gate` 记录保存，使已定的运行仍可重放。
 
 ## 开发
 

package/lib/ci.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Headless gate-report CLI for CI (`doublecheck-gate`).
+ *
+ * Consumes a serialized {@link GateState} (the JSON the gate settles and
+ * writes next to `gate-report.md`) and emits a machine-readable report for a
+ * GH Actions PR comment or status check. It does NOT re-run the four-phase
+ * gate — it only serializes the already-settled state — so the gate runner
+ * and the evidence folds stay exactly as they are.
+ *
+ * Usage:
+ *   doublecheck-gate --format json --input gate-report.json
+ *   doublecheck-gate --format sarif < gate-report.json
+ *
+ * Exit code: 0 = deliverable, 1 = rework, 2 = usage/parse error.
+ *
+ * @module dsh-doublecheck/ci
+ */
+export {};

package/lib/ci.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Headless gate-report CLI for CI (`doublecheck-gate`).
+ *
+ * Consumes a serialized {@link GateState} (the JSON the gate settles and
+ * writes next to `gate-report.md`) and emits a machine-readable report for a
+ * GH Actions PR comment or status check. It does NOT re-run the four-phase
+ * gate — it only serializes the already-settled state — so the gate runner
+ * and the evidence folds stay exactly as they are.
+ *
+ * Usage:
+ *   doublecheck-gate --format json --input gate-report.json
+ *   doublecheck-gate --format sarif < gate-report.json
+ *
+ * Exit code: 0 = deliverable, 1 = rework, 2 = usage/parse error.
+ *
+ * @module dsh-doublecheck/ci
+ */
+import { readFileSync } from 'node:fs';
+import { renderGateReportJson, renderGateReportSarif } from "./domain/gate.js";
+/** Parse CLI arguments into `{ format, input }`. */
+function parseArgs(argv) {
+    let format = 'json';
+    let input = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--format' || arg === '-f') {
+            const next = argv[index + 1];
+            if (next !== 'json' && next !== 'sarif')
+                throw new Error(`--format must be json or sarif, got ${JSON.stringify(next)}`);
+            format = next;
+            index += 1;
+        }
+        else if (arg === '--input' || arg === '-i') {
+            input = argv[index + 1] ?? null;
+            if (input === null)
+                throw new Error('--input requires a file path');
+            index += 1;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            throw new Error('usage: doublecheck-gate [--format json|sarif] [--input <file>]');
+        }
+        else if (!arg.startsWith('-')) {
+            input = arg;
+        }
+        else {
+            throw new Error(`unknown argument ${JSON.stringify(arg)}`);
+        }
+    }
+    return { format, input };
+}
+/** Read the gate-state JSON from the input file or stdin (fd 0). */
+function readState(input) {
+    const raw = input !== null ? readFileSync(input, 'utf8') : readFileSync(0, 'utf8');
+    return JSON.parse(raw);
+}
+/** Render and print the report, returning the process exit code. */
+function main(argv) {
+    let format;
+    let input;
+    try {
+        ;
+        ({ format, input } = parseArgs(argv));
+        const state = readState(input);
+        process.stdout.write((format === 'sarif' ? renderGateReportSarif : renderGateReportJson)(state) + '\n');
+        return state.verdict === 'rework' ? 1 : 0;
+    }
+    catch (error) {
+        process.stderr.write(`doublecheck-gate: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 2;
+    }
+}
+process.exitCode = main(process.argv.slice(2));

package/lib/domain/gate.d.ts

@@ -156,6 +156,19 @@ export interface TestsGateConfig {
     /** Minimum coverage percentage when coverage is required. */
     minCoveragePct: number;
 }
+/** The dsh-eval evidence sub-config of the tests phase (weak dependency). */
+export interface EvalReportsConfig {
+    /** Off keeps the tests phase purely session-log-derived (default). */
+    enabled: boolean;
+    /** Workspace-relative directory holding the engine's report file. */
+    dir: string;
+    /** Report file name inside {@link dir}. */
+    file: string;
+    /** A missing report is a red light exactly when true (a skip otherwise). */
+    required: boolean;
+}
+/** Default eval-evidence sub-config: off, so the gate never reads files by default. */
+export declare const DEFAULT_EVAL_REPORTS_CONFIG: EvalReportsConfig;
 /**
  * Evaluate the tests phase: the latest run color, the open red window, and
  * (optionally) the coverage percentage. Deterministic — no model calls.
@@ -164,6 +177,54 @@ export interface TestsGateConfig {
  * @returns the settled phase result.
  */
 export declare function evaluateTests(evidence: TestEvidence, config: TestsGateConfig): GatePhaseResult;
+/** The dsh-eval report evidence folded from one report file (counts only). */
+export interface EvalReportEvidence {
+    /** The suite name, or `dsh-eval` when the report omits it. */
+    suite: string;
+    /** Total cases in the suite. */
+    total: number;
+    /** Cases that passed. */
+    pass: number;
+    /** Cases that failed an assertion. */
+    fail: number;
+    /** Cases that errored before settling. */
+    error: number;
+    /** Cases cancelled. */
+    cancelled: number;
+    /** ISO finish timestamp, or '' when the report omits it. */
+    finishedAt: string;
+}
+/**
+ * Parse a dsh-eval `report.json` (the dsh-auto-review eval engine's machine
+ * report) into audit-safe counts. Structural and tolerant: the engine is a
+ * foreign weak dependency, so a malformed or unrelated file yields null
+ * instead of throwing. No case text or assertion detail is read — only the
+ * suite name, the five summary counts, and the finish timestamp.
+ * @param raw - the parsed JSON document.
+ * @returns the folded evidence, or null when the document is not a dsh-eval report.
+ */
+export declare function parseEvalReport(raw: unknown): EvalReportEvidence | null;
+/**
+ * Evaluate the dsh-eval evidence check: a present report whose suite passed
+ * every case is a pass, a report with failing/erroring/cancelled cases is a
+ * red light, and a missing report is a skip (the weak dependency) — or a red
+ * light when `required` is set. Audit-safe: counts and the suite name only.
+ * @param evidence - the folded report, or null when none was readable.
+ * @param config - the eval-evidence sub-config.
+ * @param reason - why the report was unreadable (for the skip/red notice).
+ * @returns the eval-evidence check.
+ */
+export declare function evaluateEvalEvidence(evidence: EvalReportEvidence | null, config: EvalReportsConfig, reason: string): GateCheck;
+/**
+ * Attach the eval-evidence check to a settled tests phase (the file fold is
+ * async and lives in the guard row, so the domain exposes the merge).
+ * @param result - the settled tests-phase result.
+ * @param evidence - the folded report, or null.
+ * @param config - the eval-evidence sub-config.
+ * @param reason - why the report was unreadable.
+ * @returns the tests-phase result with the eval check appended.
+ */
+export declare function attachEvalChecks(result: GatePhaseResult, evidence: EvalReportEvidence | null, config: EvalReportsConfig, reason: string): GatePhaseResult;
 /** The structured output the consistency and local review subagents must satisfy. */
 export declare const GATE_FINDINGS_SCHEMA: ObjectJsonSchema;
 /**
@@ -261,3 +322,50 @@ export declare function renderGateReportMarkdown(state: GateState, planSuggestio
 export declare function renderPhaseMarkdown(result: GatePhaseResult): string[];
 /** Human-readable phase headings (stable English audit ids). */
 export declare function phaseLabel(phase: GatePhase): string;
+/**
+ * The machine-readable CI report derived from a settled gate state. Lossless
+ * JSON over the same counts/ids/verdicts the markdown report carries — no
+ * session text or file contents — so a GH Actions step can consume it for a
+ * PR comment or status check. The four-phase runner and the evidence folds
+ * are unchanged; this is a pure serialization of their settled output.
+ */
+export interface CiReport {
+    readonly schemaVersion: 1;
+    readonly tool: 'dsh-doublecheck';
+    readonly verdict: GateVerdict;
+    /** Convenience boolean: true when the delivery may proceed. */
+    readonly deliverable: boolean;
+    readonly reviewEngine: GateReviewEngine;
+    readonly at: string;
+    /** Number of failing (red) checks across enabled phases. */
+    readonly redChecks: number;
+    readonly phases: Array<{
+        readonly phase: GatePhase;
+        readonly enabled: boolean;
+        readonly status: GateCheckStatus;
+        readonly checks: Array<{
+            readonly id: string;
+            readonly label: string;
+            readonly status: GateCheckStatus;
+            readonly summary: string;
+            readonly suggestion: string;
+        }>;
+    }>;
+}
+/** Build the JSON-safe CI report from a settled gate state. */
+export declare function buildCiReport(state: GateState): CiReport;
+/**
+ * Render the settled gate state as headless JSON for CI (`--ci` output).
+ * @param state - the settled gate state.
+ * @returns the pretty-printed JSON report.
+ */
+export declare function renderGateReportJson(state: GateState): string;
+/**
+ * Render the settled gate state as a SARIF 2.1.0 document for CI
+ * (GitHub code-scanning / status checks). Each failing check is an `error`
+ * result and each warning is a `warning` result; passing/skipped/pending
+ * checks are declared as rules but produce no result.
+ * @param state - the settled gate state.
+ * @returns the pretty-printed SARIF document.
+ */
+export declare function renderGateReportSarif(state: GateState): string;

package/lib/domain/gate.js

@@ -241,6 +241,13 @@ export function evaluateRequirements(evidence, config) {
     }
     return { phase: 'requirements', enabled: true, status: worstStatus(checks), checks };
 }
+/** Default eval-evidence sub-config: off, so the gate never reads files by default. */
+export const DEFAULT_EVAL_REPORTS_CONFIG = {
+    enabled: false,
+    dir: '.eval-reports',
+    file: 'report.json',
+    required: false,
+};
 /**
  * Evaluate the tests phase: the latest run color, the open red window, and
  * (optionally) the coverage percentage. Deterministic — no model calls.
@@ -304,6 +311,93 @@ export function evaluateTests(evidence, config) {
     }
     return { phase: 'tests', enabled: true, status: worstStatus(checks), checks };
 }
+/**
+ * Parse a dsh-eval `report.json` (the dsh-auto-review eval engine's machine
+ * report) into audit-safe counts. Structural and tolerant: the engine is a
+ * foreign weak dependency, so a malformed or unrelated file yields null
+ * instead of throwing. No case text or assertion detail is read — only the
+ * suite name, the five summary counts, and the finish timestamp.
+ * @param raw - the parsed JSON document.
+ * @returns the folded evidence, or null when the document is not a dsh-eval report.
+ */
+export function parseEvalReport(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const report = raw;
+    const summary = report.summary;
+    if (typeof summary !== 'object' || summary === null)
+        return null;
+    const counts = summary;
+    const total = counts.total;
+    const pass = counts.pass;
+    const fail = counts.fail;
+    const error = counts.error;
+    const cancelled = counts.cancelled;
+    if (!Number.isInteger(total) || !Number.isInteger(pass) || !Number.isInteger(fail)
+        || !Number.isInteger(error) || !Number.isInteger(cancelled)) {
+        return null;
+    }
+    const finishedAt = report.finishedAt;
+    return {
+        suite: typeof report.suite === 'string' && report.suite.length > 0 ? report.suite : 'dsh-eval',
+        total: total,
+        pass: pass,
+        fail: fail,
+        error: error,
+        cancelled: cancelled,
+        finishedAt: typeof finishedAt === 'number'
+            ? new Date(finishedAt).toISOString()
+            : typeof finishedAt === 'string' ? finishedAt : '',
+    };
+}
+/**
+ * Evaluate the dsh-eval evidence check: a present report whose suite passed
+ * every case is a pass, a report with failing/erroring/cancelled cases is a
+ * red light, and a missing report is a skip (the weak dependency) — or a red
+ * light when `required` is set. Audit-safe: counts and the suite name only.
+ * @param evidence - the folded report, or null when none was readable.
+ * @param config - the eval-evidence sub-config.
+ * @param reason - why the report was unreadable (for the skip/red notice).
+ * @returns the eval-evidence check.
+ */
+export function evaluateEvalEvidence(evidence, config, reason) {
+    if (evidence === null) {
+        return {
+            id: 'eval-report',
+            phase: 'tests',
+            label: 'dsh-eval evidence (prompt regression / stress / fairness)',
+            status: config.required ? 'fail' : 'skip',
+            summary: `no dsh-eval report found${reason !== '' ? ` (${reason})` : ''}`,
+            suggestion: config.required
+                ? 'run dsh-eval and write its report to the configured path before delivering'
+                : '',
+        };
+    }
+    const allPassed = evidence.total > 0 && evidence.fail === 0 && evidence.error === 0 && evidence.cancelled === 0;
+    return {
+        id: 'eval-report',
+        phase: 'tests',
+        label: 'dsh-eval evidence (prompt regression / stress / fairness)',
+        status: allPassed ? 'pass' : 'fail',
+        summary: allPassed
+            ? `${evidence.pass}/${evidence.total} cases passed (dsh-eval suite "${evidence.suite}")`
+            : `${evidence.fail} failed, ${evidence.error} errored, ${evidence.cancelled} cancelled of ${evidence.total} cases (dsh-eval suite "${evidence.suite}")`,
+        suggestion: allPassed ? '' : 'fix the failing dsh-eval cases and re-run the suite',
+    };
+}
+/**
+ * Attach the eval-evidence check to a settled tests phase (the file fold is
+ * async and lives in the guard row, so the domain exposes the merge).
+ * @param result - the settled tests-phase result.
+ * @param evidence - the folded report, or null.
+ * @param config - the eval-evidence sub-config.
+ * @param reason - why the report was unreadable.
+ * @returns the tests-phase result with the eval check appended.
+ */
+export function attachEvalChecks(result, evidence, config, reason) {
+    const checks = [...result.checks, evaluateEvalEvidence(evidence, config, reason)];
+    return { ...result, checks, status: worstStatus(checks) };
+}
 /** The structured output the consistency and local review subagents must satisfy. */
 export const GATE_FINDINGS_SCHEMA = {
     type: 'object',
@@ -656,3 +750,87 @@ export function phaseLabel(phase) {
         case 'review': return 'Review conclusion';
     }
 }
+/** Build the JSON-safe CI report from a settled gate state. */
+export function buildCiReport(state) {
+    return {
+        schemaVersion: 1,
+        tool: 'dsh-doublecheck',
+        verdict: state.verdict,
+        deliverable: state.verdict === 'deliverable',
+        reviewEngine: state.reviewEngine,
+        at: state.at,
+        redChecks: countRedChecks(Object.values(state.phases)),
+        phases: GATE_PHASES.map(phase => {
+            const result = state.phases[phase];
+            return {
+                phase,
+                enabled: result?.enabled ?? false,
+                status: result?.status ?? 'pending',
+                checks: (result?.checks ?? []).map(check => ({
+                    id: check.id,
+                    label: check.label,
+                    status: check.status,
+                    summary: check.summary,
+                    suggestion: check.suggestion,
+                })),
+            };
+        }),
+    };
+}
+/**
+ * Render the settled gate state as headless JSON for CI (`--ci` output).
+ * @param state - the settled gate state.
+ * @returns the pretty-printed JSON report.
+ */
+export function renderGateReportJson(state) {
+    return JSON.stringify(buildCiReport(state), null, 2);
+}
+/**
+ * Render the settled gate state as a SARIF 2.1.0 document for CI
+ * (GitHub code-scanning / status checks). Each failing check is an `error`
+ * result and each warning is a `warning` result; passing/skipped/pending
+ * checks are declared as rules but produce no result.
+ * @param state - the settled gate state.
+ * @returns the pretty-printed SARIF document.
+ */
+export function renderGateReportSarif(state) {
+    const rules = [];
+    const results = [];
+    for (const phase of GATE_PHASES) {
+        const result = state.phases[phase];
+        if (result === undefined || !result.enabled)
+            continue;
+        for (const check of result.checks) {
+            const ruleId = `doublecheck/${phase}/${check.id}`;
+            rules.push({ id: ruleId, shortDescription: { text: `${phaseLabel(phase)} — ${check.label}` } });
+            if (check.status === 'pass' || check.status === 'skip' || check.status === 'pending')
+                continue;
+            results.push({
+                ruleId,
+                level: check.status === 'fail' ? 'error' : 'warning',
+                message: { text: check.suggestion !== '' ? `${check.summary} — rework: ${check.suggestion}` : check.summary },
+            });
+        }
+    }
+    const sarif = {
+        version: '2.1.0',
+        $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+        runs: [{
+                tool: {
+                    driver: {
+                        name: 'dsh-doublecheck',
+                        informationUri: 'https://github.com/PerryLink/dsh-doublecheck',
+                        rules,
+                    },
+                },
+                properties: {
+                    verdict: state.verdict,
+                    deliverable: state.verdict === 'deliverable',
+                    reviewEngine: state.reviewEngine,
+                    at: state.at,
+                },
+                results,
+            }],
+    };
+    return JSON.stringify(sarif, null, 2);
+}

package/lib/guard/gate.d.ts

@@ -29,7 +29,7 @@ import type { CommandInvocation, CommandResult } from '@deepseek-ai/dsh-commands
 import type { UserMessage } from '@deepseek-ai/dsh-llm';
 import type Schema from '@deepseek-ai/schemastery';
 import type { TestRunDetection } from '../domain/evidence.js';
-import { type GateQuestion, type GateState, type GateVerdict } from '../domain/gate.js';
+import { type EvalReportsConfig, type GateQuestion, type GateState, type GateVerdict } from '../domain/gate.js';
 import type { GuardProse, ProseLanguage } from './prose.js';
 /** The reviewer knobs shared by the consistency and review phases. */
 export interface GateReviewerConfig {
@@ -76,6 +76,8 @@ export interface GateConfig {
         minCoveragePct: number;
         /** Regex (one capture group) parsing a coverage percentage from test output. */
         coveragePattern: string;
+        /** The dsh-eval (dsh-auto-review eval engine) report fold. */
+        evalReports: EvalReportsConfig;
     };
     /** The implementation-consistency phase (local forked reviewer). */
     consistency: GateReviewerConfig;

package/lib/guard/gate.js

@@ -25,7 +25,7 @@
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import z from '@deepseek-ai/schemastery';
-import { countRedChecks, DEFAULT_COVERAGE_PATTERN, DEFAULT_GATE_QUESTIONS, deriveGateVerdict, evaluateConsistency, evaluateRequirements, evaluateReview, evaluateTests, foldAutoReviewEvidence, foldRequirementsEvidence, foldTestEvidence, GATE_FINDINGS_SCHEMA, renderGateReportMarkdown, renderPhaseMarkdown, skippedPhase, } from "../domain/gate.js";
+import { attachEvalChecks, countRedChecks, DEFAULT_COVERAGE_PATTERN, DEFAULT_EVAL_REPORTS_CONFIG, DEFAULT_GATE_QUESTIONS, deriveGateVerdict, evaluateConsistency, evaluateRequirements, evaluateReview, evaluateTests, foldAutoReviewEvidence, foldRequirementsEvidence, foldTestEvidence, GATE_FINDINGS_SCHEMA, parseEvalReport, renderGateReportJson, renderGateReportMarkdown, renderPhaseMarkdown, skippedPhase, } from "../domain/gate.js";
 import { sortFindings } from "./review.js";
 import { PROSE } from "./prose.js";
 /** The default gate configuration: every phase on, the six key questions required. */
@@ -46,6 +46,7 @@ export const DEFAULT_GATE_CONFIG = {
         requireCoverage: false,
         minCoveragePct: 80,
         coveragePattern: DEFAULT_COVERAGE_PATTERN,
+        evalReports: { ...DEFAULT_EVAL_REPORTS_CONFIG },
     },
     consistency: {
         enabled: true,
@@ -91,7 +92,13 @@ export const GateConfigSchema = z.object({
         requireCoverage: z.boolean().default(false),
         minCoveragePct: z.number().default(80),
         coveragePattern: z.string().min(1).default(DEFAULT_COVERAGE_PATTERN),
-    }).default({ ...DEFAULT_GATE_CONFIG.tests }),
+        evalReports: z.object({
+            enabled: z.boolean().default(false),
+            dir: z.string().min(1).default('.eval-reports'),
+            file: z.string().min(1).default('report.json'),
+            required: z.boolean().default(false),
+        }).default({ ...DEFAULT_EVAL_REPORTS_CONFIG }),
+    }).default({ ...DEFAULT_GATE_CONFIG.tests, evalReports: { ...DEFAULT_EVAL_REPORTS_CONFIG } }),
     consistency: z.object({
         enabled: z.boolean().default(true),
         provider: z.string().min(1).default('fork'),
@@ -176,6 +183,12 @@ export function validateGateConfig(gate) {
     catch {
         throw new Error(`dsh-doublecheck: invalid gate.tests.coveragePattern "${gate.tests.coveragePattern}"`);
     }
+    if (gate.tests.evalReports.dir.trim() === '') {
+        throw new Error('dsh-doublecheck: gate.tests.evalReports.dir must not be empty');
+    }
+    if (gate.tests.evalReports.file.trim() === '') {
+        throw new Error('dsh-doublecheck: gate.tests.evalReports.file must not be empty');
+    }
     for (const [label, reviewer] of [['consistency', gate.consistency], ['review', gate.review]]) {
         if (!Number.isInteger(reviewer.maxFindings) || reviewer.maxFindings < 1 || reviewer.maxFindings > 20) {
             throw new Error(`dsh-doublecheck: gate.${label}.maxFindings must be within 1..20`);
@@ -302,9 +315,16 @@ export async function runGate(ctx, config, detection, agent, signal, language) {
     const requirements = config.requirements.enabled
         ? evaluateRequirements(foldRequirementsEvidence(events, config.requirements.interrogateTool), { checklist: config.requirements.checklist, minConfirmed: config.requirements.minConfirmed })
         : skippedPhase('requirements');
-    const tests = config.tests.enabled
+    let tests = config.tests.enabled
         ? evaluateTests(foldTestEvidence(events, detection, coverageRegex), config.tests)
         : skippedPhase('tests');
+    if (config.tests.enabled && config.tests.evalReports.enabled) {
+        // Weak dependency on dsh-auto-review's eval engine: fold its report file
+        // (prompt-regression / stress / fairness suites) into the tests phase.
+        // A missing or malformed report settles as skip/red, never a throw.
+        const read = await readEvalEvidence(ctx, config.tests.evalReports, agent, signal);
+        tests = attachEvalChecks(tests, read.evidence, config.tests.evalReports, read.reason);
+    }
     const prose = PROSE[language];
     const consistencyTask = language === 'zh' ? CONSISTENCY_TASK_ZH : CONSISTENCY_TASK_EN;
     const consistencyPromise = config.consistency.enabled
@@ -376,19 +396,63 @@ async function writeGateFile(ctx, filePath, state, agent, signal) {
     const fs = ctx.get('fs');
     if (fs === undefined)
         return;
-    let target;
     try {
-        target = await fs.resolve(filePath, {
+        const markdownTarget = await fs.resolve(filePath, {
+            ...agent.session.header.cwd !== undefined ? { cwd: agent.session.header.cwd } : {},
+            signal,
+        });
+        await fs.writeText(markdownTarget, renderGateReportMarkdown(state, true), undefined, signal);
+        // The headless CI copy: the same settled state as JSON, for the
+        // `doublecheck-gate` CLI (PR comment / status checks). Additive output —
+        // the markdown report and the four-phase runner are unchanged.
+        const ciTarget = await fs.resolve(ciReportPath(filePath), {
             ...agent.session.header.cwd !== undefined ? { cwd: agent.session.header.cwd } : {},
             signal,
         });
-        await fs.writeText(target, renderGateReportMarkdown(state, true), undefined, signal);
+        await fs.writeText(ciTarget, renderGateReportJson(state), undefined, signal);
     }
     catch (error) {
         signal.throwIfAborted();
         ctx.logger.debug(`dsh-doublecheck: gate report file write skipped: ${String(error)}`);
     }
 }
+/** Derive the JSON CI-report path from the markdown report path. */
+function ciReportPath(filePath) {
+    return filePath.endsWith('.md') ? `${filePath.slice(0, -3)}.json` : `${filePath}.json`;
+}
+/**
+ * Read and fold the dsh-eval report through the filesystem seam. A missing
+ * seam, a missing file, malformed JSON, or a wrong document shape all settle
+ * as `evidence: null` with a reason — never a throw (the weak dependency).
+ * @param ctx - plugin context carrying the fs seam.
+ * @param evalConfig - the eval-evidence sub-config.
+ * @param agent - the gated agent (its session cwd anchors the path).
+ * @param signal - the caller's cancellation signal.
+ * @returns the fold.
+ */
+async function readEvalEvidence(ctx, evalConfig, agent, signal) {
+    const fs = ctx.get('fs');
+    if (fs === undefined)
+        return { evidence: null, reason: 'the filesystem seam is not mounted' };
+    const dir = evalConfig.dir.replace(/\/+$/, '');
+    const reportPath = dir === '' || dir === '.' ? evalConfig.file : `${dir}/${evalConfig.file}`;
+    let target;
+    try {
+        target = await fs.resolve(reportPath, {
+            ...agent.session.header.cwd !== undefined ? { cwd: agent.session.header.cwd } : {},
+            signal,
+        });
+        const text = await fs.readText(target, signal);
+        const evidence = parseEvalReport(JSON.parse(text));
+        if (evidence === null)
+            return { evidence: null, reason: `"${reportPath}" is not a dsh-eval report` };
+        return { evidence, reason: '' };
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        return { evidence: null, reason: `cannot read "${reportPath}": ${String(error)}` };
+    }
+}
 /** The latest `doublecheck/gate` record of a session, or null before any run. */
 function latestGateRecord(events) {
     for (let index = events.length - 1; index >= 0; index -= 1) {
@@ -513,6 +577,6 @@ export function renderGateConfigMarkdown(config) {
     config.requirements.checklist.forEach((question, index) => {
         lines.push(`| ${index + 1} | ${question.id} | ${question.question} | ${question.specDimension ?? '—'} | ${question.required ? 'yes' : 'no'} |`);
     });
-    lines.push('', `- minimum confirmed: ${config.requirements.minConfirmed}`, `- interrogation tool: ${config.requirements.interrogateTool}`, '', '## Test evidence', '', `- require passing run: ${config.tests.requirePassingRun}`, `- allowed failing runs after green: ${config.tests.allowFailingRuns}`, `- require coverage: ${config.tests.requireCoverage}`, `- minimum coverage: ${config.tests.minCoveragePct}%`, `- coverage pattern: \`${config.tests.coveragePattern}\``, '', '## Implementation consistency', '', `- enabled: ${config.consistency.enabled}`, `- reviewer provider: ${config.consistency.provider}`, `- max findings: ${config.consistency.maxFindings}`, `- tools: ${config.consistency.tools.join(', ')}`, '', '## Review conclusion', '', `- enabled: ${config.review.enabled}`, `- engine: ${config.review.engine} (auto = dsh-auto-review verdict records when present, else the local reviewer)`, `- reviewer provider: ${config.review.provider}`, `- max findings: ${config.review.maxFindings}`, `- tools: ${config.review.tools.join(', ')}`, '');
+    lines.push('', `- minimum confirmed: ${config.requirements.minConfirmed}`, `- interrogation tool: ${config.requirements.interrogateTool}`, '', '## Test evidence', '', `- require passing run: ${config.tests.requirePassingRun}`, `- allowed failing runs after green: ${config.tests.allowFailingRuns}`, `- require coverage: ${config.tests.requireCoverage}`, `- minimum coverage: ${config.tests.minCoveragePct}%`, `- coverage pattern: \`${config.tests.coveragePattern}\``, `- dsh-eval evidence: ${config.tests.evalReports.enabled ? `on (\`${config.tests.evalReports.dir}/${config.tests.evalReports.file}\`, required: ${config.tests.evalReports.required})` : 'off'}`, '', '## Implementation consistency', '', `- enabled: ${config.consistency.enabled}`, `- reviewer provider: ${config.consistency.provider}`, `- max findings: ${config.consistency.maxFindings}`, `- tools: ${config.consistency.tools.join(', ')}`, '', '## Review conclusion', '', `- enabled: ${config.review.enabled}`, `- engine: ${config.review.engine} (auto = dsh-auto-review verdict records when present, else the local reviewer)`, `- reviewer provider: ${config.review.provider}`, `- max findings: ${config.review.maxFindings}`, `- tools: ${config.review.tools.join(', ')}`, '');
     return lines.join('\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-doublecheck",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "description": "Delivery quality gate for DeepSeek Harness: grill the requirements, test the implementation, prove the delivery, and gate the handoff with a deliverable/rework decision.",
   "packageManager": "pnpm@11.7.0",
   "repository": {
@@ -14,6 +14,9 @@
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "bin": {
+    "doublecheck-gate": "lib/ci.js"
+  },
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",

package/strict.patch.yml

@@ -53,6 +53,11 @@
         requireCoverage: true
         minCoveragePct: 80
         coveragePattern: 'coverage[^\\d]{0,40}(\\d+(?:\\.\\d+)?)\\s*%'
+        evalReports:
+          enabled: false
+          dir: '.eval-reports'
+          file: 'report.json'
+          required: false
       consistency:
         enabled: true
         provider: fork