@polymorphism-tech/morph-spec 8.34.2 → 8.35.0

package/framework/evals/proof-rubrics/guard-cego.md

@@ -0,0 +1,52 @@
+# Prova: Guard Cego
+
+> Escopo: Gate 3 (avaliador independente). Não é dimensão do score composto — impõe **teto** em
+> Cobertura de Testes (`evals/rubrics/test-coverage.md`, seção "Tetos de prova").
+
+## O que esta prova responde
+
+Um guard só vale contra o ataque que ele consegue VER. O jeito de descobrir o que ele não vê não é
+mudar o conteúdo que ele já inspeciona — é mudar a **FORMA** do que chega até ele.
+
+A pergunta é: **qual entrada válida este guard deixa passar sem enxergar, e o ramo que ele abriu
+tem teste próprio?**
+
+## Bandas 0-10
+
+| 0-3 | 4-6 | 7-8 | 9-10 |
+|---|---|---|---|
+| Guard sem teste próprio. Ou testado só com o conteúdo que ele já rejeita, nunca com forma diferente | Ataque por conteúdo apenas. Guard que compara `Serialize(A) == Serialize(B)` aceito sem cross-check | Ataque por forma feito; falta o cross-check por contador independente, ou o predicado do guard continua mais estreito que a ação que ele governa | Forma atacada (multi-linha, aninhamento, ordem, codificação), cross-check por contador independente, predicado tão largo quanto a ação, e todo ramo recém-alcançável com teste próprio |
+
+## Anti-padrões literais
+
+- **Atacar o guard só pelo conteúdo** — mude a **FORMA**. Medido: o guard era um parser linha a
+  linha e o YAML **multi-linha** era perfeitamente válido; o conteúdo proibido passou inteiro
+  porque chegou numa forma que o parser não montava.
+- **`Serialize(A) == Serialize(B)` como prova de igualdade** — o guard é cego ao próprio
+  serializador: se ele perde um campo, perde nos dois lados e a comparação dá igual. Faça
+  **cross-check por um contador independente** (número de itens, soma, hash de um campo-chave).
+- **Predicado mais estreito que a ação que ele governa** — um publish que só olhava o *spec* e
+  virava no-op sobre tudo o mais. Afirme sobre o **texto publicado**, não sobre a intenção de
+  publicar.
+- **Early-return depois do filtro** — o `return` sai antes da limpeza e o estado fica meio mutado.
+  Quando o filtro é um `skip`, transforme-o em `else`: o caminho de saída precisa passar pelo
+  mesmo fecho.
+- **Ramo antes inalcançável que passou a ser alcançável** — isso é **código NOVO**, ainda que a
+  linha seja antiga e o diff não a toque. Ele precisa de teste próprio; nenhuma cobertura anterior
+  responde por ele.
+- **Guard novo sem prova de que morde** — canário que não morde é canário errado, e canário que
+  morde pelo motivo errado é pior: mute a produção, exija que o teste FALHE **nomeando o que
+  quebrou**, e restaure por cópia de bytes feita antes.
+
+## Como registrar no relatório
+
+Uma linha por guard tocado, dizendo a forma atacada e o resultado:
+
+```markdown
+- `chain.js:blockRawWorktreeAdd` — atacado por FORMA: comando com `\` de continuação em duas linhas
+  e com aspas simples. Bloqueou nas duas. Cross-check: contador de comandos bloqueados subiu 2.
+- Ramo `options.discardIgnored === true` era inalcançável antes de T4 — agora é alcançável e ganhou
+  teste próprio (`finish.test.js:412`).
+```
+
+E no `**Proof-Scores:**`, a chave `guard`.

package/framework/evals/proof-rubrics/media-claims.md

