@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

package/framework/evals/review-checklist.md

@@ -18,7 +18,7 @@ relatório começa igual e é append-only (vale o último `**Verdict:**`):
 - (o que melhoraria, sem bloquear)
 ```
 
-Sem bloqueador, escreva `Nenhum.` na seção. `SHIP` com bloqueador aberto é contradição e pausa o gate.
+O `**Reviewed-SHA:**` é obrigatório: o `approve` recusa relatório sem ele ou de outro sha. Sem bloqueador, escreva `Nenhum.` na seção. `SHIP` com bloqueador aberto é contradição e pausa o gate.
 Confirmação depois de uma correção: seção nova ao fim com `**Verdict:**` e o `**Reviewed-SHA:**` novo —
 julgando só os seus bloqueadores, ou, sem eles, só o delta `{sha anterior}..{sha novo}`. Bloqueador
 que a correção fechou sai de `## Bloqueadores` (escreva `Nenhum.`) e o fechamento vai em `## Notas`;
@@ -31,70 +31,58 @@ diferente") é nota; nota não bloqueia e não pede rodada nova. Na dúvida, sem
 | Tipo | Quem | Quando | Evidência mínima |
 |------|------|--------|------------------|
 | `check` | verificador | cenário `Cn` NÃO PROVADO ou FALHA | o que falta provar, ou o repro que falha |
-| `teste` | verificador | teste vermelho; teste que não morde a regra que diz proteger | saída do verify, mutante sobrevivente, assert que passa pelo motivo errado |
+| `teste` | verificador | teste vermelho; teste que não morde a regra que diz proteger; Cn de risco sem teste | saída do teste filtrado, assert que passa pelo motivo errado |
 | `regressao` | revisor | comportamento que funcionava e quebrou | consumidor afetado + o caminho que quebra |
-| `escopo` | revisor | o diff faz o que nenhuma fatia pediu, ou deixa de fazer o que o contrato pede | arquivo/trecho fora das fatias, ou o item do contrato ausente |
+| `escopo` | revisor | o diff faz o que nenhum cenário pediu, ou deixa de fazer o que o contrato pede | trecho que nenhum Cn explica, ou o item do contrato ausente |
 | `arquitetura` | revisor | padrão ou abstração nova contra o stack e os standards; item da lista fechada de `architecture-engineering-lens#review-blockers` que o DIFF introduziu (o que já existia é nota) | o trecho e o standard que ele contraria |
 | `performance` | revisor | custo que o volume real torna visível | a consulta/lista e o volume que a derruba |
+| `irreversivel` | revisor | o diff faz o que um revert não desfaz e nenhum `Cn` declara `degrau: migrar`/`irreversível`: apaga ou reescreve dado fora de migration, envia a terceiro, cobra, muda resposta de API ou webhook que alguém consome | o trecho e o efeito que fica depois do revert. Vai direto ao usuário, sem rodada de correção |
 | `seguranca` | segurança | authz, segredo, injeção, PII, custo sem teto, migration destrutiva | o caminho de exploração |
 
 ## Verificador (`4-review/verifier.md`)
 
-Missão: **provar cada cenário** do `2-plan/checks.json`. O default de todo `Cn` é NÃO PROVADO;
-critério que você não verificou nunca vira PROVADO por inferência. A prova é a que o plano declarou
-(`prova:` do Cn): `leitura` prova-se pelo `arquivo:linha` e pela fiação, **sem teste** — Cn `leitura`
-sem teste não é NÃO PROVADO, e pedir teste para ele não é bloqueador. Só Cn com `risco:` exige teste
-que morde.
+Missão: **fazer cada cenário acontecer** e dizer se o resultado é o que o `2-plan/checks.json`
+promete. Você recebe os cenários, a URL da app e o comando de reset — não o plano, o diff nem o relato
+de quem implementou, de propósito: você prova o comportamento, não a versão dele que o implementador
+conta. O default de todo `Cn` é NÃO PROVADO; o que você não executou (ou, em `leitura`, não leu)
+nunca vira PROVADO por inferência.
 
 ```markdown
 ## Checks
 
 | Cn | status | evidência |
 |----|--------|-----------|
-| C1 | PROVADO | `src/Orders/Create.cs:42` + `OrdersTests.RecusaSemItens` (morde: M1 morto) |
-| C2 | NÃO PROVADO | nenhum teste exercita o caminho de escrita |
+| C1 | PROVADO | `POST /orders {items:[]}` → 422 "pedido sem itens"; `OrdersTests.RecusaSemItens` verde |
+| C2 | FALHA | /tenants?status=ativo lista 3 inativos (print `4-review/c2.png`) |
 ```
 
 Uma linha por cenário, status exato `PROVADO`, `NÃO PROVADO` ou `FALHA`. O gate pausa com cenário
