@polymorphism-tech/morph-spec 8.33.0 → 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/README.md

@@ -8,7 +8,11 @@ Comprehensive hooks system for enforcing spec-driven development at the Claude C
 framework/hooks/
 ├── claude-code/                     # Claude Code native hooks
 │   ├── core/
-│   │   └── worktree-context.js      # SessionStart: worktree feature identity / active-feature summary
+│   │   ├── worktree-context.js      # SessionStart: worktree feature identity / active-feature summary
+│   │   ├── worktree-create.js       # WorktreeCreate: governed tree via `morph-spec worktree setup|provision`
+│   │   ├── worktree-remove.js       # WorktreeRemove: safe teardown via `worktree remove --if-clean`
+│   │   ├── block-destructive-worktree-removal.js  # PreToolUse(Bash): raw removal follows junctions out
+│   │   └── block-raw-worktree-add.js              # PreToolUse(Bash): raw `git worktree add` is ungoverned
 │   ├── user-prompt/
 │   │   └── enrich-prompt.js         # Context-aware prompt enrichment
 │   ├── pre-tool-use/
@@ -46,6 +50,10 @@ framework/hooks/
 | **PreToolUse** (Write\|Edit) | protect-spec-files.js | Block | Blocks edits to spec files after approval; for tasks.json validates the mutable-field diff, the status enum, and requires a `notes` when `outputs` diverge from the plan |
 | **PreToolUse** (Write\|Edit) | enforce-phase-writes.js | Block | Ensures writes go to current phase directory |
 | **PreToolUse** (Bash) | pre-bash-denylist.js | Block | Blocks `rm -rf .morph/` and direct state edits |
+| **PreToolUse** (Bash) | block-destructive-worktree-removal.js | Block | Blocks `git worktree remove` / `rm -rf` / `Remove-Item -Recurse` on a directory holding reparse points (the infra junctions a raw removal would FOLLOW out, emptying the root's `.claude/`); names `morph-spec worktree remove` |
+| **PreToolUse** (Bash) | block-raw-worktree-add.js | Block | Blocks raw `git worktree add` (a tree with no junctions → no hooks, no port block, no identity, outside `worktrees/`); names `morph-spec worktree setup <feature>` / `worktree provision <name> --base <ref>`. `list`/`prune`/`remove`/`lock`/`move`/`repair` pass |
+| **WorktreeCreate** | worktree-create.js | Replaces native | Fires for `claude -w`, EnterWorktree and `Agent isolation:"worktree"`; replaces Claude Code's bare `git worktree add`. Runs `morph-spec worktree setup <n>` (known feature) or `worktree provision <n>` (task tree, branch `morph-task/<n>`), honours `worktree.baseRef:"head"`, prints the path as its last stdout line. CLI unreachable → plain git, still under `<root>/worktrees/` |
+| **WorktreeRemove** | worktree-remove.js | Fail-open | Routes Claude Code's own cleanup through `morph-spec worktree remove --target --if-clean` (junctions dropped first; a dirty tree is left alone). Always exit 0. Secondary net — the event was observed NOT to fire headless; the Bash guard above stays the primary defense |
 | **PostToolUse** (Write\|Edit) | post-edit-typecheck.js | Advisory | Debounced `tsc --noEmit` after TS/TSX edits; silent on success. Also touches `.morph/memory/build-dirty.json` on every source-file edit — the write side of validate-completion.js's Stop-hook build-dirty gate |
 | **PostToolUse** (Write\|Edit) | tasks-json-guard.js | Advisory | Validates the written tasks.json schema (status/effort enums); warns so the LLM fixes it immediately |
 | **PostToolUse** (Write\|Edit) | trace-autogen.js | State sync | Auto-generates `.morph/traces/YYYY-MM-DD-{feature}-implement.json` from tasks.json + recap.md + taskScores on every tasks.json write — the skills never write traces by hand |
@@ -115,6 +123,8 @@ All Claude Code hooks import from `framework/hooks/shared/`:
 | `hook-response.js` | `block(reason)`, `approve(context)`, `injectContext(text)`, `pass()` |
 | `stdin-reader.js` | `readStdin()` — Promise-based stdin JSON reader |
 | `telemetry-logger.js` | `appendTelemetryEvent()`, `readTelemetryEvents()` — append-only JSONL event stream (`.morph/logs/events.jsonl`) |
+| `morph-cli.js` | `runMorphSpec(args, { cwd, timeoutMs, env })` — spawns the morph-spec CLI from a hook (`MORPH_SPEC_BIN` → `morph-spec` on PATH → `npx --no-install`); `unavailable: true` when none resolves, never a throw. Hooks may never import from `src/` |
+| `command-tokens.js` | `tokenize(command)` — quote-aware shell tokenizer shared by the Bash guards (a hook must never import a sibling hook: its standalone tail would fire) |
 
 `injectContext(text)` is how `worktree-context.js` (and any other SessionStart hook) delivers context: it emits `{ "hookSpecificOutput": { "hookEventName": "SessionStart", "additionalContext": text } }` on stdout. Claude Code only honors additional context nested under `hookSpecificOutput` — a bare top-level field is ignored.
 

package/framework/hooks/claude-code/core/block-destructive-worktree-removal.js

@@ -4,6 +4,7 @@ import { resolve, isAbsolute } from 'path';
 import { blockResult, runStandalone } from '../../shared/hook-response.js';
 import { stateExists } from '../../shared/state-reader.js';
 import { scanForBlockers } from '../../shared/reparse-scan.js';
+import { tokenize } from '../../shared/command-tokens.js';
 
 /**
  * block-destructive-worktree-removal — the only defense that does not depend on
@@ -32,14 +33,10 @@ import { scanForBlockers } from '../../shared/reparse-scan.js';
  * nothing to traverse is not blocked for looking dangerous.
  */
 
-/** Split a shell-ish command into tokens, honoring single and double quotes. */
-function tokenize(command) {
-  const tokens = [];
-  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
-  let m;
-  while ((m = re.exec(command)) !== null) tokens.push(m[1] ?? m[2] ?? m[3]);
-  return tokens;
-}
+// The tokenizer lives in shared/command-tokens.js — block-raw-worktree-add.js
+// reads `git worktree add` off the same tokens, and a hook must never import a
+// sibling hook (its standalone tail would fire in the importer's process).
+export { tokenize };
 
 /**
  * The path a recursive-removal command would destroy, or null when this is not