@@ -0,0 +1,109 @@
+# Prova: Media Claims
+
+> Escopo: Gate 3 (avaliador independente), **somente** em feature que gera mídia. Não é dimensão
+> do score composto — o composto continua `arquitetura + contratos + qualidade + testes`. Esta prova
+> impõe **teto** em Arquitetura (tabela em `evals/rubrics/architecture.md`, seção "Tetos de prova de
+> mídia").
+
+## O que esta prova responde
+
+Uma feature que gera imagem ou vídeo faz **quatro afirmações** que custam caro quando são falsas, e
+as quatro são fáceis de escrever e difíceis de provar: *controlamos o custo*, *tem revisão humana*,
+*a mídia é marcada*, *o hot path não bloqueia*.
+
+A pergunta desta rubrica é sempre a mesma: **onde está o código que torna a afirmação verdadeira,
+e o que acontece se alguém tentar burlá-la?**
+
+Ela vive em Arquitetura, e não em Cobertura, porque as quatro são **propriedades estruturais** —
+onde a chamada mora, que estados existem, o que é persistido, o que é publicado. Uma feature que
+gera mídia dentro do turno de WhatsApp está arquiteturalmente errada, não mal testada; contá-la como
+falha de teste diria a coisa errada a quem lê o relatório.
+
+As quatro afirmações, com o que conta e o que não conta:
+
+| Afirmação | Evidência que conta | Evidência que **não** conta |
+|---|---|---|
+| **Custo** | Custo estimado gravado **antes** da chamada, com a tarifa e a data da tabela de preços; teto por tenant/dia exercitado em teste, com o caso que ESTOURA | "usamos o modelo mais barato"; uma constante de preço sem fonte datada |
+| **Revisão humana** | Teste que prova que a publicação falha a partir de **todo** estado que não seja aprovado, e que aprovar carimba quem e quando | Um comentário dizendo que há revisão; um campo booleano `approved` |
+| **Marcação** | A publicação **recusa** quando a finalidade exige rótulo e ele não veio — com texto e superfície nomeados, gravados junto do artefato — mais a proveniência persistida e o C2PA preservado sem re-encode. No exemplar: `MediaJob.Publish(MediaDisclosure?, at)`, terceira porta | "o SynthID vem embutido" — vem, e cai no primeiro re-encode ou screenshot; um campo de rótulo que a publicação aceita vazio; a obrigação escrita só no comentário do estado `Published` |
+| **Hot path não bloqueado** | O tipo que produz bytes é **inacessível** do handler (teste de acessibilidade por reflexão) **e** o handler de mensagem devolve id de job | "o handler chama o serviço assíncrono"; um `Task.Run` |
+
+O conhecimento por trás das quatro está em `.morph/framework/standards/ai-agents/media-pipeline.md`.
+Esta rubrica não o repete: ela cobra a prova.
+
+## Bandas 0-10
+
+| 0-3 | 4-6 | 7-8 | 9-10 |
+|---|---|---|---|
+| Nenhuma das quatro afirmações tem código apontado. Ou a geração acontece dentro do turno de conversa, ou a publicação é alcançável sem aprovação humana — qualquer um dos dois é **bloqueante**, independentemente do resto | As quatro estão implementadas, mas a prova é leitura de código: nenhum teste exercita o caminho de recusa. Teto de custo declarado e nunca estourado em teste; marcação prometida na prosa e ausente no ponto de publicação | As quatro provadas por teste, com o caminho de recusa exercitado ao menos uma vez cada. Falta a mutação: nenhuma delas foi vista MORDENDO, ou a proveniência grava menos campos do que o standard nomeia | As quatro provadas, cada caminho de recusa com teste próprio, **e a acessibilidade do tipo que produz bytes asserida por reflexão com a mutação rodada** (tornar público, ver o teste falhar nomeando o defeito, restaurar por bytes e conferir por md5). Custo estimado antes da chamada, com tarifa datada; teto exercitado no caso que estoura. A marcação é **parâmetro da transição de publicação**, não campo opcional: existe o teste que publica sem rótulo e vê a recusa |
+
+## Anti-padrões literais
+
+- **Prender a regra dura só na prosa.** "O standard diz para não gerar no turno" não impede nada. O
+  que impede é a acessibilidade do tipo: se um handler consegue **nomear** o tipo que produz bytes,
+  a regra não está presa — mesmo que ninguém a tenha violado ainda. (memória: é a diferença entre
+  "o standard diz para não fazer" e "o compilador recusa")
+- **Testar a fachada em vez do dono do estado.** Se `Review.Publish(job)` reimplementa a regra em
+  vez de delegar a `job.Publish()`, o teste da fachada mede uma **cópia** do objeto — e as duas
+  divergem no primeiro conserto. Exercite as duas contra o MESMO job e compare.
+- **Confundir a chave de idempotência do PEDIDO com o hash do CONTEÚDO.** Uma dedupe chamada paga, a
+  outra dedupe storage. Um teste que só confere "o hash é o mesmo" **não distingue dedupe de
+  regravação**: as duas produzem o mesmo hash. Conte as gravações.
+- **Aceitar `estimatedCostUsd` gravado DEPOIS da chamada.** Isso é contabilidade, não controle: o
+  dinheiro já saiu. A prova é a ordem, e a ordem é verificável.
+- **Preço em código sem fonte datada.** Uma constante `0.211m` sem a página e a data de consulta é
+  folclore com força de orçamento. A tarifa vem da tabela do standard da modalidade.
+- **Tratar bloqueio de moderação como erro técnico.** Se o estado de bloqueio for retryable, um laço
+  de retry vira uma fatura — e no provedor que cobra o bloqueio, cobra duas vezes. Exija dois
+  estados distintos e um teste por estado.
+- **`not_detected` lido como "feito por humano".** Ausência de marca é ausência de informação. Um
+  verificador de proveniência que devolve "não detectado" não prova origem humana.
+- **Marcação delegada ao provedor.** C2PA e SynthID vêm embutidos e **caem** com screenshot ou
+  re-encode. A marcação visível é obrigação separada, e ela mora no ponto de publicação — não no de
+  geração.
+- **Marcação presa só por prosa.** É o anti-padrão mais fácil de cometer porque parece resolvido: o
+  comentário do estado `Published` diz "com a marcação aplicada", a finalidade `Marketing` diz
+  "marcação visível obrigatória", e um `grep` por rótulo, watermark ou disclosure no código volta
+  **vazio**. Se as outras três afirmações estão presas por tipo ou por estado e a marcação — que é a
+  obrigação legal — está presa por nada, a assimetria é o achado. Prova mínima: a publicação recusa
+  sem rótulo.
+- **Ler "o tipo prende" como "nada mais é possível".** O `internal` fecha *obter bytes* e *nomear o
+  produtor*; ele **não** fecha *aguardar inline*. O gatilho do worker (`IMediaJobRunner.RunAsync` no
+  exemplar) é público por necessidade — quem o dispara é o `BackgroundService` do projeto — e um
+  `await runner.RunAsync(id)` dentro de um handler de turno **compila** e paga a latência inteira.
+  Procure por esse `await`: é o que o compilador não procura. Uma prova que só cita a acessibilidade
+  e não olha os call sites do runner cobriu metade da afirmação.
+- **Teste que toca API paga.** Uma chave de API num teste é uma fatura por execução de CI e um teste
+  que fica vermelho quando o provedor tem incidente. `grep` por chave, host do provedor e leitura de
+  ambiente nos arquivos de teste tem de voltar vazio.
+- **Aceitar o número de testes sem a suíte inteira.** "Derruba 4" medido sobre um arquivo e "derruba
+  4 de 203" são afirmações diferentes. Só a suíte inteira autoriza a frase.
+- **Declarar as quatro afirmações numa feature que não gera mídia.** A isenção é automática: se
+  nenhuma task pina um standard de mídia, a seção não é exigida. Escrever a seção "por precaução"
+  gasta o Gate 3 com cerimônia vazia, que é como uma regra vira ruído e depois é desligada.
+
+## Como registrar no relatório
+
+Na seção `## Mídia gerada` do `evaluator-report.md`, uma linha por afirmação, com os quatro campos:
+
+```markdown
+## Mídia gerada
+
+| Afirmação | Onde está presa (arquivo:linha) | Teste que a prova | Rodada de mutação |
+|---|---|---|---|
+| Custo | src/…/MediaGenerator.cs:88 (reserva ANTES da chamada) | MediaGeneratorTests.ABudgetOverrun… | — |
+| Revisão humana | src/…/MediaJob.cs:… (Publish só de Approved) | MediaJobStateTests.PublishFails… (6 estados) | — |
+| Marcação | src/…/MediaJob.cs:… (3ª porta de Publish) + MediaDisclosure.cs | MediaDisclosureTests.PublishFailsWithoutADisclosure… | porta removida → 2 de 220 caem, motivo lido, md5 restaurado |
+| Hot path | src/…/IMediaProvider.cs (internal) | MediaAccessibilityTests.TheTypeThat… | público → 4 de 220 caem, motivo lido, md5 restaurado |
+```
+
+E a linha machine-readable, no mesmo estilo do `**Composite-Score:**`, junto das demais provas:
+
+```
+**Proof-Scores:** mutation=9 verde=8 fiacao=9 guard=7 media=9
+```
+
+**A chave `media` só entra quando a feature gera mídia.** Feature que não pina nenhum standard de
+mídia não declara a seção e não declara a chave — e o gate não a cobra. Feature que gera mídia **sem
+a seção** pausa o Gate 3 por conta própria (`src/lib/risk-detector.js`), antes de qualquer discussão
+de nota.

package/framework/evals/proof-rubrics/mutation-proof.md

@@ -0,0 +1,77 @@
+# Prova: Mutação
+
+> Escopo: Gate 3 (avaliador independente). Não é dimensão do score composto — o composto continua
+> `arquitetura + contratos + qualidade + testes`. Esta prova impõe **teto** em Cobertura de Testes
+> (tabela em `evals/rubrics/test-coverage.md`, seção "Tetos de prova").
+
+## O que esta prova responde
+
+Um teste verde prova que o código roda. Só a **mutação** prova que o teste MORDE: quebre de
+propósito a linha que carrega a decisão e veja quem grita. Se ninguém grita, a suíte é decoração —
+e foi assim que 11 testes verdes cobriram um artefato que o build recusava.
+
+A pergunta desta rubrica é sempre a mesma: **você mutou o call site que carrega a decisão, rodou a
+suíte inteira, leu o MOTIVO da falha, e devolveu o arquivo byte a byte?**
+
+## Bandas 0-10
+
+| 0-3 | 4-6 | 7-8 | 9-10 |
+|---|---|---|---|
+| Nenhuma mutação. Ou mutação declarada sem diff, sem md5 e sem testes nomeados — afirmação, não prova. Ou revert por `git checkout --`, que descarta trabalho não commitado de terceiros | Mutou, mas no lugar errado (o `if` refatorado, não o call site que decide) ou com filtro estreito ("derrubou 3" medido sobre 40 testes de um arquivo só). Reportou md5 sem ler o motivo da falha | Mutação no call site certo, suíte inteira, diff e md5 antes/depois. Falta o MOTIVO literal da falha, ou uma cláusula de um predicado composto ficou sem rodada própria | Uma rodada por cláusula, cada uma com arquivo:linha, diff, md5 antes/depois, contagem sobre a suíte INTEIRA e a mensagem literal de falha. Revert por snapshot de bytes + `os.utime`, com `git status --porcelain src/` vazio ao fim |
+
+## Anti-padrões literais
+
+- **Mutar o `if` refatorado em vez do call site que carrega a decisão** — o extract-method moveu a
+  regra; o teste continua batendo no invólucro. Ancore onde o valor é DECIDIDO. (memória: guard do
+  remédio, cuja checagem real vivia duas camadas acima do `if` mutado)
+- **Rodar com filtro e reportar "derruba N"** — "3 de 40" e "3 de 2684" são afirmações diferentes.
+  Só a suíte **inteira** autoriza a frase "derruba N". (memória: F30, filtro no Gate 3)
+- **Filtro tão estreito que a prova fica vácua** — mutar e rodar só o teste que você já sabia que
+  quebraria não testa nada além da sua própria expectativa.
+- **Aceitar um seed sem perguntar "que sequência real produz este seed?"** — fixture que só existe
+  no teste prova o teste, não o sistema.
+- **Imprimir `diff` + md5 e parar por aí** — md5 prova que ALGO mudou, nunca O QUÊ. Sem a mensagem
+  literal de falha (`expected 3, got 0` em `x.test.js:88`), a prova é de que o arquivo mudou, não de
+  que o teste morde a regra. (memória: três rodadas de correção nesta epic)
+- **Reverter por replace reverso, ou por `git checkout --`** — o replace reverso erra em arquivo com
+  ocorrências repetidas; o `git checkout --` **apaga alterações não commitadas de outra pessoa** e
+  aconteceu de verdade num Gate 3 desta epic. Reverta por **snapshot/restore de bytes** (cópia feita
+  ANTES) + `os.utime` para devolver o mtime, e confirme por `md5sum`.
+- **Escrever a mutação por heredoc do shell quando ela contém barra invertida** — o transporte come
+  o escape: `\b` vira o byte `0x08`, `\n` vira quebra de linha real, e o regex mutado **não é o que
+  você escreveu**. Sintoma: a mutação parece aplicada e o resultado não muda, ou o arquivo quebra
+  num ponto que você não tocou. Diagnóstico em um comando: `cat -A` mostra `^H` onde devia estar
+  `\b`. Saída: patch por **índice de linha** com o conteúdo montado sem barra invertida no fonte
+  (`String.fromCharCode(92)`), ou ferramenta de edição estrutural — nunca heredoc.
+  (memória: **três agentes** desta epic tropeçaram nisto; dois descartaram o resultado, um só
+  descobriu ao conferir os bytes)
+- **Mutar antes de commitar o fix** — se a sessão morrer no meio, o que sobrevive é a mutação, não a
+  correção. **Commite o fix ANTES de mutar**, sempre.
+- **Ler mais do que a primeira assertiva que falha** — a mutação só prova até ali; o resto do teste
+  nem rodou. Não conte cobertura que a mutação não exercitou.
+- **Uma rodada só para um predicado `A && B`** — derrubar `A` não diz nada sobre `B`. **Uma rodada
+  por cláusula.** O mesmo vale para um guard de duas classes: toque **cada** classe.
+- **Deixar loader, validador e superfície de publicação fora do alvo** — o defeito costuma estar em
+  quem LÊ o arquivo, não em quem o escreve. (memória: 11 testes verdes contra o render do próprio
+  gerador, nenhum deles CARREGANDO o artefato)
+- **Fixture fora da ordem de grandeza da tese** — tese sobre 2 600 testes provada num fixture de 3.
+- **Mutação de prosa presa por regex** — texto de skill/rubrica não se prende por `assert.match` de
+  vocabulário: mude a FORMA (mova a seção, troque o cabeçalho) e veja se o canário ainda morde.
+- **Número de mutação sem SHA e sem data** — "derruba 12" envelhece em uma semana. Anote o SHA
+  revisado e a data ao lado do número.
+- **Terminar sem `git status --porcelain src/` vazio** — mutação esquecida em produção é o pior
+  desfecho possível deste método, e já aconteceu com avaliador morto no meio da rodada.
+
+## Como registrar no relatório
+
+Na seção `## Mutações` do `evaluator-report.md`, uma linha por mutação, com os cinco campos:
+
+```markdown
+| # | Arquivo:linha | Mutação (diff) | md5 antes | md5 depois | Testes derrubados | Motivo da falha |
+|---|---|---|---|---|---|---|
+| M1 | src/lib/x.js:42 | `- if (a && b)` / `+ if (a)` | abc… | def… | 3 de 2684 | `expected 3 got 0` em x.test.js:88 |
+```
+
+E, ao fim da seção: **Reversão:** snapshot/restore de bytes + `os.utime`; `git status --porcelain
+src/` vazio. Feature sem código de produção declara a seção com a linha
+`não aplicável — feature sem código de produção`.

package/framework/evals/proof-rubrics/observabilidade-genai.md

@@ -0,0 +1,119 @@
+# Prova: Observabilidade GenAI
+
+> Escopo: Gate 3 (avaliador independente). Não é dimensão do score composto — impõe **teto** em
+> Qualidade de Código (`evals/rubrics/code-quality.md`, seção "Teto de prova de observabilidade
+> GenAI"). Aplica-se **somente** a feature que chama LLM; feature sem LLM é `not_evaluated`, e
+> `not_evaluated` **não** aplica teto.
+
+## O que esta prova responde
+
+Uma feature que chama um modelo gasta dinheiro, pode falhar de formas que nenhum teste cobre, e
+produz texto que ninguém revisou. A pergunta que importa depois do incidente é sempre a mesma, e
+raramente tem resposta:
+
+**Dá para reconstruir o que foi ao provedor, e o que ele respondeu, neste turno?**
+
+Repare no que a pergunta **não** é. Ela não é "tem span OpenTelemetry?". Essa formulação foi medida
+contra o acervo e reprova **5 de 5** repositórios — e, pior, daria a mesma nota a um projeto cuja
+observabilidade inteira é a mensagem da exceção e a outro que tem hash por bloco de prompt, vocabulário
+fechado de desfecho de tool, veredito ternário de guard, sete testes provando que a telemetria é
+inerte, e a invariante escrita de que o texto enviado é derivado sem cache *"para a telemetria não
+poder mentir"*. **Régua que pune o melhor aluno não é régua.**
+
+Span com as convenções GenAI é a forma **recomendada** (`ai-agents-observability-patterns`) e alcança
+a faixa mais alta. Telemetria própria também alcança — desde que exista **teste de fidelidade**, isto
+é, algo que prove que o registrado é o enviado. O que a rubrica cobra é o **resultado**; o standard é
+quem recomenda o meio.
+
+### Aplicabilidade — filtro mecânico, e depois uma determinação nomeada
+
+**Esta rubrica NÃO se declara determinística, e a razão é medida:** nenhuma leitura de `tasks.json`
+ou do `mandate.md` mede a propriedade que importa — *esta feature entrega código que chama um
+modelo?*. A versão anterior deste bloco prometia determinismo e **errou no primeiro cliente que
+encontrou**: a própria feature que criou esta rubrica satisfazia as duas condições (tasks com
+`group: "tests"`, mandate citando `ai-agents` dez vezes) e não chama LLM nenhum.
+
+São **duas etapas**, e a segunda não é opcional:
+
+**1. Filtro mecânico, de alta recall** (barato, lido do disco):
+
+> o `mandate.md` cita ao menos um standard `ai-agents`.
+
+Falso ⇒ `not_evaluated`, sem mais discussão. É deliberadamente **largo**: erra para o lado de
+convocar a determinação, não para o de dispensá-la.
+
+**2. Determinação, escrita pelo avaliador.** Passado o filtro, a pergunta é
+*a feature entrega código que chama um modelo?* — e o relatório **registra a resposta com o motivo**:
+
+```markdown
+- Aplicabilidade: LLM SIM — T4 acrescenta `TriagemAgent` sobre `IChatClient` (`AgentCatalog.cs:31`).
+- Aplicabilidade: `not_evaluated` — o mandate cita `ai-agents`, mas o diff é 100% markdown de
+  standard; nenhuma chamada a modelo entra no produto.
+```
+
+**Sinal auxiliar, não determinação:** toda task com `group` em `{docs, tests}` é indício **contra**
+código de produção que chama modelo. Indício, porque um harness de agente pode viver inteiro numa
+task `tests` — por isso ele informa a determinação em vez de substituí-la.
+
+**Um `not_evaluated` sem motivo escrito não é dispensa: é o escape que o standard
+`ai-agents-guardrails` proíbe.** O motivo é o que torna a decisão auditável na revisão seguinte, e é o que impede que
+`not_evaluated` vire a saída fácil.
+
+## Bandas 0-10
+
+| 0-3 | 4-6 | 7-8 | 9-10 |
+|---|---|---|---|
+| A feature chama LLM e **nada** permite saber o que foi enviado, quanto custou, ou se falhou. Observabilidade é a mensagem da exceção | Chamada de LLM registrada **só por log de texto**: sem contagem de tokens, sem correlação com a feature ou a requisição, sem forma de amarrar o registro ao turno | Instrumentação presente e correta — mas a evidência no relatório é a **linha de wiring**, não a saída. O avaliador leu o `AddSource`, não leu um span | Span por chamada com `gen_ai.operation.name` e `gen_ai.provider.name`, tokens registrados, correlação com a feature, e sensível desligado fora de dev — **ou** telemetria própria equivalente cuja fidelidade tem teste. Nos dois casos, o relatório **mostra um span ou registro capturado** |
+
+A fronteira que decide 7-8 × 9-10 é uma só, e é a mesma de toda rubrica desta classe: **evidência
+capturada, não evidência declarada.** Ler o código que instrumenta prova que alguém escreveu o
+wiring; ler um span prova que ele emite.
+
+## Anti-padrões literais
+
+- **Pontuar o wiring como se fosse a saída** — `builder.AddSource(...)` no diff é 7-8, nunca 9-10.
+  Para subir, capture: rode o caminho, pegue **um** span ou **uma** linha de registro, e cole no
+  relatório com os atributos que ela carrega.
+- **Aceitar "temos logs"** — log de texto sem tokens e sem correlação é banda 4-6. A pergunta
+  operacional é "quanto custou este turno e o que foi enviado nele"; um log que não responde nenhuma
+  das duas não é observabilidade, é rastro.
+- **Reprovar telemetria própria por não ser OpenTelemetry** — a rubrica cobra a propriedade. Um
+  registro próprio com **teste de fidelidade** vale 9-10. Sem teste de fidelidade, não vale: é uma
+  afirmação sobre o que o código faz, feita pelo mesmo código.
+- **Aceitar hash sem a invariante** — um hash do prompt só prova algo se o texto de que ele é hash
+  **é** o texto enviado. Se existe cache entre a montagem e o envio, telemetria e requisição podem
+  divergir em silêncio. Procure a derivação sem cache; sem ela, o hash é decoração e a nota não passa
+  de 6.
+- **Prompt cru em produção contado como ponto a favor** — é o oposto: dado sensível persistido é
+  achado, não evidência. Cru só em dev ou harness, com opt-in; em produção, hash.
+- **Confundir "não tem LLM" com "tem e não instrumentou"** — o primeiro é `not_evaluated` e **não**
+  aplica teto; o segundo é 0-3. Colapsar os dois num booleano é o mesmo defeito que o veredito
+  ternário de `ai-agents-guardrails` existe para impedir.
+- **Aplicar teto sem ter avaliado** — sem a linha da chave `obs` no `**Proof-Scores:**` não há teto a
+  aplicar. Um teto inventado a partir de impressão é pior que teto nenhum.
+- **Pontuar telemetria de turno cancelado como cobertura** — registro de algo que não aconteceu é
+  achado, não evidência.
+
+## Como registrar no relatório
+
+Uma linha dizendo o que foi capturado e como, e — quando a nota for 9-10 — o artefato capturado:
+
+```markdown
+- Aplicabilidade: filtro passou (mandate cita `ai-agents-cost-and-budget`); determinação: LLM SIM — T4 acrescenta `TriagemAgent` sobre `IChatClient` (`AgentCatalog.cs:31`).
+- Capturado 1 span de `Morph.Agents.Triagem` rodando o caminho real com o fake:
+  `chat gpt-5-mini` · gen_ai.operation.name=chat · gen_ai.provider.name=openai ·
+  gen_ai.usage.input_tokens=1841 · output_tokens=212 · morph.feature=triagem-lead
+- Fidelidade: `PromptDecompositionTests.TextoEnviadoEhAConcatenacaoDosBlocos` prova que o hash
+  registrado é o do texto enviado (derivação sem cache).
+- EnableSensitiveData=false confirmado fora de dev (`appsettings.Production.json`).
+```
+
+E no `**Proof-Scores:**`, a chave `obs`.
+
+Quando não se aplica, uma linha basta — e ela precisa dizer **o que** foi determinado, e por quê. Um `not_evaluated` mudo não é dispensa:
+
+```markdown
+- Observabilidade GenAI: `not_evaluated` — o filtro passou (o mandate cita `ai-agents`), mas o
+  diff é 100% markdown de standard: nenhuma chamada a modelo entra no produto. Sem teto sobre
+  code-quality.
+```

package/framework/evals/proof-rubrics/verde-nao-e-coberto.md

@@ -0,0 +1,48 @@
+# Prova: Verde Não É Coberto
+
+> Escopo: Gate 3 (avaliador independente). Não é dimensão do score composto — impõe **teto** em
+> Cobertura de Testes (`evals/rubrics/test-coverage.md`, seção "Tetos de prova").
+
+## O que esta prova responde
+
+Um teste que **nasce verde** nunca teve fase RED: ele afirma uma pós-condição que o backend já
+garantia antes da mudança. Ele não está errado — está **vazio**. E é indistinguível, no relatório de
+execução, de um teste que protege alguma coisa.
+
+A pergunta é: **qual asserção deste teste teria falhado ANTES da mudança?** Se nenhuma, o teste
+documenta, não cobre — e isso precisa estar **declarado**, não escondido no verde.
+
+## Bandas 0-10
+
+| 0-3 | 4-6 | 7-8 | 9-10 |
+|---|---|---|---|
+| Testes novos apresentados como cobertura sem que nenhum tenha tido fase RED. Pré-condições afirmadas em prosa/comentário, nunca medidas | Alguns testes nascem verdes e isso não é declarado. `DoesNotContain` de um item só, deixando os irmãos abertos | O relatório reconhece pelo enunciado quais testes nascem verdes e os declara. Falta a asserção positiva no campo novo ao lado do `DoesNotContain` | Cada teste que nasce verde está declarado como tal, com o motivo. Pré-condições medidas (`Assert.NotNull`), listas EXATAS em vez de negativas pontuais, e mudança de semântica coberta pelo par positivo+negativo |
+
+## Anti-padrões literais
+
+- **Pós-condição que o backend já garante apresentada como cobertura nova** — a fase RED não
+  aconteceu. Reconheça pelo ENUNCIADO ("o campo X nunca vem nulo" num campo `NOT NULL` desde a
+  migração) e **declare no relatório**. (memória: pós-condição verde-de-nascença numa feature cujo
+  contrato já a garantia no schema)
+- **Comentário que afirma um fato em vez de asserção** — `// aqui o id já existe` não falha nunca.
+  Comentário que afirma fato vira asserção **ou some**.
+- **`DoesNotContain` de UM item** — provar que "banana" sumiu deixa "maçã" e "pera" livres. Quando o
+  contrato é "só isto e nada mais", asserte a **lista exata**.
+- **Pré-condição afirmada em prosa** — "o registro existe neste ponto" precisa ser
+  `Assert.NotNull(x)`. Sem isso, um teste que passa por vacuidade (coleção vazia, nulo silencioso)
+  se lê como verde legítimo.
+- **Mudar semântica e asserir só o lado novo** — ao trocar o texto/o campo, o par é obrigatório:
+  asserção **positiva** no campo novo **e** `DoesNotContain` do texto substituído. Sem o negativo, o
+  teste passa com os dois presentes.
+
+## Como registrar no relatório
+
+Na seção de análise de cobertura, uma linha por teste que nasce verde:
+
+```markdown
+- `test/x.test.js:41` — nasce VERDE: a pós-condição P3 já era garantida pelo `NOT NULL` da coluna
+  desde a migração 0007. Documenta, não cobre. Não conta para a faixa 9-10 de Cobertura.
+```
+
+E no `**Proof-Scores:**`, a chave `verde`. Um relatório que não distingue "cobre" de "documenta"
+não pode passar de 8 nesta prova, por mais testes que tenha.

package/framework/evals/rubrics/architecture.md

@@ -71,3 +71,33 @@ que o mandate não as mencione explicitamente. Uma violação em qualquer uma de
    `AddTransient` correspondente em `Program.cs`?
 7. Se o diff tem chamada server-direct ao backend E chamada client-side via proxy para o mesmo
    recurso, elas usam duas constantes de prefixo distintas — nenhuma reusada para o outro propósito?
+
+## Tetos de prova de mídia (Gate 3)
+
+Quando — e **somente** quando — a feature gera mídia (alguma task de `tasks.json` cita, em
+`standards[]`, um dos três standards de mídia de `ai-agents/`), o avaliador independente também
+aplica `.morph/framework/evals/proof-rubrics/media-claims.md` e grava ` media={n}` na linha
+`**Proof-Scores:**`.
+
+Ela **não** é uma quinta dimensão do composto — nenhum peso muda por causa dela. Ela entra aqui,
+como teto sobre esta dimensão, pelo mesmo mecanismo do teto de prova em Cobertura.
+
+**Por que aqui e não em Cobertura:** as quatro afirmações que ela cobra — custo, revisão humana,
+marcação, hot path não bloqueado — são **propriedades estruturais**: onde a chamada mora, que
+estados existem, o que é persistido, o que é publicado. Uma feature que gera mídia dentro do turno
+de conversa está arquiteturalmente errada, não mal testada. E há uma consequência técnica: o `min`
+que limita Cobertura é calculado sobre a lista explícita das quatro provas de evidência, com `media`
+**fora** dela — senão um `media=4` derrubaria o teto de teste por um motivo que não tem nada a ver
+com teste.
+
+| Proof-Score de media | teto nesta dimensão |
+|---|---|
+| 9 a 10 | sem teto |
+| 7 a 8 | 8 |
+| 4 a 6 | 6 |
+| 0 a 3 | 3, e o item entra como **bloqueante** listado no relatório |
+
+Sem a chave `media`, não há teto a aplicar. Mas a ausência da seção `## Mídia gerada` num relatório
+de feature que gera mídia **pausa o Gate 3** por conta própria (`src/lib/risk-detector.js`), antes
+de qualquer discussão de nota. Feature que não gera mídia é isenta automaticamente — a chave não
+aparece e o sinal é falso.

package/framework/evals/rubrics/code-quality.md

@@ -57,6 +57,32 @@ Avalia naming, ausência de code smells e aderência aos padrões do stack do pr
 > `reuse`. Um símbolo criado contra um veredito `REUSAR` é achado desta
 > dimensão, mesmo que o código esteja impecável por dentro.
 
+## Teto de prova de observabilidade GenAI
+
+Quando a feature **chama LLM**, o avaliador aplica também
+`.morph/framework/evals/proof-rubrics/observabilidade-genai.md` e grava a nota sob a chave `obs` na
+linha `**Proof-Scores:**`. Ela **não** é dimensão do composto — nenhum peso muda — e entra aqui como
+teto sobre esta dimensão:
+
+| Proof-Score `obs` | teto nesta dimensão |
+|---|---|
+| 9 a 10 | sem teto |
+| 7 a 8 | 9 |
+| 4 a 6 | 7 |
+| 0 a 3 | 5 |
+
+A rubrica pergunta a **propriedade** ("dá para reconstruir o que foi ao provedor, e o que ele
+respondeu, neste turno?"), não a tecnologia: telemetria própria com teste de fidelidade alcança a
+faixa mais alta tanto quanto um span OpenTelemetry.
+
+**Aplicabilidade tem duas etapas, e ela NÃO se declara determinística** (a versão anterior se
+declarava, e errava na primeira feature que encontrou): (1) **filtro mecânico de alta recall** — o
+`mandate.md` cita ao menos um standard `ai-agents`; falso ⇒ `not_evaluated`. (2) **determinação
+escrita pelo avaliador** — a feature entrega código que **chama um modelo**? — registrada **com o
+motivo** no relatório. Tasks com `group` em `{docs, tests}` são **indício** contra, não veredito.
+`not_evaluated` **não aplica teto**, e um `not_evaluated` sem motivo escrito não é dispensa. Sem a
+chave `obs` no `**Proof-Scores:**`, também não há teto a aplicar.
+
 ## Perguntas de avaliação
 
 1. É possível entender o que uma função faz apenas pelo seu nome e assinatura?

package/framework/evals/rubrics/test-coverage.md

@@ -58,3 +58,23 @@ Avalia se os testes cobrem os comportamentos esperados, são isolados e têm nom
    min; o fecho de um fail-open abriu um P1; a correção desse P1 saiu com meio predicado. Nenhuma
    apareceu no score, porque score não pergunta isso. **Sem resposta a esta pergunta numa correção,
    o teto de Cobertura é 8.**
+
+## Tetos de prova (Gate 3)
+
+No Gate 3 o avaliador independente pontua **a própria evidência** 0-10 nas cinco rubricas de
+`.morph/framework/evals/proof-rubrics/` (`mutation-proof.md`, `verde-nao-e-coberto.md`,
+`fiacao.md`, `guard-cego.md`, `eval-de-modelo.md`) e grava a linha `**Proof-Scores:**` no `evaluator-report.md`.
+
+Elas **não** são dimensões do composto — nenhum peso muda por causa delas. Elas entram aqui, como
+teto sobre esta dimensão, pelo mesmo mecanismo que "pós-condição sem teste impede a faixa 9-10":
+
+| menor Proof-Score das cinco | teto nesta dimensão |
+|---|---|
+| 9 a 10 | sem teto |
+| 7 a 8 | 8 |
+| 4 a 6 | 6 |
+| 0 a 3 | 3, e o item entra como **bloqueante** listado no relatório |
+
+Sem a linha `**Proof-Scores:**`, não há teto a aplicar — mas a ausência da seção `## Mutações` num
+relatório de feature com código de produção **pausa o Gate 3** por conta própria
+(`src/lib/risk-detector.js`), antes de qualquer discussão de nota.

package/framework/hooks/claude-code/core/protect-spec-files.js

@@ -20,10 +20,14 @@
  * This is the sanctioned progress path — the agent never has to rewrite the
  * whole file nor reach for a Node script to record task status.
  *
+ * A gate freezes the APPROVED ARTIFACT, so a protected file that does not yet
+ * exist on disk is a CREATION and passes — the criterion is the file's
+ * existence, never who signed the gate (see the carve-out in run()).
+ *
  * Fail-open: exits 0 on any error.
  */
 
-import { readFileSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { stateExists, isGateApproved } from '../../shared/state-reader.js';
 import {
   isFeaturePath,
@@ -238,6 +242,35 @@ export async function run(payload) {
     }
 
     // ── Gate approved — file is locked ──────────────────────────────────────
+    const absPath = resolveTargetPath(filePath, root);
+
+    // Um gate aprovado congela o ARTEFATO APROVADO. Se o arquivo ainda não
+    // existe no disco, não há artefato aprovado a proteger: isto é a CRIAÇÃO
+    // inicial, não a edição de uma spec fechada. O caso é real e não é raro —
+    // `chore`/`hotfix` nascem com `proposal`+`plan` carimbados `policy:{tipo}`
+    // (create.js → work-types.js skippedGates), então o primeiro `Write` de
+    // `2-plan/spec.md` já chega aqui com o gate "aprovado" sem que humano
+    // nenhum tenha aprovado coisa alguma — e era barrado com uma mensagem
+    // mandando revogar o gate de um arquivo inexistente.
+    //
+    // O critério é a EXISTÊNCIA, nunca o `approvedBy`. Liberar por assinatura
+    // (`policy:` passa, `lucas` não) transformaria este carve-out em licença
+    // para reescrever qualquer spec aprovada: bastaria apagá-la antes. Por ser
+    // sobre o disco, a janela fecha sozinha no instante em que o arquivo
+    // existe — os contra-canários de test/hooks/protect-spec-files.test.js
+    // pinam exatamente isso.
+    //
+    // A decisão é explícita e vale para as DUAS metades do hook. Antes, o ramo
+    // de campos mutáveis (tasks.json) já deixava a primeira criação passar, mas
+    // por acidente — o ENOENT caía no catch fail-open da leitura — enquanto o
+    // ramo travado bloqueava. Duas metades respondendo à mesma pergunta em
+    // direções opostas; agora respondem aqui, uma vez só. O `result` distinto
+    // no log é o que torna essa unificação observável.
+    if (!existsSync(absPath)) {
+      logHookActivity('protect-spec-files', 'PreToolUse', 'ok:absent');
+      return null;
+    }
+
     const mutableFields = MUTABLE_SPEC_FIELDS[filename];
 
     // Files with mutable progress fields (e.g. tasks.json): allow a full Write
@@ -247,8 +280,9 @@ export async function run(payload) {
 
       // Build the proposed document from either a full Write or a targeted Edit,
       // then semantic-diff it against the current file on disk. Any failure to
-      // read / parse / apply → fail-open (pass), never a false block.
-      const absPath = resolveTargetPath(filePath, root);
+      // read / parse / apply → fail-open (pass), never a false block. O arquivo
+      // EXISTE aqui (a inexistência já foi decidida acima), então este catch
+      // volta a significar só o que dizia originalmente: não deu para diffar.
       let oldDoc, newDoc;
       try {
         const original = readFileSync(absPath, 'utf-8');
@@ -312,8 +346,11 @@ export async function run(payload) {
     // de leitura/reconstrução cai no bloqueio (o conservador aqui é BLOQUEAR —
     // ao contrário do ramo do tasks.json, onde não conseguir diffar significa
     // não ter como provar violação; aqui a regra base é "não se edita").
+    //
+    // O arquivo EXISTE neste ponto — a inexistência foi decidida lá em cima, e
+    // é a única coisa que este catch NÃO significa mais. ENOENT tratado como
+    // "ilegível" era o defeito F14; "ilegível de verdade" continua bloqueando.
     const toolName = getToolName(payload);
-    const absPath = resolveTargetPath(filePath, root);
     let errataCheck = null;
     try {
       const original = readFileSync(absPath, 'utf-8');

package/framework/hooks/claude-code/statusline.sh

@@ -1,11 +1,11 @@
-#!/usr/bin/env bash
-# morph-spec statusline — installed globally to ~/.claude/statusline.sh
-# Claude Code invokes this with JSON via stdin after each response.
-# Requires: Python 3 available as `python3` or `python` on PATH.
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-if command -v python3 &>/dev/null; then
-  python3 "${SCRIPT_DIR}/statusline.py" 2>/dev/null || true
-elif command -v python &>/dev/null; then
-  python "${SCRIPT_DIR}/statusline.py" 2>/dev/null || true
-fi
+#!/usr/bin/env bash
+# morph-spec statusline — installed globally to ~/.claude/statusline.sh
+# Claude Code invokes this with JSON via stdin after each response.
+# Requires: Python 3 available as `python3` or `python` on PATH.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if command -v python3 &>/dev/null; then
+  python3 "${SCRIPT_DIR}/statusline.py" 2>/dev/null || true
+elif command -v python &>/dev/null; then
+  python "${SCRIPT_DIR}/statusline.py" 2>/dev/null || true
+fi