-sem linha ou não PROVADO. Numa confirmação, uma `## Checks` nova só com os Cn que mudaram: vale a
-última linha de cada Cn. Para cada `Cn`, em ordem de dano:
-
-1. **Onde vale**: `arquivo:linha` do código que entrega o cenário.
-2. **Fiação**: existe caminho da entrada real ao efeito observável? A camada pura testada não prova
-   que o handler a chama. Inventarie quem consome o eixo novo.
-3. **O teste morde?** Nasceu verde e afirma o que já era verdade; só testa a recusa e nunca o caminho
-   de escrita; guard cujos dois lados passam pelo mesmo serializador; asserção sobre texto que mede
-   vocabulário, não sentido.
-4. **Verificações mecânicas** (.NET minimal API / Next): todo serviço injetado numa lambda de endpoint
-   tem registro em `Program.cs` (senão a app não sobe); prefixo de rota server-direct e de proxy são
-   constantes distintas, cada uma usada só do seu lado.
-5. **Runtime**: com o stack no ar (URL no dispatch), navegue o fluxo do cenário e confira console e
-   network. Stack fora do ar é achado de infra, não defeito seu a provar.
-
-A suíte inteira é do orquestrador. Você não roda teste nem `verify` (o hook `test-budget` nega): a
-execução que prova mordida é a mutação abaixo; o resto, por leitura.
-
-**Prova por mutação — opcional, no máximo 3, só depois que revisor e segurança terminaram.** Só
-quando o diff tem uma linha de guarda ou regra que um cenário exige e você não achou o teste que a
-morde. Escreva `4-review/mutants.json` e rode `morph-spec mutate {feature}` **uma vez**:
-
-```json
-{"mutants":[{"id":"M1","file":"src/x.cs","line":42,"find":"a && b","replace":"a",
-  "expect":"OrdersTests.RecusaSemItens deve falhar: a regra de itens some"}]}
-```
+sem linha ou não PROVADO. Numa confirmação, uma `## Checks` nova só com os Cn pedidos: vale a última
+linha de cada Cn.
+
+**Como provar, pelo `prova:` do Cn:**
+
+| `prova:` | Execução |
+|---|---|
+| `e2e` | Navegue o fluxo com o Playwright MCP na URL do dispatch, como o usuário faria; confira o resultado na tela, no console e no network. Rode `morph-spec e2e reset {feature}` **antes de cada fluxo**: estado de um fluxo nunca prova o seguinte. |
+| `teste` | Ache o teste que cobre o Cn e rode **só ele**, pelo filtro do próprio runner (`dotnet test --filter <nome>`, `node --test <arquivo>`, `npx vitest run <arquivo> -t <nome>`, `npx playwright test <arquivo>`). `verify --filter` escolhe um nó inteiro da suíte: só serve quando o nó é esse teste. Verde não basta: leia o teste — ele morde? Nasceu afirmando o que já era verdade, só testa a recusa e nunca a escrita, ou o assert passa pelo motivo errado → bloqueador `teste`. Sem teste para um Cn com `risco:` → `teste`. |
+| `eval` | Rode o nó de evals filtrado (`--filter <nó-evals> --skip-e2e --no-persist`) e compare a saída com o cenário. |
+| `leitura` | `arquivo:linha` do código que entrega o cenário e a **fiação**: caminho da entrada real ao efeito (a camada pura não prova que o handler a chama). Sem teste, e pedir teste não é bloqueador. |
+| `manual` | Reproduza o passo de `3-implement/evidencias/{Cn}.md` e diga se o resultado bate. |
+
+Verificações mecânicas valem para todo Cn de backend (.NET minimal API / Next): serviço injetado numa
+lambda de endpoint registrado em `Program.cs`; prefixo de rota server-direct e de proxy como
+constantes distintas.
 
-`expect` é obrigatório: diga qual teste deve falhar e por quê **antes** de rodar — mutante cujo
-efeito você não sabe prever tende a ser equivalente. Barra invertida do código vira `{{BS}}`.
-Sobreviveu numa linha que um cenário exige → bloqueador `teste`. Sobreviveu em outra → nota.
-Sem subconjunto (exit 2) ou `inconclusive`: a mutação não roda a suíte inteira — prove por leitura
-(`arquivo:linha` + o teste que cobre), nunca em laço. Cole a
-seção `## Mutações` que a ferramenta imprime. A reversão é da ferramenta; rodada morta no meio:
-`morph-spec mutate --restore`.
+Você não roda a suíte inteira nem `verify` sem filtro (o hook `test-budget` nega): ela já rodou antes
+do dispatch. Stack fora do ar ou URL ausente: os `e2e` ficam NÃO PROVADO com o motivo — achado de
+infra, não defeito seu a provar; não suba nem derrube o stack.
 
