dsh-doublecheck 0.5.0 → 0.6.0

package/README.pt.md

@@ -2,7 +2,8 @@
 
 > **Verifique duas vezes antes de publicar: interrogue os requisitos, teste a implementação, comprove a entrega.**
 
-[![version](https://img.shields.io/badge/version-0.5.0-blue)](https://github.com/PerryLink/dsh-doublecheck/releases)
+[![version](https://img.shields.io/badge/version-0.6.0-blue)](https://github.com/PerryLink/dsh-doublecheck/releases)
+[![npm](https://img.shields.io/npm/v/dsh-doublecheck)](https://www.npmjs.com/package/dsh-doublecheck)
 [![license](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
 [![topics](https://img.shields.io/badge/topics-dsh%20%7C%20dsh--plugin-22c55e)](https://github.com/topics/dsh-plugin)
 
@@ -35,20 +36,23 @@ grill ──▶ design ──▶ red ──▶ green ──▶ review ──▶
 | **review** | Um crítico adversário bifurcado audita a entrega contra o spec. | ✅ v0.3 |
 | **verify** | `doublecheck_report` + um workflow de verificação por dimensão comprovam a entrega. | ✅ v0.4 |
 
-## Recursos (v0.5)
+## Recursos
 
 - 🔥 **Skill `grill-requirements`** — um skill empacotado no formato Agent Skills que interroga a tarefa em seis dimensões (**objetivo, escopo, critérios de aceite, modos de falha, prioridades, não-objetivos**) usando a UI nativa `ask_user_question` do DSH, recusa escrever código até o consenso e registra o contrato.
 - 🧰 **Skills de etapa para o ciclo inteiro** — `red-green-tdd` (escreva o teste que falha, rode red, implemente, rode green), `delivery-review` (autorrevisão adversária contra o spec uma vez em green) e `delivery-proof` (consolide a evidência no relatório de entrega antes de declarar concluído) juntam-se ao `grill-requirements`: as seis etapas têm orientação de modelo, não só a primeira.
-- 📜 **Ferramenta `doublecheck_spec`** — grava o spec acordado no log da sessão e escreve uma cópia em markdown no workspace, para o contrato sobreviver à conversa.
+- 📜 **Ferramenta `doublecheck_spec`** — grava o spec acordado no log da sessão e escreve uma cópia em markdown no workspace, para o contrato sobreviver à conversa. Dimensões vazias ou só com espaços são rejeitadas no commit (v0.6): o grill precisa assentar as seis antes de o spec contar.
 - 🔄 **Re-grill na mudança de tarefa** — um spec registrado cobre a própria tarefa: um novo pedido direto do usuário após o último spec reabre o portão grill para esse follow-up, em vez de herdar o contrato anterior em silêncio.
 - 🛡️ **Guard de disciplina** — um portão suave no pipeline de políticas de ferramentas. Tarefa vaga + sem spec + rumo a `edit`/`write` → **lembrar**, **pedir aprovação humana** ou **bloquear**, conforme `intensity`.
-- 🟥🟩 **Portões de evidência red/green** (`modules.tdd`) — verificações duras sobre o log da sessão: uma edição de implementação exige um **teste que falha registrado** desde o último teste que passa (escrever arquivos de teste é sempre permitido — é assim que o passo red acontece), e um turno que termina com edições mas sem nenhum teste que passa recebe um lembrete green injetado.
-- 👁️ **Revisão adversária** (`modules.adversary`) — assim que a entrega chega ao green, um subagente crítico bifurcado (seam nativo de subagentes do DSH, provider `fork` por padrão) audita a sessão contra o spec registrado com postura adversária e devolve achados estruturados. `remind` injeta a crítica; `warn`/`block` ainda direcionam uma rodada para o modelo responder aos achados. `adversaryModel` roteia o crítico para um modelo separado; a allowlist de ferramentas do crítico é somente leitura por padrão. Os achados trafegam pela fonte de mensagens durável `doublecheck-review`. A revisão se rearma quando o crítico termina: edições de implementação após o último registro de revisão disparam outra rodada, e cancelar o turno aborta o crítico em voo.
+- 🟥🟩 **Portões de evidência red/green** (`modules.tdd`) — verificações duras sobre o log da sessão: uma edição de implementação exige um **teste que falha registrado** desde o último teste que passa (escrever arquivos de teste é sempre permitido — é assim que o passo red acontece), e um turno que termina com edições mas sem nenhum teste que passa recebe um lembrete green injetado. Ferramentas guard personalizadas funcionam de cara: os portões leem as chaves de argumento `file_path` e `path`, e uma chamada que não nomeia arquivo nenhum não é tratada como edição de implementação.
+- 👁️ **Revisão adversária** (`modules.adversary`) — assim que a entrega chega ao green, um subagente crítico bifurcado (seam nativo de subagentes do DSH, provider `fork` por padrão) audita a sessão contra o spec registrado com postura adversária e devolve achados estruturados, ordenados com blockers primeiro. `remind` injeta a crítica; `warn`/`block` ainda direcionam uma rodada para o modelo responder aos achados. `adversaryModel` roteia o crítico para um modelo separado; a allowlist de ferramentas do crítico é somente leitura por padrão. Os achados trafegam pela fonte de mensagens durável `doublecheck-review`. A revisão se rearma quando o crítico termina: edições de implementação após o último registro de revisão disparam outra rodada, e cancelar o turno aborta o crítico em voo.
+- 🌐 **Superfície de modelo totalmente localizada** — toda string visível ao modelo que o pacote injeta ou responde (lembretes, feedback de negação/consulta, direcionamento de revisão, avisos de troca, respostas do `/doublecheck` e o prompt de tarefa do crítico) respeita `language: 'en' | 'zh'`; os documentos spec/report do workspace mantêm seus cabeçalhos estáveis em inglês.
 - 📊 **Relatório doublecheck + workflow de verificação** (`doublecheck_report`, v0.4) — consolida a evidência de disciplina da sessão (spec, cronologia red/green, achados da revisão, edições) em um relatório de entrega com um veredito derivado (`grill → draft → red → green → objections/verified → proven/challenged/unverified`), gravado no workspace. Com `verify`, os verificadores por dimensão rodam pelo seam de workflow do DSH (`verifyMode: all` lança um verificador paralelo por dimensão; `single` executa um combinado) e os vereditos se dobram no relatório — `proven` exige um veredito para cada dimensão.
 - 🚦 **Portão de entrega** — no limite do turno, uma entrega que chegou ao green sem `doublecheck_report` registrado recebe um lembrete de relatório esperado antes de declarar concluído; um relatório bem-sucedido avança a etapa para `verify`.
-- 🔁 **Estado durável** — todo artefato visível ao modelo (spec, lembretes, feedback de negação, achados da revisão, o interruptor `/doublecheck on|off`) fica no log da sessão; as decisões dos portões derivam só do log (`tool/call` + `tool/result`, incluindo os sub-despachos do Code Mode), então sessões retomadas ou bifurcadas se comportam igual. `remindOnce` também é durável: uma sessão que já recebeu um lembrete nunca o recebe duas vezes, mesmo após reiniciar.
-- ⌨️ **Comando de sessão `/doublecheck`** — `status` informa o interruptor efetivo, os módulos configurados e a etapa dobrada; `report` dobra o relatório de entrega na hora; `on|off` grava o override durável `doublecheck/state` e injeta um aviso de troca.
+- 🔁 **Estado durável** — todo artefato visível ao modelo (spec, lembretes, feedback de negação, achados da revisão, o interruptor `/doublecheck on|off`) fica no log da sessão; as decisões dos portões derivam só do log (`tool/call` + `tool/result`, incluindo os sub-despachos do Code Mode), então sessões retomadas ou bifurcadas se comportam igual. `remindOnce` também é durável: uma sessão que já recebeu um lembrete nunca o recebe duas vezes, mesmo após reiniciar. A dobra do interruptor viaja num snapshot incremental, então sessões longas ficam em O(eventos novos) por chamada de ferramenta.
+- ⌨️ **Comando de sessão `/doublecheck`** — `status` informa o interruptor efetivo, os módulos configurados, a intensidade de aplicação e os fatos de etapa dobrados (spec, cor dos testes, revisão, contagem de edições); `report` dobra o relatório de entrega na hora; `on|off` grava o override durável `doublecheck/state` e injeta um aviso de troca.
 - 📚 **Ferramenta `doublecheck_skills`** — lista e carrega os skills do pacote pelo seam oficial do registro de skills.
+- 🔒 **Overlay estrito** — `strict.patch.yml` liga todos os portões com intensidade `block` numa única camada de patch (vem com o pacote).
+- 🧩 **Companheiro invariante independente** — a linha `dsh-doublecheck/invariant` é uma exportação de subrota real: relata contradições do caminho de escrita do pacote (forma spec/report/review) pelo registro `invariants` do host sem carregar o guard.
 
 ## Demo
 
@@ -76,13 +80,19 @@ As duas linhas de plugin ativam automaticamente com o profile. Instalação por
 
 ```sh
 pnpm pack
-dsh plugin --profile <name> add ./dsh-doublecheck-0.5.0.tgz
+dsh plugin --profile <name> add ./dsh-doublecheck-0.6.0.tgz
 ```
 
 Instalação por git dispensa npm:
 
 ```sh
-dsh plugin --profile <name> add "github:PerryLink/dsh-doublecheck#v0.5.0"
+dsh plugin --profile <name> add "github:PerryLink/dsh-doublecheck#v0.6.0"
+```
+
+Para um modo estrito sem configuração (todos os portões ligados, intensidade `block`), aplique o overlay incluído por cima do bundle patch:
+
+```sh
+dsh --profile <name> --patch ./node_modules/dsh-doublecheck/strict.patch.yml
 ```
 
 ## Desinstalação
@@ -131,6 +141,7 @@ Sobrescreva qualquer linha **por id** no `cordis.patch.yml` do profile. Um patch
       - '(?:^|[;&|]\s*)(?:(?:pnpm|npm|npx|yarn|bun)(?:\s+run)?\s+(?:test|vitest|jest|mocha)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:(?:pytest|go\s+test|cargo\s+test|make\s+test|ctest)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:node\s+--test(?:\s|$))'
+      - '(?:^|[;&|]\s*)(?:deno\s+test|uv\s+run\s+pytest)(?:\s|$)'
     reportMutationTools: ['edit', 'write']
     reportTestFilePatterns:
       - '(^|[\\/])(tests?|__tests__|specs?)([\\/]|$)'
@@ -156,11 +167,14 @@ Sobrescreva qualquer linha **por id** no `cordis.patch.yml` do profile. Um patch
       - '(?:^|[;&|]\s*)(?:(?:pnpm|npm|npx|yarn|bun)(?:\s+run)?\s+(?:test|vitest|jest|mocha)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:(?:pytest|go\s+test|cargo\s+test|make\s+test|ctest)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:node\s+--test(?:\s|$))'
+      - '(?:^|[;&|]\s*)(?:deno\s+test|uv\s+run\s+pytest)(?:\s|$)'
     testFilePatterns:
       - '(^|[\\/])(tests?|__tests__|specs?)([\\/]|$)'
       - '\\.(test|spec)\\.[A-Za-z0-9]+$'
 ```
 
+O `strict.patch.yml` incluído é exatamente esta linha guard com `intensity: block` e todos os módulos ligados — aplique-o como camada de patch depois do bundle patch para o modo estrito sem editar um profile à mão.
+
 ### `intensity`
 
 | Valor | Comportamento diante de um `edit`/`write` controlado pelo portão |
@@ -174,13 +188,13 @@ Sobrescreva qualquer linha **por id** no `cordis.patch.yml` do profile. Um patch
 | Chave | Padrão | Significado |
 |---|---|---|
 | `modules.grill` | `true` | `false` desativa o portão grill. O interruptor dos skills/ferramentas grill é o flag `disabled` da linha deles. |
-| `modules.tdd` | `false` | `true` ativa os portões de evidência red/green (v0.2). |
+| `modules.tdd` | `true` | `true` ativa os portões de evidência red/green (v0.2); ativado por padrão desde v0.5. |
 | `modules.adversary` | `false` | `true` ativa a revisão do crítico bifurcado no green (v0.3); usa o seam `ctx.subagents` — um seam ausente se resolve como um aviso «indisponível». |
 | `guardTools` | `['edit', 'write']` | Nomes de ferramentas de mutação que o guard vigia. |
 | `vagueTaskMaxChars` | `200` | Tarefas mais longas nunca são tratadas como vagas. Tarefas breves que citam arquivo, caminho, URL, palavra-chave com sublinhado ou palavra-chave hifenizada são concretas. |
 | `remindOnce` | `true` | Injetar o lembrete de cada portão no máximo uma vez por sessão. |
 | `testToolNames` | `['bash', 'pwsh']` | Nomes de ferramentas de shell que podem executar testes. |
-| `testCommandPatterns` | *(pnpm/npm/yarn/bun test, pytest, go/cargo/make test, node --test)* | Expressões regulares com as quais um comando deve coincidir para contar como execução de teste. |
+| `testCommandPatterns` | *(pnpm/npm/yarn/bun test, pytest, go/cargo/make test, node --test, deno test, uv run pytest)* | Expressões regulares com as quais um comando deve coincidir para contar como execução de teste. |
 | `testFilePatterns` | *(diretórios de teste, `*.test.*` / `*.spec.*`)* | Expressões regulares que identificam arquivos de teste — sempre editáveis, isentos do portão red. |
 | `adversaryModel` | `null` | Rota do modelo crítico; `null` = o modelo principal se autorrevisa. |
 | `adversaryProvider` | `'fork'` | Nome do provider de subagentes onde o crítico roda. |
@@ -228,10 +242,23 @@ Sem mudanças no agent-loop. Todo registro é um `ctx.effect` / `ctx.on` / `regi
 - Os lembretes chegam como contexto `{kind:'plugin'}`, então as UIs de transcrição os exibem como metadados de injeção.
 - A crítica do adversário chega da mesma forma depois que o crítico se estabelece, com achados marcados por severidade; sob `warn`/`block` o ciclo é direcionado uma rodada para que o modelo os responda.
 - `doublecheck_report` devolve o relatório consolidado como resultado de ferramenta (spec, cronologia de testes, revisão, verificação, veredito), então «comprovar a entrega» está a uma chamada de distância.
+- `/doublecheck` responde direto na transcrição: `status` mostra o interruptor, os módulos, a intensidade e os fatos de etapa; `report` imprime o relatório dobrado; `on|off` muda o interruptor da sessão.
+
+## Comando de sessão
+
+```
+/doublecheck status|report|on|off
+```
+
+- `status` — interruptor efetivo (o override durável vence o padrão da config), módulos configurados, intensidade de aplicação e os fatos de etapa dobrados (spec registrado, cor red/green, revisão em registro, contagem de edições).
+- `report` — dobra o relatório de entrega a partir do log da sessão na hora (sem workflow de verificação; `doublecheck_report` é dono desse caminho).
+- `on` / `off` — grava o evento durável `doublecheck/state` (sobrevive a reinício, retomada e bifurcação — o replay É o estado) e injeta um aviso de troca visível ao modelo.
+
+Todas as respostas do comando respeitam o ajuste `language` da linha guard.
 
 ## Roadmap
 
-O ciclo de disciplina de seis etapas está completo: **grill → design → red → green → review → verify** — todas embarcam neste pacote (v0.1 → v0.4). Trabalho futuro: cobertura de snapshot para as transcrições de revisão/relatório e formatação de relatório mais rica.
+O ciclo de disciplina de seis etapas está completo: **grill → design → red → green → review → verify** — todas embarcam neste pacote (v0.1 → v0.6). Fixtures de regressão com transcrições reais fixam as formas dos eventos duráveis (`tests/fixtures/`). Trabalho futuro: formatação de relatório mais rica, um selo de status de disciplina na Web UI e a semeadura de spec entre sessões a partir do arquivo do workspace.
 
 ## Desenvolvimento
 

package/README.zh.md

@@ -2,7 +2,8 @@
 
 > **发布前先双重检查：追问需求、验证实现、证明交付。**
 
-[![version](https://img.shields.io/badge/version-0.5.0-blue)](https://github.com/PerryLink/dsh-doublecheck/releases)
+[![version](https://img.shields.io/badge/version-0.6.0-blue)](https://github.com/PerryLink/dsh-doublecheck/releases)
+[![npm](https://img.shields.io/npm/v/dsh-doublecheck)](https://www.npmjs.com/package/dsh-doublecheck)
 [![license](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
 [![topics](https://img.shields.io/badge/topics-dsh%20%7C%20dsh--plugin-22c55e)](https://github.com/topics/dsh-plugin)
 [![CI](https://img.shields.io/github/actions/workflow/status/PerryLink/dsh-doublecheck/ci.yml?branch=main)](https://github.com/PerryLink/dsh-doublecheck/actions/workflows/ci.yml)
@@ -35,20 +36,23 @@ grill ──▶ design ──▶ red ──▶ green ──▶ review ──▶
 | **review** | 派生对抗 critic 子代理，把交付与 spec 逐条对质。 | ✅ v0.3 |
 | **verify** | `doublecheck_report` + 逐维度核对 workflow，证明交付。 | ✅ v0.4 |
 
-## v0.5 功能
+## 功能
 
 - 🔥 **`grill-requirements` 技能** —— 按通用 Agent Skills 格式打包的技能，围绕六个维度（**目标、边界、验收标准、失败模式、优先级、非目标**）连环追问，使用 DSH 原生 `ask_user_question` 界面；共识达成前拒绝写代码，并记录契约。
 - 🧰 **覆盖全循环的阶段技能** —— `red-green-tdd`（先写失败测试、跑红、实现、跑绿）、`delivery-review`（green 之后对照 spec 做对抗式自审）、`delivery-proof`（把证据汇总成交付报告后再宣称完成）与 `grill-requirements` 一起发货，六个阶段都有模型指引，而不再只有第一阶段。
-- 📜 **`doublecheck_spec` 工具** —— 把拷问出的 spec 写入会话日志，并在工作区落一份 markdown，让契约不随对话消失。
+- 📜 **`doublecheck_spec` 工具** —— 把拷问出的 spec 写入会话日志，并在工作区落一份 markdown，让契约不随对话消失。提交时拒绝空或纯空白的维度（v0.6）：grill 必须把六个维度全部敲定，spec 才算数。
 - 🔄 **任务变更重新 grill** —— 已提交的 spec 只覆盖它自己的任务：spec 提交之后用户新发的直接请求会让 grill 门对该后续请求重新开启，而不是悄悄沿用旧契约。
 - 🛡️ **纪律 guard** —— 挂在工具策略管线上的软门。模糊任务 + 没有 spec + 直奔 `edit`/`write` → 按 `intensity` 分别**提醒**、**请求人工批准**或**拦截**。
-- 🟥🟩 **红/绿证据门**（`modules.tdd`）—— 会话日志硬校验：实现改动要求日志里**存在失败测试运行**（自上次通过以来；写测试文件永远放行——那正是 red 步骤）；回合结束时若有改动却没有通过测试运行，则注入 green 提醒。
-- 👁️ **对抗评审**（`modules.adversary`）—— 交付到达 green 后，经 DSH 原生 subagent 接缝（默认 `fork` provider）派生一个 critic 子代理，以对抗视角核对会话与已提交 spec，产出结构化 findings。`remind` 只注入评审意见；`warn`/`block` 额外 steer 一轮让模型正面回应 findings。`adversaryModel` 可把评审路由到独立模型；critic 工具白名单默认只读。findings 随 `doublecheck-review` 消息源持久结构化落盘。评审会持久化重武装：最新评审记录之后的实现编辑会触发下一轮评审；取消回合会中止在途 critic。
+- 🟥🟩 **红/绿证据门**（`modules.tdd`）—— 会话日志硬校验：实现改动要求日志里**存在失败测试运行**（自上次通过以来；写测试文件永远放行——那正是 red 步骤）；回合结束时若有改动却没有通过测试运行，则注入 green 提醒。自定义 guard 工具开箱即用：门会读取 `file_path` 与 `path` 两种参数键，完全未命名任何文件的调用不视为实现改动。
+- 👁️ **对抗评审**（`modules.adversary`）—— 交付到达 green 后，经 DSH 原生 subagent 接缝（默认 `fork` provider）派生一个 critic 子代理，以对抗视角核对会话与已提交 spec，产出结构化 findings，并按 blocker 优先排序返回。`remind` 只注入评审意见；`warn`/`block` 额外 steer 一轮让模型正面回应 findings。`adversaryModel` 可把评审路由到独立模型；critic 工具白名单默认只读。findings 随 `doublecheck-review` 消息源持久结构化落盘。评审会持久化重武装：最新评审记录之后的实现编辑会触发下一轮评审；取消回合会中止在途 critic。
 - 📊 **Doublecheck 报告 + 核对 workflow**（`doublecheck_report`，v0.4）—— 把会话纪律证据（spec、红/绿时间线、评审 findings、编辑数）汇总成交付报告并推导 verdict（`grill → draft → red → green → objections/verified → proven/challenged/unverified`），落盘工作区。开启 `verify` 时，经 DSH workflow 接缝派发逐维度核对员（`verifyMode: all` 每维度并行一个；`single` 合并为一个核对员）并并入报告——`proven` 要求每个维度都有裁决。
 - 🚦 **交付门** —— 回合结束时，已到 green 但没有 `doublecheck_report` 记录的交付会收到「报告待补」提醒；成功报告会把阶段折叠推进到 `verify`。
-- 🔁 **持久化状态** —— 所有模型可见内容（spec、提醒、拒绝反馈、评审 findings、`/doublecheck on|off` 开关）都落会话日志；门禁判定完全由日志（`tool/call` + `tool/result`，含 Code Mode 子派发）推导，恢复/派生会话同样生效。`remindOnce` 同样持久化：已收到提醒的会话重启后不会重复收到。
-- ⌨️ **`/doublecheck` 会话命令** —— `status` 报告生效开关、已配置模块与折叠阶段；`report` 当场折叠交付报告；`on|off` 写入持久 `doublecheck/state` 事件并注入切换通知。
+- 🔁 **持久化状态** —— 所有模型可见内容（spec、提醒、拒绝反馈、评审 findings、`/doublecheck on|off` 开关）都落会话日志；门禁判定完全由日志（`tool/call` + `tool/result`，含 Code Mode 子派发）推导，恢复/派生会话同样生效。`remindOnce` 同样持久化：已收到提醒的会话重启后不会重复收到。开关折叠基于增量快照，长会话每次工具调用只摊 O(新增事件) 成本。
+- 🌐 **全本地化的模型界面** —— 本包注入或回答的每一个模型可见字符串（提醒、拒绝/询问反馈、评审 steering、切换通知、`/doublecheck` 回复、critic 的任务提示词）都遵循 `language: 'en' | 'zh'`；工作区 spec/report 文档保持其稳定的英文标题。
+- ⌨️ **`/doublecheck` 会话命令** —— `status` 报告生效开关、已配置模块、执行强度与折叠阶段事实（spec、测试颜色、评审、编辑数）；`report` 当场折叠交付报告；`on|off` 写入持久 `doublecheck/state` 事件并注入切换通知。
 - 📚 **`doublecheck_skills` 工具** —— 通过官方技能注册表接缝列出与加载本包技能。
+- 🔒 **严格 overlay** —— `strict.patch.yml` 在一个 patch 层中把每道门都以 `block` 强度打开（随包发布）。
+- 🧩 **独立 invariant 伴生行** —— `dsh-doublecheck/invariant` 子路径导出真实可用：无需加载 guard，即可通过宿主 `invariants` 注册表上报本包写入路径的矛盾（spec/report/review 结构）。
 
 ## 演示
 
@@ -76,13 +80,19 @@ dsh --profile <name> --dump-config   # 应看到 "# == dsh-doublecheck" 层
 
 ```sh
 pnpm pack
-dsh plugin --profile <name> add ./dsh-doublecheck-0.5.0.tgz
+dsh plugin --profile <name> add ./dsh-doublecheck-0.6.0.tgz
 ```
 
 git 安装不需要 npm：
 
 ```sh
-dsh plugin --profile <name> add "github:PerryLink/dsh-doublecheck#v0.5.0"
+dsh plugin --profile <name> add "github:PerryLink/dsh-doublecheck#v0.6.0"
+```
+
+想要零配置的严格模式（所有门开启、`block` 强度），在 bundle patch 之上叠加随包发布的 overlay：
+
+```sh
+dsh --profile <name> --patch ./node_modules/dsh-doublecheck/strict.patch.yml
 ```
 
 ## 卸载
@@ -131,6 +141,7 @@ dsh plugin --profile <name> remove dsh-doublecheck
       - '(?:^|[;&|]\s*)(?:(?:pnpm|npm|npx|yarn|bun)(?:\s+run)?\s+(?:test|vitest|jest|mocha)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:(?:pytest|go\s+test|cargo\s+test|make\s+test|ctest)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:node\s+--test(?:\s|$))'
+      - '(?:^|[;&|]\s*)(?:deno\s+test|uv\s+run\s+pytest)(?:\s|$)'
     reportMutationTools: ['edit', 'write']
     reportTestFilePatterns:
       - '(^|[\\/])(tests?|__tests__|specs?)([\\/]|$)'
@@ -156,11 +167,14 @@ dsh plugin --profile <name> remove dsh-doublecheck
       - '(?:^|[;&|]\s*)(?:(?:pnpm|npm|npx|yarn|bun)(?:\s+run)?\s+(?:test|vitest|jest|mocha)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:(?:pytest|go\s+test|cargo\s+test|make\s+test|ctest)(?:\s|$))'
       - '(?:^|[;&|]\s*)(?:node\s+--test(?:\s|$))'
+      - '(?:^|[;&|]\s*)(?:deno\s+test|uv\s+run\s+pytest)(?:\s|$)'
     testFilePatterns:
       - '(^|[\\/])(tests?|__tests__|specs?)([\\/]|$)'
       - '\\.(test|spec)\\.[A-Za-z0-9]+$'
 ```
 
+随包发布的 `strict.patch.yml` 正是这行 guard 配置在 `intensity: block` 且所有模块开启——把它作为 patch 层叠加在 bundle patch 之后，即可获得严格模式而无需手动编辑 profile。
+
 ### `intensity`
 
 | 取值 | 对被门禁拦截的 `edit`/`write` 的处理 |
@@ -182,7 +196,7 @@ dsh plugin --profile <name> remove dsh-doublecheck
 | `vagueTaskMaxChars` | `200` | 超过此长度的任务一律不算模糊；简短任务提到文件名、路径、URL、下划线关键词或连字符关键词即为具体。 |
 | `remindOnce` | `true` | 每道门每个会话最多注入一次提醒——持久化：从日志折叠，重启/恢复后不会重复。 |
 | `testToolNames` | `['bash', 'pwsh']` | 可运行测试的 shell 工具名。 |
-| `testCommandPatterns` | *（pnpm/npm/yarn/bun test、pytest、go/cargo/make test、node --test）* | 命令需匹配的正则才算测试运行。 |
+| `testCommandPatterns` | *（pnpm/npm/yarn/bun test、pytest、go/cargo/make test、node --test、deno test、uv run pytest）* | 命令需匹配的正则才算测试运行。 |
 | `testFilePatterns` | *（测试目录、`*.test.*`/`*.spec.*`）* | 识别测试文件的正则——永远可编辑，豁免 red 门。 |
 | `adversaryModel` | `null` | critic 模型路由；`null` = 主模型自评。 |
 | `adversaryProvider` | `'fork'` | critic 使用的 subagent provider 名。 |
@@ -239,13 +253,15 @@ dsh plugin --profile <name> remove dsh-doublecheck
 /doublecheck status|report|on|off
 ```
 
-- `status` —— 生效开关（持久覆盖优先于配置默认）、已配置模块与折叠阶段（spec 是否提交、red/green 颜色、评审是否在档）。
+- `status` —— 生效开关（持久覆盖优先于配置默认）、已配置模块、执行强度与折叠阶段事实（spec 是否提交、red/green 颜色、评审是否在档、编辑数）。
 - `report` —— 当场从会话日志折叠交付报告（不跑验证工作流；验证属于 `doublecheck_report` 工具）。
 - `on` / `off` —— 写入持久 `doublecheck/state` 事件（跨重启/恢复/派生生效——重放即状态）并注入模型可见的切换通知。
 
+所有命令回复都遵循 guard 行的 `language` 设置。
+
 ## 路线图
 
-六阶段纪律环已全部完成：**grill → design → red → green → review → verify** 均随本包交付（v0.1 → v0.5）。真实转录回归夹具（`tests/fixtures/`）锁定持久事件形态。后续工作：更丰富的报告格式、Web UI 纪律状态徽章、以及从工作区 spec 文件播种跨会话状态。
+六阶段纪律环已全部完成：**grill → design → red → green → review → verify** 均随本包交付（v0.1 → v0.6）。真实转录回归夹具（`tests/fixtures/`）锁定持久事件形态。后续工作：更丰富的报告格式、Web UI 纪律状态徽章、以及从工作区 spec 文件播种跨会话状态。
 
 ## 开发
 

package/lib/domain/evidence.d.ts

@@ -70,7 +70,10 @@ export declare function shellCommand(name: string, args: Record<string, unknown>
 export declare function isTestCommand(command: string, detection: TestRunDetection): boolean;
 /**
  * The mutation target path of a tool call, when the tool is a configured
- * mutation tool and its arguments name a file.
+ * mutation tool and its arguments name a file. Accepts both the DSH-native
+ * `file_path` key (`edit` / `write`) and the `path` key custom guard tools
+ * may use, so a configured tool is never mis-gated merely for its argument
+ * shape.
  * @param name - the called tool name.
  * @param args - the parsed arguments record.
  * @param detection - the compiled detection knobs.

package/lib/domain/evidence.js

@@ -16,6 +16,7 @@ export const DEFAULT_TEST_COMMAND_PATTERNS = [
     '(?:^|[;&|]\\s*)(?:(?:pnpm|npm|npx|yarn|bun)(?:\\s+run)?\\s+(?:test|vitest|jest|mocha)(?:\\s|$))',
     '(?:^|[;&|]\\s*)(?:(?:pytest|go\\s+test|cargo\\s+test|make\\s+test|ctest)(?:\\s|$))',
     '(?:^|[;&|]\\s*)(?:node\\s+--test(?:\\s|$))',
+    '(?:^|[;&|]\\s*)(?:deno\\s+test|uv\\s+run\\s+pytest)(?:\\s|$)',
 ];
 /** Shared defaults: mutation tools and test-file path patterns. */
 export const DEFAULT_MUTATION_TOOLS = ['edit', 'write'];
@@ -103,7 +104,10 @@ export function isTestCommand(command, detection) {
 }
 /**
  * The mutation target path of a tool call, when the tool is a configured
- * mutation tool and its arguments name a file.
+ * mutation tool and its arguments name a file. Accepts both the DSH-native
+ * `file_path` key (`edit` / `write`) and the `path` key custom guard tools
+ * may use, so a configured tool is never mis-gated merely for its argument
+ * shape.
  * @param name - the called tool name.
  * @param args - the parsed arguments record.
  * @param detection - the compiled detection knobs.
@@ -112,7 +116,8 @@ export function isTestCommand(command, detection) {
 export function mutationTargetPath(name, args, detection) {
     if (!detection.mutationTools.includes(name))
         return undefined;
-    const path = args?.['file_path'];
+    const filePath = args?.['file_path'];
+    const path = filePath ?? args?.['path'];
     return typeof path === 'string' && path.length > 0 ? path : undefined;
 }
 /**

package/lib/domain/vocabulary.d.ts

@@ -20,6 +20,8 @@ export interface GrilledSpec {
     /** What the user explicitly does not want. */
     nonGoals: string;
 }
+/** All six spec fields, in declaration order. */
+export declare const SPEC_FIELD_NAMES: readonly (keyof GrilledSpec)[];
 /** One structured objection from the adversary review. */
 export interface ReviewFinding {
     /** How much the finding threatens the delivery claim. */

package/lib/domain/vocabulary.js

@@ -5,6 +5,10 @@
  *
  * @module dsh-doublecheck/domain/vocabulary
  */
+/** All six spec fields, in declaration order. */
+export const SPEC_FIELD_NAMES = [
+    'goal', 'scope', 'acceptanceCriteria', 'failureModes', 'priorities', 'nonGoals',
+];
 /** All verify dimensions, in spec order. */
 export const VERIFY_DIMENSIONS = [
     'goal',

package/lib/grill/index.js

@@ -18,7 +18,7 @@ import z from '@deepseek-ai/schemastery';
 import { DEFAULT_MUTATION_TOOLS, DEFAULT_TEST_COMMAND_PATTERNS, DEFAULT_TEST_FILE_PATTERNS, DEFAULT_TEST_TOOL_NAMES, compileDetection, } from "../domain/evidence.js";
 import { SPEC_TOOL_NAME } from "../domain/stages.js";
 import { buildVerifyScript, deriveReportVerdict, foldReportFacts, renderReportMarkdown, VERIFY_META, } from "../domain/report.js";
-import { VERIFY_DIMENSIONS } from "../domain/vocabulary.js";
+import { SPEC_FIELD_NAMES, VERIFY_DIMENSIONS } from "../domain/vocabulary.js";
 import { BundledSkillProvider, PROVIDER_NAME } from "./provider.js";
 export const name = 'doublecheck-grill';
 export const inject = ['skills', 'tools'];
@@ -215,6 +215,13 @@ export function apply(ctx, config) {
                 priorities: args.priorities,
                 nonGoals: args.nonGoals,
             };
+            // Fail fast at the commit: an empty dimension would satisfy the gate
+            // shape while recording an uncheckable contract. The grill must settle
+            // every dimension before the spec counts.
+            const empty = SPEC_FIELD_NAMES.filter(field => spec[field].trim() === '');
+            if (empty.length > 0) {
+                throw new Error(`doublecheck_spec: the spec dimension(s) ${empty.join(', ')} must not be empty; finish the requirements grill before committing the spec`);
+            }
             const outcome = await writeSpecFile(ctx, spec, args.filePath ?? config.specFile, exec);
             if (exec.agent !== undefined) {
                 ctx.emit('doublecheck/spec', { session: exec.agent.session, spec, ...outcome });

package/lib/guard/command.d.ts

@@ -34,6 +34,13 @@ export interface CommandDeps {
     snapshotOf: (session: Session) => Snapshot;
     /** The compiled test-run detection shared with the tdd/adversary gates. */
     detection: TestRunDetection;
+    /**
+     * The effective session switch — the exact reader the gates use (local
+     * override → durable `doublecheck/state` → configured default), so the
+     * command answers consistently with what the gates enforce, including on
+     * rc.6 hosts where the override is process-local.
+     */
+    effectiveEnabled: (session: Session) => boolean;
     /** Whether the host append surface stamps `ignorable` (see {@link hostStampsIgnorable}). */
     stampsIgnorable: () => boolean;
     /** Record a process-local switch override when the durable write is unavailable. */

package/lib/guard/command.js

@@ -16,6 +16,7 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { Session, SessionId } from '@deepseek-ai/dsh-session';
 import { deriveReportVerdict, foldReportFacts, renderReportMarkdown } from "../domain/report.js";
+import { PROSE } from "./prose.js";
 /**
  * Whether this host's `Session.append` stamps the `ignorable` envelope marker.
  * Detected once per process on a detached probe session: hosts without the
@@ -54,14 +55,11 @@ export function effectiveDoublecheckEnabled(events, fallback) {
     return fallback;
 }
 /** The switch notice injected after `/doublecheck on|off`. */
-function switchNotice(enabled, durable) {
+function switchNotice(enabled, durable, prose) {
     const source = { kind: 'plugin', plugin: 'dsh-doublecheck', form: 'notice', summary: 'doublecheck state' };
-    const scope = durable
-        ? 'for this session'
-        : 'for this process only (this harness build predates the ignorable append surface, so the switch is not durable)';
     const text = enabled
-        ? `Double-check discipline was switched ON ${scope} (changed by the user): the requirements grill, the red/green gates, and the delivery review are active again.`
-        : `Double-check discipline was switched OFF ${scope} (changed by the user): the discipline gates defer to the human approval chain until switched back on.`;
+        ? durable ? prose.switchOnDurable : prose.switchOnLocal
+        : durable ? prose.switchOffDurable : prose.switchOffLocal;
     return createUserMessage({ content: [{ type: 'text', text }], source });
 }
 /**
@@ -70,26 +68,32 @@ function switchNotice(enabled, durable) {
  * @returns the command handler for `ctx.commands.register`.
  */
 export function doublecheckHandler(deps) {
-    const { config, snapshotOf, detection, stampsIgnorable, setLocalOverride } = deps;
+    const { config, snapshotOf, detection, stampsIgnorable, setLocalOverride, effectiveEnabled } = deps;
+    const prose = PROSE[config.language];
     return (invocation) => {
         const agent = invocation.agent;
         if (agent === undefined) {
-            return { kind: 'error', text: '/doublecheck needs an agent session to inspect.' };
+            return { kind: 'error', text: prose.commandNoAgent };
         }
         const session = agent.session;
         const input = invocation.rawInput.trim().toLowerCase();
-        const enabled = effectiveDoublecheckEnabled(session.events, config.enableByDefault);
+        const enabled = effectiveEnabled(session);
         if (input === 'status' || input === '') {
             const snapshot = snapshotOf(session);
             const discipline = snapshot.discipline;
             return {
                 kind: 'success',
-                text: [
-                    `Double-check discipline is ${enabled ? 'ON' : 'OFF'} for this session. (/doublecheck on|off)`,
-                    `Modules: grill=${config.modules.grill ? 'on' : 'off'}, tdd=${config.modules.tdd ? 'on' : 'off'}, adversary=${config.modules.adversary ? 'on' : 'off'} (cordis.yml).`,
-                    `Stage: spec=${discipline.hasSpec ? 'committed' : 'missing'}, tests=${discipline.color}, review=${snapshot.lastReviewSeq >= 0 ? 'on record' : 'not run'}.`,
-                    'Usage: /doublecheck status|report|on|off',
-                ].join('\n'),
+                text: prose.commandStatus({
+                    enabled,
+                    defaultEnabled: config.enableByDefault,
+                    modules: config.modules,
+                    intensity: config.intensity,
+                    remindOnce: config.remindOnce,
+                    hasSpec: discipline.hasSpec,
+                    color: discipline.color,
+                    reviewed: snapshot.lastReviewSeq >= 0,
+                    editCount: discipline.editCount,
+                }),
             };
         }
         if (input === 'report') {
@@ -104,11 +108,11 @@ export function doublecheckHandler(deps) {
             return { kind: 'success', text: renderReportMarkdown(report) };
         }
         if (input !== 'on' && input !== 'off') {
-            return { kind: 'error', text: `Unknown /doublecheck argument "${invocation.rawInput.trim()}". Usage: /doublecheck status|report|on|off` };
+            return { kind: 'error', text: prose.commandUnknown(invocation.rawInput.trim()) };
         }
         const target = input === 'on';
         if (enabled === target) {
-            return { kind: 'success', text: `Double-check discipline is already ${input.toUpperCase()} for this session.` };
+            return { kind: 'success', text: target ? prose.commandAlreadyOn : prose.commandAlreadyOff };
         }
         // Adaptive durable write: only hosts that stamp `ignorable` may write the
         // state event; on rc.6 the options bag is ignored and an unmarked foreign
@@ -121,12 +125,12 @@ export function doublecheckHandler(deps) {
         else {
             setLocalOverride(session, target);
         }
-        agent.inject(switchNotice(target, durable));
+        agent.inject(switchNotice(target, durable, prose));
         return {
             kind: 'success',
-            text: durable
-                ? `Double-check discipline ${input.toUpperCase()} for this session.`
-                : `Double-check discipline ${input.toUpperCase()} for this process only (not durable on this harness).`,
+            text: target
+                ? durable ? prose.commandOnDurable : prose.commandOnLocal
+                : durable ? prose.commandOffDurable : prose.commandOffLocal,
         };
     };
 }

package/lib/guard/index.d.ts

@@ -102,6 +102,8 @@ export interface Snapshot {
     lastReviewSeq: number;
     /** Implementation edits folded after {@link lastReviewSeq}. */
     editsAfterReview: number;
+    /** The last durable `doublecheck/state` switch on record, when one exists. */
+    stateEnabled?: boolean;
 }
 /**
  * Install the guard listeners.

package/lib/guard/index.js

@@ -36,7 +36,7 @@ import { PROSE } from "./prose.js";
 import { applyDoublecheckEvent, emptyDoublecheckState, viewDoublecheck, } from "../domain/projection.js";
 import { doublecheckViewSchema } from "../types.js";
 import { installInvariant, PACKAGE_NAME } from "../invariant.js";
-import { doublecheckHandler, effectiveDoublecheckEnabled, hostStampsIgnorable } from "./command.js";
+import { doublecheckHandler, hostStampsIgnorable } from "./command.js";
 export const name = 'doublecheck-guard';
 export const inject = ['commands'];
 export const Config = z.object({
@@ -91,9 +91,14 @@ export function apply(ctx, config) {
     const pendingReminders = new WeakMap();
     /** Process-local switch overrides written by `/doublecheck on|off` on hosts that cannot store the durable event. */
     const localOverrides = new WeakMap();
-    /** The effective switch for a session: the local override first, then the durable log fold. */
+    /**
+     * The effective switch for a session: the local override first, then the
+     * durable `doublecheck/state` fold, then the configured default. The fold
+     * rides the same incremental snapshot as the discipline facts, so the read
+     * costs O(new events) instead of rescanning the log per tool call.
+     */
     function doublecheckEnabled(session) {
-        return localOverrides.get(session) ?? effectiveDoublecheckEnabled(session.events, config.enableByDefault);
+        return localOverrides.get(session) ?? snapshotOf(session).stateEnabled ?? config.enableByDefault;
     }
     const prose = PROSE[config.language];
     /**
@@ -138,6 +143,9 @@ export function apply(ctx, config) {
                     }
                 }
             }
+            else if (event.type === 'doublecheck/state') {
+                snapshot.stateEnabled = event.data.enabled;
+            }
             else if (event.type === 'tool/call' && event.seq > snapshot.lastReviewSeq) {
                 // Implementation edits after the latest review re-arm the adversary
                 // trigger for a second review round.
@@ -224,6 +232,7 @@ export function apply(ctx, config) {
             config,
             snapshotOf,
             detection,
+            effectiveEnabled: doublecheckEnabled,
             stampsIgnorable: hostStampsIgnorable,
             setLocalOverride: (session, enabled) => localOverrides.set(session, enabled),
         }),
@@ -293,11 +302,13 @@ export function apply(ctx, config) {
             }
         }
         // Red gate: implementation edits need a failing test on record. Writing
-        // test files is the red step itself and always delegates.
+        // test files is the red step itself and always delegates, and a call that
+        // names no file at all (a custom guard tool with another argument shape)
+        // is not an implementation edit either.
         if (config.modules.tdd && snapshot.discipline.color !== 'red') {
             const args = exec.arguments;
             const path = mutationTargetPath(exec.name, args, detection);
-            if (path !== undefined && isTestFilePath(path, detection))
+            if (path === undefined || isTestFilePath(path, detection))
                 return next();
             const reminder = nextTddRedReminder(snapshot);
             if (reminder !== undefined)

package/lib/guard/prose.d.ts

@@ -5,6 +5,12 @@
  * `green gate`) stay English: they are stable session-log ids the durable
  * once-semantics fold matches, and translating them would silently break
  * `remindOnce` after a language switch. Only the model-facing text localizes.
+ *
+ * Scope of localization: every model-visible string the package injects or
+ * answers with (gate prose, the critic task, `/doublecheck` replies, the
+ * switch notice) is localized. The workspace documents (`doublecheck-spec.md`
+ * / `doublecheck-report.md`) keep their English section headings: they are
+ * stable artifacts whose structure other tooling may match.
  * @module dsh-doublecheck/guard/prose
  */
 /** Supported prose languages for guard injections. */
@@ -29,6 +35,47 @@ export interface GuardProse {
     reviewUnavailableNoFindings: string;
     reviewFindingsHeader: (count: number) => string;
     reviewFindingsFooter: string;
+    reviewHeldBack: (held: number) => string;
+    /** The critic's task prompt (model-facing behavior of the review run). */
+    criticTask: string;
+    switchOnDurable: string;
+    switchOnLocal: string;
+    switchOffDurable: string;
+    switchOffLocal: string;
+    commandNoAgent: string;
+    commandUnknown: (input: string) => string;
+    commandAlreadyOn: string;
+    commandAlreadyOff: string;
+    commandOnDurable: string;
+    commandOnLocal: string;
+    commandOffDurable: string;
+    commandOffLocal: string;
+    commandStatus: (facts: CommandStatusFacts) => string;
+}
+/** The folded facts the localized `/doublecheck status` reply renders. */
+export interface CommandStatusFacts {
+    /** The effective session switch. */
+    enabled: boolean;
+    /** The configured default for sessions without a state record. */
+    defaultEnabled: boolean;
+    /** Configured module switches. */
+    modules: {
+        grill: boolean;
+        tdd: boolean;
+        adversary: boolean;
+    };
+    /** Configured enforcement strength. */
+    intensity: string;
+    /** Whether reminder repetition is capped per session. */
+    remindOnce: boolean;
+    /** Whether a committed spec exists in the log. */
+    hasSpec: boolean;
+    /** The latest test-run color (`none` / `red` / `green`). */
+    color: string;
+    /** Whether an adversary review record exists in the log. */
+    reviewed: boolean;
+    /** Total implementation edits folded so far. */
+    editCount: number;
 }
 /** The localized prose tables by language. */
 export declare const PROSE: Readonly<Record<ProseLanguage, GuardProse>>;