-**Feature que gera mídia** (alguma fatia cita em `standards:` `standards/ai-agents/modalities-image-gen.md`,
-`media-video.md` ou `media-pipeline.md`): grave `## Mídia gerada`, uma linha por afirmação — custo
-controlado, revisão humana, mídia marcada, hot path não bloqueado —, cada uma com o código que a prende
-e o teste que a prova. Afirmação falsa é bloqueador. Sem a seção, o gate pausa.
+**Feature que gera mídia** (o `plan.md` cita um standard de mídia): grave `## Mídia gerada`, uma
+linha por afirmação — custo controlado, revisão humana, mídia marcada, hot path não bloqueado —, cada
+uma com o código que a prende e o teste que a prova. A régua de cada afirmação está em
+`.morph/framework/standards/ai-agents/modalities-image-gen.md`, `ai-agents/media-video.md` e
+`ai-agents/media-pipeline.md`. Afirmação falsa é bloqueador. Sem a seção, o gate pausa.
 
 **Prompt ou modelo alterado**: o nó `evals` do verify é a prova; sem ele, o gate pausa sozinho.
 
@@ -110,23 +98,27 @@ havendo item decidido, o gate pausa.
 
 ## Revisor (`4-review/reviewer.md`)
 
-Read-only, sobre o commit do dispatch: `git diff {base}..{sha}`, `git show {sha}:<caminho>`. Nunca a
-árvore de trabalho — o verificador pode estar com um mutante aplicado nela. Default SHIP.
+Read-only, sobre o commit do dispatch: `git diff {base}..{sha}`, `git show {sha}:<caminho>`, e o
+`2-plan/plan.md` (a spec). Nunca a árvore de trabalho: o commit é o que foi provado. Default SHIP.
 
-1. **Escopo**: o diff contra as fatias (`arquivos:`) e o `## Contrato de implementação` do plano.
+1. **Escopo**: o diff contra os cenários e o `## Contrato de implementação` do plano.
    Teste além do orçamento também é escopo: teste para Cn `prova: leitura`, mais de um teste por Cn de
    risco sem porquê no plano, teste que só fixa texto/constante/DTO, o mesmo comportamento em duas
-   camadas — bloqueador `escopo` (apague, não acrescente). Teste apagado sem porquê no relatório da
-   fatia, edição de `.sln`/`.csproj`/glob do runner que tira testes da execução, ou `expectedCount` menor no `.morph/config/config.json` do diff sem teste apagado no mesmo
+   camadas — bloqueador `escopo` (apague, não acrescente). Teste apagado sem porquê nas `## Notas` do
+   `report.md`, edição de `.sln`/`.csproj`/glob do runner que tira testes da execução, ou `expectedCount` menor no `.morph/config/config.json` do diff sem teste apagado no mesmo
    diff, é bloqueador `regressao`: é suíte que parou de rodar, não limpeza.
 2. **Arquitetura**: padrão ou abstração nova contra o stack do projeto e os standards (camada que o
    projeto não usa, repositório sobre o DbContext, dependência nova sem decisão no plano).
-3. **Regressão**: para cada símbolo público alterado, `morph-spec graph affected <símbolo> --prod --json`.
+3. **Regressão**: abra pela árvore do que mudou, `morph-spec graph diff --base {base} --json` (símbolos
+   tocados `+`/`~` e quem chama quem). Se ela recusar (`stale-graph`, `graph-drift`, `no-graph`), leia o
+   diff cru. Para cada símbolo público alterado, `morph-spec graph affected <símbolo> --prod --json`.
    Sem grafo (`no-graph`, `not-found`, `ambiguous`), caia para `git grep -n <símbolo> {sha}` e siga — a
    ausência de grafo nunca bloqueia, e ausência de consumidor nunca sai do grafo.
 4. **O que a correção abriu**: revisando a correção de uma rodada anterior, releia o comportamento
    vizinho ao que ela mudou.
 5. **Performance só com evidência**: lista sem paginação no servidor sobre volume real, N+1 visível.
+   **Irreversível não declarado**: o que fica depois de um `git revert` (dado apagado ou reescrito, mensagem
+   enviada, cobrança, contrato externo mudado) sem um `Cn` com `degrau:` que o cubra → bloqueador `irreversivel`.
 6. **Chamada a LLM**: dá para reconstruir o que foi ao provedor e o que ele respondeu neste turno?
    Não → nota.
 7. **Tela no diff**: cor ou espaçamento literal fora do CSS de tokens, mais de uma ação primária,

package/framework/hooks/README.md

@@ -7,9 +7,9 @@ Comprehensive hooks system for enforcing spec-driven development at the Claude C
 ```
 framework/hooks/
 ├── claude-code/
-│   ├── core/          # every hook, plus chain.js (one process per multi-hook group)
-│   └── statusline.py  # global statusline
+│   └── core/          # every hook, plus chain.js (one process per multi-hook group)
 ├── shared/            # code hooks share (and src/ imports): state reader, guards, e2e, heavy, telemetry
+├── statusline.js      # global statusline, not a hook: phase and scenarios through the project's .morph/framework/hooks/shared
 └── README.md
 ```
 
@@ -28,8 +28,7 @@ typechecks or runs tests: that is `morph-spec verify`.
 | **PreToolUse** (Bash) | conventional-commit.js | Block | Blocks a `git commit -m` whose subject is not Conventional Commits (`<type>(<scope>): <subject>`); a `$(…)`/heredoc message, `-F` and git-generated `Merge`/`Revert` pass |
 | **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 |
-| **PreToolUse** (Bash) | warn-bash-source-write.js | Warn | Heredoc/redirect/`tee` into project source (`isProjectSource`): context naming the file, the command still runs — Write/Edit is what phase, protected-file and comment guards see |
-| **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>`), bases a task tree on the dispatcher's `morph/<f>` branch when `worktree.baseRef` is unset (`"head"` = current HEAD, `"fresh"` = default branch), prints the path as its last stdout line. CLI unreachable → plain git, still under `<root>/worktrees/` |
+| **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>`), bases a task tree on the default branch, 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) | comment-guard.js | Blocking | Blocks when the edit ADDED a comment the `architecture-code-comments` standard never allows: process history (ADR, scenario/slice id, gate, plan.md), banner/`#region`, a block over 3 lines, or a doc-comment outside a published package. Old comments are never reported; last link of the chain |
 | **PostToolUse** (Write\|Edit\|AskUserQuestion) | state-sync.js | State sync | Autonomous state updates (feature register, output tracking, gate approval) |
@@ -37,6 +36,7 @@ typechecks or runs tests: that is `morph-spec verify`.
 | **PostToolUse** (all tools) | telemetry-log.js | Telemetry | Appends every tool call (skill, sub-agent dispatch + prompt, knowledge-base read, bash/edit) to `.morph/logs/events.jsonl`; silent, fail-open — the NLH execution-path capture read back by `morph-spec telemetry` |
 | **PostToolUse** (all tools) | loop-detect.js | Advisory | Warns when the last 8 actions collapse to ≤2 unique signatures |
 | **PostToolUse** (all tools) | graph-refresh-kick.js | Background | After a Bash or PowerShell command that runs git/gh/morph-spec, launches the DETACHED refresh of the ROOT's codebase graph (`shared/graph-refresh.js`: cwd in the git common dir, never a worktree; one lock per repository; staleness by `shared/graph-freshness.js` — stamp plus the per-tree run record in `<git-common-dir>/morph-spec/graph-refresh-state.json`); never waits, never injects |
+| **PostToolUse** (all tools) | masked-exit.js | Advisory | After a Bash test/build/verify run (`testRunKind`/`morphVerifyCall`/`heavyKind` of the producer) whose exit `exitCodeMasked` hides (`\| tail`, `; echo`, `\|\| true`, `&`), names the form and says to write the output to `.morph/logs/test-last.log` and read it; silent when the command prints `$?`/`PIPESTATUS` |
 | **PostToolUseFailure** (all tools) | telemetry-log.js | Telemetry | The failed call (a Bash that exits non-zero fires only this event): exit code parsed from the `Exit code N` line, outcome and duration — never the error body |
 | **PostToolBatch** | telemetry-log.js | Telemetry | One `ToolBatch` event per model turn that used tools (the turn counter of `cost --metrics`) |
 | **SubagentStop** | telemetry-log.js | Telemetry | `AgentUsage`: the sub-agent's token usage read from its own transcript, as a delta per agent; never blocks the stop |

package/framework/hooks/claude-code/core/README.md

@@ -4,4 +4,4 @@ See `framework/MORPH.md` for full documentation.
 
 ## test-budget
 
-`PreToolUse` Bash (antes do `heavy-gate`), `PostToolUse` e `PostToolUseFailure`. Só age em sub-agent (`agent_id`) com `.morph/` presente. Nega: `morph-spec verify` sem `--filter`; a 4ª rodada de teste do mesmo sub-agent (rodada = `testRunKind` ou `verify --filter`; exit 3 não conta), mandando gravar `PARCIAL` e devolver; todo teste ou `verify` de `morph-verifier`/`morph-reviewer`/`morph-security` (`morph-spec mutate` passa). Contador em `.morph/memory/test-runs/<agent_id>.json`; o `SendMessage` do orquestrador para o agente (a retomada depois do `PARCIAL`) zera o dele. Fail-open.
+`PreToolUse` Bash (antes do `heavy-gate`). Só age nos agentes do Gate 3 (`agent_id` com `agent_type` em `REVIEW_AGENT_TYPES`: `morph-verifier`/`morph-reviewer`/`morph-security`) com `.morph/` presente. Nega `morph-spec verify` sem `--filter` e a suíte de teste inteira; libera o teste filtrado (`testRunCall` de `framework/hooks/shared/heavy-command.js` decide o que é filtro). A sessão principal e os demais sub-agents não são tocados. Sem contador. Fail-open.

package/framework/hooks/claude-code/core/denylist.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.3.0",
+  "version": "1.4.0",
   "patterns": [
     "DROP TABLE",
     "DROP DATABASE",
@@ -76,7 +76,7 @@
       ],
       "subagentOnly": true,
       "display": "git add -A",
-      "reason": "leva junto o arquivo de outra fatia na mesma árvore; `git add <paths>` só dos seus"
+      "reason": "altera a árvore que o Gate 3 está lendo"
     },
     {
       "executable": "git",
@@ -85,7 +85,7 @@
       ],
       "subagentOnly": true,
       "display": "git stash",
-      "reason": "mexe na árvore que outras fatias e o verificador estão usando"
+      "reason": "altera a árvore que o Gate 3 está lendo"
     },
     {
       "executable": "git",
@@ -100,7 +100,7 @@
       ],
       "subagentOnly": true,
       "display": "git checkout --",
-      "reason": "reverte código de produção; a prova de que o teste morde é do verificador"
+      "reason": "altera a árvore que o Gate 3 está lendo"
     }
   ]
 }

package/framework/hooks/claude-code/core/gate-guard.js

@@ -70,6 +70,15 @@ function checkAskUserQuestion(input, sessionRoot) {
         'PostToolUse'
       );
     }
+    if (decision.resolver === 'session') {
+      return contextResult(
+        `⚠️ [morph-spec] GATE ASKED TOO EARLY — o Gate "${gate}" pausou com resolver:"session" ` +
+        `(${decision.reason || 'sinal mecânico'}): essa pausa não é do humano. ` +
+        `Faça o que a razão diz e rode \`morph-spec gate-check ${feature} ${gate}\` de novo; ` +
+        `a pergunta só vem quando o gate-check devolver resolver:"human".`,
+        'PostToolUse'
+      );
+    }
     return null;
   }
   return null;

package/framework/hooks/claude-code/core/masked-exit.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { stateExists } from '../../shared/state-reader.js';
+import { contextResult, runStandalone } from '../../shared/hook-response.js';
+import { exitCodeMasked, hasUnquotedPipe, producerOf } from '../../shared/command-tokens.js';
+import { heavyKind, morphVerifyCall, testRunKind } from '../../shared/heavy-command.js';
+
+// Printing `$?` or PIPESTATUS puts the real code in the output, so the session already sees it.
+const EXIT_SHOWN = /\$\?|PIPESTATUS/;
+
+function runKind(producer) {
+  if (morphVerifyCall(producer)) return 'morph-spec verify';
+  return testRunKind(producer) ?? heavyKind(producer);
+}
+
+function maskForm(command) {
+  const bare = command.replace(/"[^"]*"|'[^']*'/g, '""');
+  if (hasUnquotedPipe(command) && !/\bpipefail\b/.test(command)) {
+    const filter = /(?<![|>])\|(?!\|)\s*([^\s|;&]+)/.exec(bare)?.[1];
+    return filter ? `| ${filter}` : '|';
+  }
+  const or = /\|\|\s*([^\s;&|]+)/.exec(bare);
+  if (or) return `|| ${or[1]}`;
+  const reporter = /;\s*(echo|printf|true|:|exit\s+0)\b/.exec(bare);
+  if (reporter) return `; ${reporter[1]}`;
+  if (/(?<![&>])&(?![&>])/.test(bare)) return '&';
+  return 'o comando que vem depois';
+}
+
+export async function run(payload) {
+  try {
+    if (payload?.tool_name !== 'Bash') return null;
+    const command = payload.tool_input?.command;
+    if (typeof command !== 'string' || !command.trim()) return null;
+    if (!stateExists(payload.cwd || undefined)) return null;
+    if (!exitCodeMasked(command) || EXIT_SHOWN.test(command)) return null;
+    const kind = runKind(producerOf(command));
+    if (!kind) return null;
+    return contextResult(
+      `⚠️ [morph-spec] O exit de \`${kind}\` está mascarado por \`${maskForm(command)}\`: o código que você viu é o do último comando, não o do teste/build. `
+      + 'Grave a saída em arquivo (`… > .morph/logs/test-last.log 2>&1`) e leia o arquivo.',
+      'PostToolUse'
+    );
+  } catch {
+    return null;
+  }
+}
+
+await runStandalone(run);

package/framework/hooks/claude-code/core/state-sync.js

@@ -164,8 +164,11 @@ function handleAskUserQuestion(input, sessionRoot) {
     }
 
     // Same contract as `approve --self-assessed`: approving review without its reports is stamped, never silent.
+    // The reports live in the tree that ran the review, which may not be the one the feature was found in.
+    const trees = allWorkTrees(sessionRoot);
+    const reportIn = (f) => trees.some((t) => existsSync(join(t, '.morph', 'features', featureName, '4-review', f)));
     const selfAssessed = gate === 'review' && feature?.workType !== 'hotfix'
-      && (feature?.workType === 'chore' ? ['reviewer.md'] : ['verifier.md', 'reviewer.md']).some((f) => !existsSync(join(root, '.morph', 'features', featureName, '4-review', f)));
+      && (feature?.workType === 'chore' ? ['reviewer.md'] : ['verifier.md', 'reviewer.md']).some((f) => !reportIn(f));
     if (selfAssessed) {
       warnings.push(
         `⚠️ [morph-spec] Gate 3 de "${featureName}" aprovado SEM os relatórios de review independentes (verifier.md, reviewer.md) — ` +

package/framework/hooks/claude-code/core/telemetry-log.js

@@ -46,8 +46,7 @@ function classifyReadKind(target) {
   if (inFeature) {
     const rel = inFeature[1];
     const PLAN_ARTIFACT_BASENAMES = new Set([
-      'plan.md', 'checks.json',
-      'handoff.md',
+      'plan.md', 'checks.json', 'report.md',
     ]);
     const base = rel.split('/').pop();
     if (PLAN_ARTIFACT_BASENAMES.has(base) || rel.includes('reports/')) {

package/framework/hooks/claude-code/core/test-budget.js

@@ -1,87 +1,27 @@
 #!/usr/bin/env node
-import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
 import { blockResult, runStandalone } from '../../shared/hook-response.js';
 import { stateExists } from '../../shared/state-reader.js';
-import { QUEUE_FULL_EXIT, REVIEW_AGENT_TYPES, morphVerifyCall, testRunKind } from '../../shared/heavy-command.js';
-
-export const TEST_RUN_BUDGET = 3;
+import { REVIEW_AGENT_TYPES, morphVerifyCall, testRunCall } from '../../shared/heavy-command.js';
 
 export const REASONS = {
-  verify: '`morph-spec verify` cheio é do orquestrador, depois do seu retorno. Rode só o filtro dos seus testes.',
-  budget: '4ª rodada de teste nesta fatia. Grave `PARCIAL` na 1ª linha do relatório com o que ainda falha e devolva: o orquestrador decide.',
-  review: 'Agente de review não roda teste: a prova é o verify do orquestrador. Para provar que um teste morde, `morph-spec mutate`.',
+  verify: '`morph-spec verify` sem `--filter` é a prova do gate, rodada pela sessão. Rode só o nó do cenário: `morph-spec verify <f> --filter <nó> --no-persist`.',
+  suite: 'Suíte inteira não: rode só o teste do cenário que você está provando (o arquivo, `-t <nome>` ou `--filter <expr>`).',
 };
 
-// Pre and Post must land on the same counter: a sub-agent's cwd drifts into subfolders.
 const projectRoot = (payload, env) => env.CLAUDE_PROJECT_DIR || payload?.cwd || process.cwd();
 
-const counterPath = (root, agentId) =>
-  join(root, '.morph', 'memory', 'test-runs', `${String(agentId).replace(/[^A-Za-z0-9_-]/g, '_')}.json`);
-
-function readCounter(path) {
-  try {
-    return JSON.parse(readFileSync(path, 'utf-8')) ?? {};
-  } catch {
-    return {};
-  }
-}
-
-const readRuns = (path) => Number(readCounter(path).runs) || 0;
-
-function recordRun(path, name) {
-  mkdirSync(join(path, '..'), { recursive: true });
-  const tmp = `${path}.tmp.${process.pid}`;
-  writeFileSync(tmp, JSON.stringify({ runs: readRuns(path) + 1, ...(name ? { name } : {}) }));
-  renameSync(tmp, path);
-}
-
-function exitCodeOf(payload) {
-  const code = /^exit code (\d+)/i.exec(String(payload.error ?? '').split('\n', 1)[0]);
-  return code ? Number(code[1]) : null;
-}
-
-// The orchestrator resuming an agent is the decision the budget hands back to it: a fresh budget.
-function resetOnResume(payload, env) {
-  const to = payload.tool_input?.to;
-  if (payload.agent_id || payload.hook_event_name !== 'PostToolUse' || !to) return;
-  const root = projectRoot(payload, env);
-  if (!stateExists(root)) return;
-  // `to` may be the dispatch name instead of the id: the counter records the name it ran under.
-  const byId = counterPath(root, to);
-  const dir = join(byId, '..');
-  for (const file of readdirSync(dir)) {
-    const path = join(dir, file);
-    if (path === byId || readCounter(path).name === to) rmSync(path, { force: true });
-  }
-}
-
 export async function run(payload, deps = {}) {
   try {
-    if (payload?.tool_name === 'SendMessage') {
-      resetOnResume(payload, deps.env ?? process.env);
-      return null;
-    }
-    if (payload?.tool_name !== 'Bash' || !payload.agent_id) return null;
+    if (payload?.hook_event_name !== 'PreToolUse' || payload.tool_name !== 'Bash') return null;
+    if (!payload.agent_id || !REVIEW_AGENT_TYPES.has(payload.agent_type)) return null;
     const command = payload.tool_input?.command || '';
-    const kind = testRunKind(command);
     const verify = morphVerifyCall(command);
-    if (!kind && !verify) return null;
-
-    const env = deps.env ?? process.env;
-    const root = projectRoot(payload, env);
-    if (!stateExists(root)) return null;
-    const path = counterPath(root, payload.agent_id);
-
-    if (payload.hook_event_name === 'PreToolUse') {
-      if (REVIEW_AGENT_TYPES.has(payload.agent_type)) return blockResult(REASONS.review);
-      if (verify && !verify.filtered) return blockResult(REASONS.verify);
-      if (readRuns(path) >= TEST_RUN_BUDGET) return blockResult(REASONS.budget);
-      return null;
-    }
+    const tests = testRunCall(command);
+    if (!verify && !tests) return null;
+    if (!stateExists(projectRoot(payload, deps.env ?? process.env))) return null;
 
-    if (payload.hook_event_name === 'PostToolUseFailure' && exitCodeOf(payload) === QUEUE_FULL_EXIT) return null;
-    if (payload.hook_event_name === 'PostToolUse' || payload.hook_event_name === 'PostToolUseFailure') recordRun(path, payload.agent_type);
+    if (verify && !verify.filtered) return blockResult(REASONS.verify);
+    if (tests && !tests.filtered) return blockResult(REASONS.suite);
   } catch {}
   return null;
 }

package/framework/hooks/claude-code/core/validate-completion.js

@@ -9,30 +9,17 @@ import {
 import { contextResult, runStandalone } from '../../shared/hook-response.js';
 import { appendTelemetryEvent } from '../../shared/telemetry-logger.js';
 import { readTranscriptUsage, usageDelta } from '../../shared/transcript-usage.js';
-import { sliceProgress, sliceReportPath, inspectReport } from '../../shared/slice-progress.js';
-
-// Advisory: the same rule `report-check` applies when the orchestrator resumes control.
-function auditSliceReports(featurePath) {
-  const progress = sliceProgress(featurePath);
-  if (!progress) return [];
-  const warnings = [];
-  for (const slice of progress.slices) {
-    if (slice.status !== 'feito') continue;
-    const { missing } = inspectReport(sliceReportPath(featurePath, slice.id), { covers: slice.covers });
-    if (missing.length) {
-      const hints = missing.map((id) => MISSING_HINT[id] ?? `cite ${id} pelo id`);
-      warnings.push(`relatório de ${slice.id} sem: ${missing.join(', ')} — ${hints.join('; ')} (formato na skill morph-apply; morph-spec report-check)`);
-    }
-  }
-  return warnings;
+import { implementProgress } from '../../shared/report-progress.js';
+
+function auditReport(featurePath) {
+  const progress = implementProgress(featurePath);
+  if (!progress || progress.legacy) return [];
+  const bare = progress.checks.filter((c) => c.status === 'feito' && !c.evidence.trim()).map((c) => c.id);
+  return bare.length
+    ? [`report.md: ${bare.join(', ')} feito sem evidência — o teste, a linha de código ou o passo que prova (morph-spec report-check)`]
+    : [];
 }
 
-const MISSING_HINT = {
-  what: '2-3 frases do que foi feito e como foi provado',
-  files: 'linha **Arquivos:** com todo arquivo criado ou modificado',
-  partial: '1ª linha PARCIAL: a fatia não terminou',
-};
-
 const COMPACT_TRIGGER_PHASES = new Set(['implement']);
 
 const HEAVY_SOURCE_PHASES = new Set(['plan', 'uiux']);
@@ -89,7 +76,7 @@ export async function run(payload) {
     // Hash-gated: the audit re-runs every Stop, so only a changed warning set is injected; resolving clears the hash.
     try {
       const featurePath = join(cwd, '.morph', 'features', name);
-      const reportWarnings = auditSliceReports(featurePath);
+      const reportWarnings = auditReport(featurePath);
 
       const warnedHashesPath = join(memDir, 'warned-hashes.json');
       let warnedHashes = {};
@@ -100,7 +87,7 @@ export async function run(payload) {
       if (reportWarnings.length > 0) {
         const hash = createHash('sha1').update(reportWarnings.join('\n')).digest('hex');
         if (warnedHashes[name]?.reports !== hash) {
-          warnings.push('📋 Relatórios de fatia:');
+          warnings.push('📋 3-implement/report.md:');
           for (const w of reportWarnings) warnings.push(`  • ${w}`);
           warnedHashes[name] = { ...warnedHashes[name], reports: hash };
           try { writeFileSync(warnedHashesPath, JSON.stringify(warnedHashes, null, 2), 'utf-8'); } catch {}

package/framework/hooks/claude-code/core/worktree-context.js

@@ -9,13 +9,12 @@ import {
   getFeaturePhase,
   getPendingGates,
 } from '../../shared/state-reader.js';
-import { sliceProgress } from '../../shared/slice-progress.js';
+import { implementProgress } from '../../shared/report-progress.js';
 import { collectNextSignals, decideNext, formatNext } from '../../shared/next-step.js';
 import { contextResult, runStandalone } from '../../shared/hook-response.js';
 import { acquireClaim, foreignClaim, claimAge } from '../../shared/claim-registry.js';
 import { rotateEventsLogIfLarge } from '../../shared/telemetry-logger.js';
 import { kickGraphRefresh, seedFromPrimary } from '../../shared/graph-refresh.js';
-import { kickAgentReap } from '../../shared/agent-reap.js';
 import { isInContainer } from '../../shared/worktree-root.js';
 import { isSecondaryWorktree, resolveGitCommonDir } from '../../shared/git-paths.js';
 
@@ -121,18 +120,6 @@ function buildEnvLine(dir) {
   }
 }
 
-function buildHandoffLine(dir, feature) {
-  try {
-    const handoffPath = join(dir, '.morph', 'features', feature, 'handoff.md');
-    if (!existsSync(handoffPath)) return null;
-    const generatedAt = readFileSync(handoffPath, 'utf8')
-      .match(/gerado em (\d{4}-\d{2}-\d{2}T[\d:.]+Z)/)?.[1];
-    return `📄 Handoff: .morph/features/${feature}/handoff.md${generatedAt ? ` (gerado ${generatedAt})` : ''} — leia antes de continuar.`;
-  } catch {
-    return null;
-  }
-}
-
 // No git here, so verify staleness is unknown: an escalation the tree already moved past, or the
 // root skeleton of a feature living in a worktree, would be an order read from stale facts.
 function buildNextLine(dir, feature) {
@@ -161,9 +148,6 @@ function buildWorktreeContext(dir, feature) {
   const envLine = buildEnvLine(dir);
   if (envLine) text += `\n${envLine}`;
 
-  const handoffLine = buildHandoffLine(dir, feature);
-  if (handoffLine) text += `\n${handoffLine}`;
-
   text += buildMissingInfraWarning(dir);
   return text;
 }
@@ -185,11 +169,11 @@ function buildActiveFeatureSummary(dir) {
   if (!active) return null;
 
   const phase = getFeaturePhase(active.name, dir);
-  const slices = sliceProgress(join(dir, '.morph', 'features', active.name));
+  const progress = implementProgress(join(dir, '.morph', 'features', active.name));
   const pending = getPendingGates(active.name, dir);
 
   let text = `MORPH-SPEC: feature ativa ${active.name} (fase ${phase})`;
-  if (slices) text += ` · fatias ${slices.done}/${slices.total}`;
+  if (progress) text += ` · cenários ${progress.done}/${progress.total}`;
   if (pending.length) {
     text += ` · gates pendentes: ${pending.join(', ')}`;
   }
@@ -207,8 +191,8 @@ function claimBlock(dir, feature, sessionId) {
     if (!other) return '';
     return `\n⚠️  ATENÇÃO — a feature ${feature} tem claim VIVO de OUTRA sessão`
       + `\n   pid ${other.pid}${other.path ? ` · ${other.path}` : ''} · visto há ${claimAge(other)}`
-      + '\n   Duas sessões na mesma feature já custaram um relatório de fatia inteiro e um sub-agent'
-      + '\n   (o worktree sumiu debaixo dele). Confirme com a outra sessão ANTES de agir —'
+      + '\n   Duas sessões na mesma feature sobrescrevem o trabalho uma da outra.'
+      + '\n   Confirme com a outra sessão ANTES de agir —'
       + '\n   principalmente antes de `finish`, `archive` ou `delete`.'
       + `\n   Se aquela sessão morreu: morph-spec claim ${feature} --release`;
   } catch {
@@ -229,7 +213,6 @@ export async function run(payload) {
     // Only the ROOT's graph is refreshed in background: a detached process holding a worktree directory made `finish` fail on win32.
     try { seedFromPrimary(dir); } catch {}
     try { kickGraphRefresh(dir); } catch {}
-    try { kickAgentReap(dir); } catch {}
 
     if (isSecondaryWorktree(dir)) {
       const task = taskFromBranch(dir);