@polymorphism-tech/morph-spec 10.1.1 → 10.2.0

package/README.md

@@ -3,7 +3,7 @@
 > Spec-driven development framework for multi-stack projects. Turns feature requests into implementation-ready code through structured, AI-orchestrated phases.
 
 **Package:** `@polymorphism-tech/morph-spec`
-**Version:** 10.1.1  
+**Version:** 10.2.0  
 **Requires:** Node.js 22+, Claude Code
 
 ---
@@ -115,7 +115,7 @@ In `trust: "auto"` mode (default), gates auto-pass without risk signals. See `fr
 Check gate status:
 
 ```bash
-morph-spec approval-status {feature}
+morph-spec status {feature}
 ```
 
 ---
@@ -165,7 +165,6 @@ morph-spec fleet                              # Every active feature (root + wor
 morph-spec status {feature}                    # Feature status dashboard
 morph-spec approve {feature} {gate}            # Approve a phase gate (plan, uiux, review)
 morph-spec advance {feature}                   # Approve the current gate and scaffold the next phase folder
-morph-spec approval-status {feature}           # Show approval status for all gates
 morph-spec finish {feature} --pr|--merge       # Close a feature: archive + integrate (PR or local merge) + teardown
 morph-spec archive {feature}                   # Archive WITHOUT integrating (legacy feature / cleanup)
 ```
@@ -177,9 +176,6 @@ Progress within a feature is the slice reports `3-implement/reports/F{n}.md`: ab
 ### Validation
 
 ```bash
-morph-spec validate                    # Run all validators
-morph-spec validate {validator}        # Run specific validator
-morph-spec validate-feature {feature}  # Content-aware feature validation
 morph-spec verify {feature}            # Deterministic build+tests+validators chain, before the LLM judge
 ```
 
@@ -380,4 +376,4 @@ Code generated by morph-spec (contracts, templates, implementation output) belon
 
 ---
 
-*morph-spec v10.1.1 by [Polymorphism Tech](https://polymorphism.tech)*
+*morph-spec v10.2.0 by [Polymorphism Tech](https://polymorphism.tech)*

package/bin/morph-spec.js

@@ -35,7 +35,6 @@ const stackSetCommand = lazy('../src/commands/project/stack-set.js', 'stackSetCo
 const testsAuditCommand = lazy('../src/commands/validation/tests-audit.js', 'testsAuditCommand');
 
 const approveCommand = lazy('../src/commands/state/approve.js', 'approveCommand');
-const approvalStatusCommand = lazy('../src/commands/state/approve.js', 'approvalStatusCommand');
 const unapproveCommand = lazy('../src/commands/state/approve.js', 'unapproveCommand');
 const advanceCommand = lazy('../src/commands/state/advance.js', 'advanceCommand');
 const archiveCommand = lazy('../src/commands/state/archive.js', 'archiveCommand');
@@ -55,8 +54,6 @@ const graphAffectedCommand = lazy('../src/commands/graph/affected.js', 'graphAff
 const graphExplainCommand = lazy('../src/commands/graph/explain.js', 'graphExplainCommand');
 const graphDiffCommand = lazy('../src/commands/graph/diff.js', 'graphDiffCommand');
 
-const validateCommand = lazy('./validate.js', 'validateCommand');
-const validateFeatureCommand = lazy('../src/commands/validation/validate-feature.js', 'validateFeatureCommand');
 const verifyCommand = lazy('../src/commands/validation/verify.js', 'verifyCommand');
 const e2eUpCommand = lazy('../src/commands/e2e/e2e.js', 'e2eUpCommand');
 const e2eStatusCommand = lazy('../src/commands/e2e/e2e.js', 'e2eStatusCommand');
@@ -72,7 +69,6 @@ const contextRefreshCommand = lazy('../src/commands/context/context-refresh.js',
 
 const dashboardCommand = lazy('../src/commands/dashboard/dashboard.js', 'dashboardCommand');
 
-const telemetryCommand = lazy('../src/commands/observability/telemetry.js', 'telemetryCommand');
 const costCommand = lazy('../src/commands/observability/cost.js', 'costCommand');
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -216,12 +212,6 @@ program
   .option('--json', 'Output as JSON')
   .action((feature, options) => deleteCommand(feature, options));
 
-program
-  .command('approval-status <feature>')
-  .description('Show approval status for all gates')
-  .option('--json', 'Output as JSON')
-  .action((feature, options) => approvalStatusCommand(feature, options));
-
 program
   .command('unapprove <feature> <gate>')
   .description('Revoke a phase gate approval (recovery only)')
@@ -324,29 +314,6 @@ graphCommand
   .option('--json', 'Output as JSON')
   .action((options) => graphDiffCommand(options));
 
-program
-  .command('validate [validator]')
-  .description('Run project validations (all | packages | next-components | spec-tasks)')
-  .option('-v, --verbose', 'Show detailed output')
-  .option('--auto-fix, --fix', 'Auto-fix issues where possible')
-  .option('--no-fail', 'Don\'t exit with error code')
-  .action((validator, options) => {
-    const args = validator ? [validator] : ['all'];
-    if (options.verbose) args.push('--verbose');
-    if (options.autoFix) args.push('--auto-fix');
-    if (options.noFail) args.push('--no-fail');
-    validateCommand(args);
-  });
-
-program
-  .command('validate-feature <feature>')
-  .alias('vf')
-  .description('Content-aware validation of feature outputs (sections, schema, contracts)')
-  .option('--phase <phase>', 'Validate outputs for a specific phase')
-  .option('--json', 'Output as JSON')
-  .option('-v, --verbose', 'Show detailed output')
-  .action(validateFeatureCommand);
-
 program
   .command('verify <feature>')
   .description('Run the deterministic verification chain (build + tests + validators + e2e) — code before the LLM judge')
@@ -361,6 +328,7 @@ program
   .option('--skip-build', 'Skip the build node. The run is partial, so the verification stamp is NOT written (reason "skip-build")')
   .option('--skip-e2e', 'Skip the e2e node (Docker bring-up + Playwright)')
   .option('--fresh-e2e', 'Recreate the e2e stack from scratch: down -v (named volumes included), drop the freshness stamp, rebuild, re-seed auth')
+  .option('--fresh', 'Run every node again, ignoring the green nodes of an earlier run on this same tree. Use it when something outside the tree changed (.env, database, tool version)')
   .option('--no-persist', 'Do not persist the result to feature.json')
   .option('--ci', 'Push morph/<feature> and take the proof from the project CI (creates .github/workflows/morph-verify.yml when no workflow runs verify). Same stamp, source "ci". No GitHub/gh/workflow = local verify with the reason; uncommitted code = exit 2; CI still running after 50 min = exit 3, no stamp')
   .action((feature, options) =>
@@ -593,14 +561,6 @@ program
   .option('--no-open', 'Don\'t auto-open browser')
   .action(dashboardCommand);
 
-program
-  .command('telemetry')
-  .description('Summarize the harness execution path from .morph/logs/events.jsonl (skills, personas, standards read, tool mix, prompts)')
-  .option('--json', 'Output the aggregate as JSON')
-  .option('--feature <name>', 'Narrow the summary to a single feature')
-  .option('--limit <n>', 'How many recent prompts to show (default 10)', (v) => parseInt(v, 10))
-  .action((options) => telemetryCommand(options));
-
 program
   .command('cost [feature]')
   .description('Cost-facing view over .morph/logs/events.jsonl: bytes re-ingested by kind (proxy, not tokens), dispatch counts, real tokens when observed')

package/claude-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "morph-spec",
-  "version": "10.1.1",
+  "version": "10.2.0",
   "displayName": "MORPH-SPEC Framework",
   "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
   "publisher": "polymorphism-tech",

package/docs/CHEATSHEET.md

@@ -56,7 +56,6 @@ plan → [uiux] → implement → review
 ```bash
 morph-spec approve {feature} {gate} [--mode auto] [--approver name] [--notes text]
 morph-spec advance {feature} [--design]         # approve current gate + scaffold next phase folder in one step
-morph-spec approval-status {feature} [--json]
 morph-spec unapprove {feature} {gate} [--reason text]   # recovery only
 morph-spec finish {feature} --pr|--merge [--push] [--keep] [--force] [--discard-ignored]   # normal close: archive + integrate + teardown
 morph-spec archive {feature} [--force] [--no-git]        # archive WITHOUT integrating (legacy feature / cleanup)
@@ -97,8 +96,6 @@ Never hand-edit `gateDecisions`/`approvalGates` in `feature.json` — always go
 
 ```bash
 morph-spec plan-check {feature} [--json]                           # validate plan.md, write checks.json
-morph-spec validate [packages|next-components]
-morph-spec validate-feature {feature} [--phase {phase}] [--json]   # alias: vf
 morph-spec verify {feature} [--json] [--filter <ids>] [--skip-tests] [--skip-build] [--skip-e2e]   # deterministic build+test+validator+e2e chain; the gate reads the unfiltered run
 morph-spec report-check {feature} [--before-eval] [--json]         # state of the implement and of the Gate 3 reports
 ```
@@ -177,4 +174,4 @@ Never edited directly — go through CLI commands or `morph-spec update` instead
 
 ---
 
-*morph-spec v10.1.1 by Polymorphism Tech*
+*morph-spec v10.2.0 by Polymorphism Tech*

package/docs/QUICKSTART.md

@@ -89,4 +89,4 @@ morph-spec doctor
 
 ---
 
-*morph-spec v10.1.1 by Polymorphism Tech*
+*morph-spec v10.2.0 by Polymorphism Tech*

package/framework/agents.json

@@ -18,7 +18,6 @@
         "prove",
         "scenario",
         "check",
-        "mutation",
         "verdict"
       ],
       "stack": [

package/framework/commands/morph-archive.md

@@ -23,7 +23,7 @@ is idempotent: an already-archived feature is reported, not re-moved.
 
 1. **Verify** the feature cleared Gate 3:
    ```
-   morph-spec approval-status {feature}
+   morph-spec status {feature} --verbose
    ```
    Gate `review` must be `approved`. If not, stop and report what's missing (don't force it without
    the user's say-so).

package/framework/commands/morph-preflight.md

@@ -26,15 +26,14 @@ These checks verify that the morph-spec workflow is complete for the feature bei
 
 ```bash
 # Verify implementation is complete
-morph-spec status {feature}
-morph-spec approval-status {feature}
+morph-spec status {feature} --verbose
 morph-spec verify {feature}
 ```
 
 | Check | Command | Pass Criteria |
 |-------|---------|---------------|
 | Phase is implement or later | `status` | phase derived as `implement` or `review` |
-| All gates approved | `approval-status` | plan (and uiux, when the feature has design) and review gates approved |
+| All gates approved | `status --verbose` | plan (and uiux, when the feature has design) and review gates approved |
 | Build, tests and validators pass | `verify` | every node green |
 | All slices reported | `status` → Fatias | 0 slices pending or partial |
 
@@ -42,7 +41,7 @@ morph-spec verify {feature}
 
 ---
 
-**Tests:** run them only through `morph-spec verify {feature}` — never a bare `dotnet test`/`npm test`, which bypasses the heavy-job queue and leaves no proof the gates read. Any red node blocks deployment.
+**Tests:** the proof the gates read is `morph-spec verify {feature}` without `--filter`. A bare `dotnet test`/`npm test` is fine for checking something (it goes through the heavy-job queue), but it leaves no proof. Any red node blocks deployment.
 
 ---
 

package/framework/docs/CLI.md

@@ -64,7 +64,7 @@ A tabela é a mesma régua que `shouldPauseGate` aplica e que o `gate-check` imp
 | `screenChecklist` | item em aberto | **uiux**: tela sem checklist completo, nenhuma `## Tela:`, ou tela sem protótipo, prints 1280/390, ou seletor e print de cada estado. **ship**: item decidido sem linha em `## Checklist de tela` |
 | `planChecks` | ≠ `fresh` | `checks.json` ausente ou de outra versão do `plan.md`: rode `plan-check`. Só no **plano**; `approve`/`advance` automáticos recusam |
 | `workType` | === 'hotfix' | Gate 3 pausa SEMPRE (ver "Gates por tipo de trabalho") |
-| `planCritique` | `missing`/`no-hash`/`stale` | `2-plan/critica.md` ausente, sem `**Plan-Hash:**`, ou de outra versão do plano sem `**Aplicado-em:**` que cubra a atual (`signal: plan-critique`). Só no **plano**, `chore`/`hotfix` isentos (`exempt`); `approve`/`advance` automáticos recusam |
+| `planCritique` | `missing`/`no-hash`/`stale` | `2-plan/critica.md` ausente, sem `**Plan-Hash:**`, ou de outra versão do plano sem `**Aplicado-em:**` que cubra a atual (`signal: plan-critique`). Só no **plano**, `chore`/`hotfix` e plano pequeno isentos (`exempt`: até 3 cenários, todos `prova: teste` ou `leitura`, sem degrau e sem mídia gerada); `approve`/`advance` automáticos recusam |
 | `rungs` | `Cn` com `degrau: migrar` ou `irreversível` (`checks.json`) | **plano**: pausa nomeando os `Cn` (`signal: rung`), e `approve`/`advance` automáticos recusam. **ship**: pausa se o plano não teve aprovação humana (chore, policy) |
 | `migrationsTouched` | caminho `migrations/` no diff, `rungs` vazio | Feature mexeu em dado sem declarar o degrau (`signal: rung-undeclared`). Só no **ship** |
 | `contractsTouched` | `openapi.{yaml,yml,json}`, `swagger.{…}` ou `.proto` no diff, sem `Cn` `irreversível` | O arquivo de contrato mudou sem o degrau (`signal: rung-undeclared`). Webhook e endpoint ficam com o bloqueador `irreversivel` do revisor. Só no **ship** |
@@ -125,7 +125,7 @@ Feature sem `workType` (pré-v8) é tratada como `feature`.
 
 ### finish
 
-**`morph-spec finish <feature> --pr|--merge`** — o **encerramento único** da feature (worktree ou comum): **arquiva** commitando `features/{f} → archive/{f}` dentro de `morph/{f}` — depois integra: `--merge` na hora; `--pr` só abre o PR, sem integrar. **O payload distingue os dois** — `--merge` sai com `integrated: true`; `--pr` sai com `integrated: false`, `awaiting: "merge"`, `pr: {number, url}` e um `nextStep` apontando para o merge. **`finished: true` sai nos dois casos e marca só o comando ter terminado, nunca a integração** — `--pr` não encerra a feature, quem encerra é o merge do PR; até lá ela aparece em `morph-spec list`/`fleet` como `aguardando-merge`, sem cópia local (ver `list` acima e `doctor` abaixo).
+**`morph-spec finish <feature> --pr|--merge`** — o **encerramento único** da feature (worktree ou comum; a sessão escolhe por `finish.mode` do `config.json`, padrão `pr`): **arquiva** commitando `features/{f} → archive/{f}` dentro de `morph/{f}` — depois integra: `--merge` na hora; `--pr` só abre o PR, sem integrar. **O payload distingue os dois** — `--merge` sai com `integrated: true`; `--pr` sai com `integrated: false`, `awaiting: "merge"`, `pr: {number, url}` e um `nextStep` apontando para o merge. **`finished: true` sai nos dois casos e marca só o comando ter terminado, nunca a integração** — `--pr` não encerra a feature, quem encerra é o merge do PR; até lá ela aparece em `morph-spec list`/`fleet` como `aguardando-merge`, sem cópia local (ver `list` acima e `doctor` abaixo).
 
 **Índice de ADRs:** no mesmo commit do archive, o `finish` lê o `2-plan/plan.md` da feature: os ADRs de `## Decisões` com `**Alcance:** projeto` entram em `.morph/specs/adrs/` (um arquivo por ADR, `{feature}--ADR-{nnn}.md` — features paralelas nunca tocam o mesmo arquivo), e a tabela `ADR | Mudança | Escopo` de `### Conflitos com o acervo` retira (total, o arquivo sai) ou estreita (parcial, `scope:` no arquivo) os ADRs revogados — forma em `morph-spec plan-check --help`; o `plan-check` avisa, enquanto o plano ainda muda, a linha que o `finish` não aplicaria. O payload traz `adrIndex: {added, revoked, narrowed}` e `revocationProblems: [{id, reason, message}]` (linha malformada ou ambígua, ADR fora do índice) — cada chave só aparece com conteúdo, e nenhum problema recusa o `finish`.
 
@@ -277,7 +277,11 @@ Fail-open: uma poda que falha nunca derruba o comando. PROVE-or-DECLINE como o r
 
 ### verify
 
-**`morph-spec verify <feature> [--json] [--timeout <ms>] [--filter <ids>] [--record-baseline] [--refresh-cache] [--linux] [--linux-image <img>] [--skip-tests] [--skip-build] [--skip-e2e] [--fresh-e2e] [--no-persist] [--ci]`** — cadeia determinística build+testes+validadores+**e2e** (código antes do juiz LLM), sempre sobre a feature inteira. Antes da cadeia, instala em `.claude/rules/` (fora do git) a regra de stack que falta, pela stack do `config.json` somada à que os arquivos mostram (em stderr; nunca muda o veredito). Nunca grava o `config.json`: arquivo versionado mudado pelo próprio verify tornaria a prova velha e a árvore suja para o `--ci`; a tag nova entra pelo `plan-check` ou pelo `update`.
+**`morph-spec verify <feature> [--json] [--timeout <ms>] [--filter <ids>] [--record-baseline] [--refresh-cache] [--linux] [--linux-image <img>] [--skip-tests] [--skip-build] [--skip-e2e] [--fresh-e2e] [--fresh] [--no-persist] [--ci]`** — cadeia determinística build+testes+validadores+**e2e** (código antes do juiz LLM), sempre sobre a feature inteira. Antes da cadeia, instala em `.claude/rules/` (fora do git) a regra de stack que falta, pela stack do `config.json` somada à que os arquivos mostram (em stderr; nunca muda o veredito). Nunca grava o `config.json`: arquivo versionado mudado pelo próprio verify tornaria a prova velha e a árvore suja para o `--ci`; a tag nova entra pelo `plan-check` ou pelo `update`.
+
+**Reaproveitamento entre rodadas:** uma rodada completa grava o resultado por nó em `.git/morph-spec/verify-nodes-<feature>.json`, chaveado pela impressão da árvore (a régua de `treeFingerprint`). Mesma árvore: build, suíte e e2e verdes não rodam de novo (`reused[]`; os validadores sempre rodam), e o vermelho que passa agora entra em `flaky[]`, que o stamp guarda em `verification.flaky` para o verificador. Árvore mudada: nada é aproveitado; as suítes vermelhas da rodada anterior rodam primeiro e, se uma seguir vermelha, as outras ficam `skip` (`adiado: …`) e a rodada sai vermelha. O stamp verde sempre exige todos os nós verdes na árvore atual. Rodada parcial (`--filter`, `--skip-*`, `--linux`, `--record-baseline`, `--refresh-cache`, `--fresh-e2e`) não lê nem grava. O que a impressão não vê (`.env`, banco, versão de ferramenta): `--fresh` roda tudo.
+
+**Reexecução de spec que falhou:** com Playwright (`npx playwright test`), specs vermelhas rodam mais uma vez com `--last-failed` (exige Playwright 1.44+). Passaram: nó verde, com os nomes em `flaky[]`. Falharam: nó vermelho. `e2e.command` próprio sem `playwright` como argumento não reexecuta. Cada rodada de specs tem teto de `e2e.specTimeoutMs` (padrão 300 000 ms).
 
 O nó `e2e` é o único que **executa** a aplicação: sobe o `docker compose` do projeto, espera todo serviço ficar saudável, sobe os `e2e.hostServices` (ver `e2e` abaixo) e roda as specs Playwright quando existem (sem specs, ainda vale como smoke — "a app sobe" já pega o serviço não registrado que derruba o startup e passa batido no build). Sem compose mas com `e2e.hostServices`, a stack é **só de host**: sobem só os serviços do host, sem lint de isolamento do compose nem checagem de Docker, e as specs rodam contra eles. Sem compose e sem `e2e.hostServices`, o nó pula com `project does not containerize (no compose file)`; com a integração `docker` declarada e sem compose, falha.
 
@@ -311,7 +315,7 @@ Forma de `project.tests[]`, prefixo `[tests/{id}]` do `feedback[]`, regra de con
 
 **Validador que não pôde checar:** o `reuse` sem grafo não acha nada, e um `validators: pass` dos outros validadores o esconderia — então o `feedback[]` diz `[validators/reuse] não rodou: …`, e o nó leva `skipped: [{ validator, reason, unavailable }]` (quando o nó inteiro pula, a própria linha dele já dá o motivo).
 
-**Nós pesados (build, testes, e2e) esperam por slot** (`morph-spec heavy`): estouro da espera sai **exit 3** com `status: "busy"`, `persisted: false`, sem stamp e sem evento — não é vermelho, e o orquestrador repete a chamada.
+**Nós pesados (build, testes, e2e) esperam por slot** (`morph-spec heavy`): estouro da espera sai **exit 3** com `status: "busy"`, `persisted: false`, sem stamp e sem evento — não é vermelho: `morph-spec heavy status` mostra quem segura a vaga, e cabe no máximo uma chamada nova.
 
 **Por quê.** Um worktree é o checkout de OUTRA feature do mesmo repo: incluí-lo dobrava o relógio e reportava sobre código que não está sob verificação (em campo isso deu `tests: fail` no timeout exato, com o sumário da 1ª execução dizendo "Com falha: 0"). Sem o `down -v`, "fresco" reconstruiria a imagem e preservaria o banco velho — e um `storageState` capturado contra aquele banco continuaria autenticando um usuário que não existe mais (403 que parece app quebrada). A regra do `morph-plan` — *baseline é um COMANDO, nunca um número* — sobrevive porque ninguém digita o número: um valor escrito à mão descreve o que alguém acreditou, e a divergência entre a crença e a suíte é o defeito que a regra existe para matar.
 
@@ -325,7 +329,7 @@ Nenhuma regra de gate muda: e2e pulado, escopo, evals e stale valem igual.
 
 **Sem CI cai para o verify local, com a razão** (`project.ci: false`, origin fora do GitHub, `gh` ausente ou sem login, branch que não é `morph/<feature>`, token HTTPS sem o escopo `workflow` para criar o arquivo, push recusado, workflow que não disparou nem com `gh workflow run`, run sem o artefato). **Antes de tudo — com ou sem CI — reaproveita o stamp fresco:** último stamp `pass` com `sha`, nada fora de commit e `treeMovedSince(stamp.sha, HEAD)` falso (a mesma régua do `verificationStale`: só `.morph/` andou, ou o `config.json` mudou só `expectedCount`) → não empurra, não roda nem regrava, imprime "stamp verde e fresco — o CI não roda de novo" e o `--json` traz `reason: "stamp-reused"`, `status`, `nodes` e `reused: { sha, ts, source }`, exit 0.
 
-Código não commitado é **erro de uso (exit 2)**: o CI só vê commits. CI rodando depois de 50 min é **exit 3** (`status: "pending"`), sem stamp — não é vermelho. Com task, `--filter`, `--skip-*`, `--fresh-e2e`, `--linux`, `--record-baseline`, `--refresh-cache` ou `--no-persist`, erro de uso. Vermelho imprime `gh run view <id> --log-failed`.
+Código não commitado é **erro de uso (exit 2)**: o CI só vê commits. CI rodando depois de 50 min é **exit 3** (`status: "pending"`), sem stamp — não é vermelho. Com `--filter`, `--skip-*`, `--fresh-e2e`, `--linux`, `--record-baseline`, `--refresh-cache` ou `--no-persist`, erro de uso. Vermelho imprime `gh run view <id> --log-failed`.
 
 **O runner só tem o que está commitado:** o que testes e e2e leem de arquivo gitignored (`.env`, `appsettings.*.json` local, connection string do Neon, `storageState`) não existe lá, e o run sai vermelho sem defeito de código. Declare o valor como secret do repositório e exponha-o no `env:` do job em `morph-verify.yml` (o arquivo é do projeto: editar à mão é o esperado, e o `findCiWorkflow` continua aceitando enquanto ele chamar `morph-spec verify` publicando `morph-verify.json`), ou desligue com `project.ci: false`.
 
@@ -341,7 +345,7 @@ Teste é o que o validador `reuse` já trata como teste: arquivo `.test.` ou `.s
 
 Sem base git, ou sem linha de código adicionada, pula com razão; qualquer falha de medição também vira skip, nunca erro. 
 
-**Por quê.** Excesso justificado não silencia o aviso: a justificativa mora na task (orçamento do `morph-plan` passo 5), e é lá que o avaliador a lê.
+**Por quê.** Excesso justificado não silencia o aviso: a justificativa mora no plano, junto do `Cn`, e é lá que o revisor a lê.
 
 ### e2e
 
@@ -408,11 +412,11 @@ Isolamento entre worktrees: `COMPOSE_PROJECT_NAME=morph-{feature}` separa os con
 
 Env: `MORPH_HEAVY=off` desliga o semáforo (a suíte do próprio framework roda assim, para não enfileirar nos slots reais de quem a executa), `MORPH_HEAVY_SLOTS`, `MORPH_HEAVY_DIR`.
 
-**Fim do trabalho pesado:** no fim do `verify` de escopo **feature** (nunca no de task: cada task pagaria compilador frio), no `e2e down` e no `doctor --procs --prune`, roda `dotnet build-server shutdown` **só** se o projeto é .NET, `heavy.shutdownBuildServer` está ligado, nenhum slot está preso **e** nenhum `dotnet build|test|publish|msbuild` está vivo — sub-agents e IDE não passam pelo semáforo, então semáforo vazio não basta. Fail-open, timeout de 30 s, resultado em `cleanup` no `--json`.
+**Fim do trabalho pesado:** no `e2e down`, no `doctor --procs --prune` e no fim do `verify` quando a RAM livre está abaixo do dobro de `heavy.minFreeMemGb` (com folga, o compilador fica quente para a próxima rodada), roda `dotnet build-server shutdown` **só** se o projeto é .NET, `heavy.shutdownBuildServer` está ligado, nenhum slot está preso **e** nenhum `dotnet build|test|publish|msbuild` está vivo — sub-agents e IDE não passam pelo semáforo, então semáforo vazio não basta. Fail-open, timeout de 30 s, resultado em `cleanup` no `--json`.
 
 `heavy.disableNodeReuse` põe `MSBUILDDISABLENODEREUSE=1` enquanto o nó pesado roda e restaura depois. O `--linux` rotula o container (`morph-spec.verify=<runId>`, `morph-spec.root=<hash da raiz>`) e o remove **por label** no fim, nunca por nome; o `e2e down` usa `--remove-orphans`. O `verify` **não** derruba a stack e2e (`keepUp` é por desenho).
 
-**Bash cru (`heavy.gateBash`, padrão `true`):** a sessão roda build e teste quando quer, e um `dotnet build`/`dotnet test`/`npm test` pelo Bash não passa pelo `verify`, então dois elos das chains de hooks fazem o papel dele. `heavy-gate` (`PreToolUse` Bash, depois de todos os guards e antes do `worktree-env-inject`) reconhece o comando pesado — `dotnet build|test|publish|pack|msbuild|vstest`, `msbuild`, `npm|pnpm|yarn|bun test|build` e `run test|build[:x]`, `npx vitest|jest|playwright test|next build`, `vitest`, `jest`, `playwright test`, `next|vite build`, `docker build|buildx`, `docker compose|docker-compose up|build` — olhando o executável de cada segmento (`;`, `&&`, `||`, `|`, quebra de linha, fora de aspas): `git commit -m "fix build && dotnet test"` e `morph-spec heavy run -- dotnet test` não são pesados. Toma um slot e espera até `min(waitTimeoutSec, 540)` s — abaixo dos 600 s de timeout do hook, porque um `PreToolUse` que estoura o timeout **deixa a chamada rodar**; sem vaga no prazo a chamada é **recusada** (`deny`) com a causa e a instrução de repetir o mesmo comando, e não roda.
+**Bash cru (`heavy.gateBash`, padrão `true`):** a sessão roda build e teste quando quer, e um `dotnet build`/`dotnet test`/`npm test` pelo Bash não passa pelo `verify`, então dois elos das chains de hooks fazem o papel dele. `heavy-gate` (`PreToolUse` Bash, depois de todos os guards e antes do `worktree-env-inject`) reconhece o comando pesado — `dotnet build|test|publish|pack|msbuild|vstest`, `msbuild`, `npm|pnpm|yarn|bun test|build` e `run test|build[:x]`, `npx vitest|jest|playwright test|next build`, `vitest`, `jest`, `playwright test`, `next|vite build`, `docker build|buildx`, `docker compose|docker-compose up|build`, `powershell|pwsh` com um `.ps1` cujo nome contém `test` — olhando o executável de cada segmento (`;`, `&&`, `||`, `|`, quebra de linha, fora de aspas): `git commit -m "fix build && dotnet test"` e `morph-spec heavy run -- dotnet test` não são pesados. Toma um slot e espera até `min(waitTimeoutSec, 540)` s — abaixo dos 600 s de timeout do hook, porque um `PreToolUse` que estoura o timeout **deixa a chamada rodar**; sem vaga no prazo a chamada é **recusada** (`deny`) com a causa e a instrução de repetir o mesmo comando, e não roda.
 
 `heavy-release` (`PostToolUse` e `PostToolUseFailure`) devolve a vaga pelo `tool_use_id`.
 
@@ -496,7 +500,9 @@ A auditoria devolve **nada** sem tentar coisa alguma em três situações: nenhu
 
 **Bloco `tree`**, em toda saída e sem mudar o exit code: `dirty`/`dirtyCount` (o que não está commitado fora de `.morph/`), `diffstat` (contra `HEAD`), `commits` (sobre a default, até 10; `null` sem default), `fingerprint` (a mesma impressão da árvore que o `verify` grava), `head` e `branch`; `null` quando o git não responde — desconhecido, nunca árvore limpa.
 
-**`--before-eval`** grava em `4-review/tree-before-eval.json` a foto da árvore (HEAD e o blob de cada arquivo que difere dele, fora de `.morph/`) antes do dispatch da review, e daí em diante toda saída traz `tree.sinceBeforeEval: { at, headChanged, changed, changedCount }`; sem foto, `null`. Traz também `reviewModels`: `verifier.model` (`sonnet` por padrão, `opus` com prompt/modelo tocado ou plano que cita standard de mídia, com `reasons`), `reviewer.model` (`sonnet`), `security: { required, model: 'opus', reasons }` (exigida quando o diff toca auth, segredo, permissão, dado pessoal, pagamento ou migration) e `required`, a lista de papéis que o Gate 3 cobra — a mesma regra do `gate-check` e do `approve`.
+**`--before-eval`** grava em `4-review/tree-before-eval.json` a foto da árvore (HEAD e o blob de cada arquivo que difere dele, fora de `.morph/`) antes do dispatch da review, e daí em diante toda saída traz `tree.sinceBeforeEval: { at, headChanged, changed, changedCount }`; sem foto, `null`. Traz também `reviewModels`: `verifier.model` (`sonnet` por padrão, `opus` com prompt/modelo tocado ou plano que cita standard de mídia, com `reasons`), `reviewer.model` (`sonnet`), `security: { required, model: 'opus', reasons }` (exigida quando o diff toca auth, segredo, permissão, dado pessoal, pagamento ou migration) e `required`, a lista de papéis que o Gate 3 cobra — a mesma regra do `gate-check` e do `approve`. Traz ainda `gate3: { base, sha, flaky, e2eChecks, redispatch }`: `base` é o merge-base com a default, `flaky` vem do stamp do verify, `e2eChecks` lista os `Cn` de `prova: e2e`, e `redispatch` diz quem volta depois de uma correção (`null` sem relatório: todos os exigidos vão).
+
+**Quem volta depois de uma correção** (`reviewConfirmation`, a mesma regra no `approve`): papel com relatório atrás do `HEAD` volta, salvo SHIP limpo com delta estreito: arquivos citados nos bloqueadores (caminho ou nome) ou de teste; para a segurança, nenhum caminho sensível. O `approve` só dispensa esse papel com um papel que abriu bloqueador revisando o `HEAD`.
 
 ### plan-check
 
@@ -545,6 +551,7 @@ em runtime é `validateTestNodes()` — schema que ninguém chama é decoração
 | `command` | **sim** | Comando literal, executado por shell a partir de `cwd`. Nunca é reescrito pelo verify |
 | `cwd` | não (`"."`) | Relativo à raiz. Path que resolve **fora** da raiz é recusado (endereça outra árvore); `cwd` inexistente é `fail`, não `skip` — um skip esconderia erro de plano atrás de gate verde |
 | `runner` | não (inferido) | `dotnet` \| `vitest` \| `jest` \| `node-test` \| `playwright` \| `none` \| `evals`. Escolhe o extrator de contagem e se há prebuild. `none` = contagem DESCONHECIDA, nunca zero. `evals` é o único que **nunca é inferido** e o único que exige um bloco próprio — ver a subseção abaixo |
+| `parallel` | não | `true` roda o nó junto dos outros nós com `parallel: true`. Declare só em suítes que não dividem banco, porta nem pasta de build: o harness não tem como conferir. Ignorado em nó `e2e: true` e numa rodada que persegue suíte vermelha |
 | `expectedCount` | não | Baseline, só nos runners de contagem estável (`node-test`, `evals`); nos outros é ignorada e o `--record-baseline` a apaga. **Gravada só por `verify --record-baseline`**, nunca digitada. Ausente = `null` (sem baseline); `0` **declarado** é uma baseline real |
 | `timeoutMs` | não | Teto deste nó. Sem ele vale `project.testTimeoutMs` e, por fim, o default de 30 min × projetos encadeados |
 | `build` | não | Projetos a compilar antes (só `runner: "dotnet"`). Declarado em nó não-dotnet é erro de config, não campo silenciosamente ignorado |
@@ -691,8 +698,8 @@ testes reprova com `suíte verde sem nenhum teste executado` (suíte que parou d
 **Prebuild e `--no-build` (por que um `dotnet test` verde podia mentir).** Num nó `runner: "dotnet"`,
 os alvos de `build[]` — ou, na falta, os `.csproj` extraídos do próprio `command` — são compilados
 antes da execução, com `dotnet build "<alvo>" --nologo -v q`. Compilação que falha reprova o nó com
-`test-build-failed` e a suíte **não roda**. E um `command` com `--no-build` que **não** foi precedido de
-build nesta invocação reprova com `stale-binary`, também sem executar: o predicado é "houve build
+`test-build-failed` e a suíte **não roda**. E um `command` `dotnet` com `--no-build` que **não** foi precedido de
+build nesta invocação (prebuild do nó ou `dotnet build` verde do nó `build`) reprova com `stale-binary`, também sem executar: o predicado é "houve build
 aqui", nunca "a flag está ausente". Sem isso, um projeto de teste que deixou de compilar era executado
 a partir do binário do último build bom e reportava verde. `--no-build` continua legítimo — com
 `build[]` declarado ele roda normalmente, e o comando do usuário nunca é reescrito para isso. O prebuild é
@@ -721,10 +728,10 @@ nomeia o nó que impediu. **Apagar teste é legítimo:** a única cor vermelha q
 | CI | a suíte inteira, todos os nós (`morph-verify.yml` roda o mesmo `verify {f}`) | idem — e o artefato dele é o stamp do Gate 3 |
 | Evidência de eval (cenário `Cn` com `prova: eval`) | `verify {f} --filter {id-do-nó-evals} --skip-e2e --no-persist` | Só o nó `evals`, sem stack e sem carimbo — é a evidência de runtime do cenário, não a verificação da feature |
 
-> **Não existe constante de 600 s neste CLI** (`grep -rn "600000" src/ framework/` → zero). O teto que
-> corta uma suíte longa é o do **Bash do harness**, externo ao morph-spec, e não há o que "subir". Os
-> relógios que o CLI de fato tem: build **1 800 000 ms** (30 min), tests **1 800 000 ms por projeto de teste
-> encadeado**, health do e2e **180 000 ms**, specs Playwright **300 000 ms**, mais `timeoutMs` por nó,
+> **Nenhum relógio do `verify` é de 600 s.** Os 600 s que existem são a espera da fila
+> (`heavy.waitTimeoutSec`) e o teto do **Bash do harness**, externo ao morph-spec: é ele que corta uma
+> suíte longa, e não há o que "subir". Os relógios que o `verify` de fato tem: build **1 800 000 ms** (30 min), tests **1 800 000 ms por projeto de teste
+> encadeado**, `up --build` e health do e2e **180 000 ms**, specs Playwright **300 000 ms** (`e2e.specTimeoutMs`), mais `timeoutMs` por nó,
 > que substitui o default do `tests` quando ele não serve. `--timeout <ms>` cobre build **e** tests.
 > **A suíte inteira de um projeto grande não cabe numa invocação de Bash do harness:** rode
 > `verify {feature}` com `run_in_background` e
@@ -828,10 +835,6 @@ O servidor MCP (`graphify-mcp`, 10 tools, todas aceitando `project_path`) está
 
 ## Observabilidade
 
-### telemetry
-
-**`morph-spec telemetry [--json] [--feature <f>] [--limit <n>]`** — reconstrói o caminho de execução da sessão a partir de `.morph/logs/events.jsonl` (skills invocadas, sub-agents despachados + prompts, standards/base de conhecimento lidos, mix de tools, prompts do usuário). Capturado silenciosamente pelo hook `telemetry-log`. Lê também os arquivos rotacionados em `.morph/logs/sessions/`, sem contar duas vezes a mesma linha.
-
 ### cost
 
 **`morph-spec cost [feature] [--by phase] [--all-trees] [--json]`** — custo da execução a partir do mesmo `events.jsonl`: bytes de contexto lidos por tipo (`checklist`/`standard`/`skill`/`agents`/`plan-artifact`/`code` — a janela `offset`/`limit` que o Read trouxe, quando o evento a tem), dispatches + tamanho de prompt e mix de tools. Bytes são **proxy determinística** de custo de token; os tokens reais vêm à parte: `SessionUsage` (sessão principal) e `AgentUsage` (cada sub-agent, lido do transcript dele), somados **só pelo `delta`** de cada amostra — o total de topo é acumulado e se repete a cada Stop, e amostra antiga sem `delta` fica fora da soma e é contada como legada. `--all-trees` agrega **toda árvore git** com log, mais os logs que o `finish` guardou em `.git/morph-spec/finish-backup/` antes de desmontar a worktree, deduplicados por `eventId`.
@@ -866,6 +869,6 @@ Os eventos v1 (sem `schemaVersion`) nunca contam como zero: sem agente, exit cod
 | `ToolBatch` | `size`, `tools` (contagem por ferramenta) — um por turno do modelo |
 | `SessionUsage` / `AgentUsage` | totais acumulados do transcript + `delta` desde a amostra anterior |
 | `Gate` | `gate`, `step` (`decision`/`approve`/`unapprove`); na `decision`: `pause`, `signal` (a regra que pausou, `null` sem pausa, `manual` pelo `gate-decision`) e `source`; nas outras: `approvedBy`. Gravado por `persistGateDecision` e pelos dois escritores de aprovação (CLI e hook `state-sync`) |
-| `Verify` | `status`, `sha`, `fingerprint` (a árvore fora de `.morph/`), `tree` (`root`/`worktree`), `persisted`, `reason`, `source` (`local`/`ci`: a rodada do `--ci` registra os nós e durações do run), `nodes.{build,tests,validators,e2e}.{status,durationMs}`, `nodes.validators.{ran,skipped}` |
+| `Verify` | `status`, `sha`, `fingerprint` (a árvore fora de `.morph/`), `tree` (`root`/`worktree`), `persisted`, `reason`, `source` (`local`/`ci`: a rodada do `--ci` registra os nós e durações do run), `nodes.{build,tests,validators,e2e}.{status,durationMs}`, `nodes.tests.runs[].{id,status,durationMs}` (qual suíte custou o quê), `reused[]`, `flaky[]`, `nodes.validators.{ran,skipped}` |
 
 Nada da saída de um comando é gravado — nem o corpo de erro do `PostToolUseFailure`, onde um valor de `.env` pode aparecer sem nome ao lado. `command`, `prompt`, `desc` e `target` passam por redação de segredos óbvios antes de gravar: valor ao lado de um nome de segredo (`API_KEY=…`, `*_KEY`/`*_PASS=…`, `--password …`, `user-secrets set <k> <v>`, `AccountKey=…`), `Authorization: …`, `user:pass@` (senha com `/` inclusive) e `?sig=`/`?access_token=` em URL, e formatos de token (GitHub, `sk-`, `sk_live_`, `npm_`, Slack, AWS, Google, JWT). É por padrão, não por garantia: um valor sem nome ao lado passa.

package/framework/hooks/README.md

@@ -33,7 +33,7 @@ typechecks or runs tests: that is `morph-spec verify`.
 | **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) |
 | **PostToolUse** (Write\|Edit\|AskUserQuestion) | gate-guard.js | Advisory | Warns (never blocks) when a gate action disagrees with the persisted gateDecisions |
-| **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) | 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 cost` |
 | **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` |
@@ -41,7 +41,7 @@ typechecks or runs tests: that is `morph-spec verify`.
 | **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 |
 | **UserPromptSubmit** | telemetry-log.js | Telemetry | Appends the user's prompt to the same `events.jsonl` stream; silent, fail-open |
-| **Stop** | validate-completion.js | Advisory | Warns about incomplete slice reports (hash-deduped, only re-injects when the warning set changes) |
+| **Stop** | validate-completion.js | Advisory | Warns about scenarios marked `feito` without evidence in `3-implement/report.md` (hash-deduped, only re-injects when the warning set changes) |
 
 ## Design Principles
 

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

@@ -20,10 +20,6 @@ function auditReport(featurePath) {
     : [];
 }
 
-const COMPACT_TRIGGER_PHASES = new Set(['implement']);
-
-const HEAVY_SOURCE_PHASES = new Set(['plan', 'uiux']);
-
 export async function run(payload) {
   try {
     if (process.env.MORPH_STOP_HOOK_ACTIVE === '1') return null;
@@ -42,37 +38,6 @@ export async function run(payload) {
 
     const currentPhase = feature.phase || derivePhaseForFeature(name, cwd);
 
-    const watchPath = join(memDir, 'phase-watch.json');
-    let phaseWatch  = {};
-    try {
-      if (existsSync(watchPath)) phaseWatch = JSON.parse(readFileSync(watchPath, 'utf-8'));
-    } catch { /* corrupt file — start fresh */ }
-
-    const lastPhase = phaseWatch[name];
-
-    // Always stored, so the alert fires once per transition.
-    try {
-      phaseWatch[name] = currentPhase;
-      writeFileSync(watchPath, JSON.stringify(phaseWatch, null, 2), 'utf-8');
-    } catch {}
-
-    const isPhaseTransition = lastPhase && lastPhase !== currentPhase;
-    const enteringImplement = COMPACT_TRIGGER_PHASES.has(currentPhase);
-    const comingFromHeavyPhase = HEAVY_SOURCE_PHASES.has(lastPhase);
-
-    if (isPhaseTransition && enteringImplement && comingFromHeavyPhase) {
-      warnings.push(
-        `⚡ Phase advanced: ${lastPhase} → implement`,
-        ``,
-        `💡 Recommended before starting implementation:`,
-        `   Run /compact to free up context — plan.md and the design`,
-        `   loaded during planning take significant space. A compact now gives`,
-        `   Claude a clean slate focused on writing code.`,
-        ``,
-        `   After /compact, resume with: /morph-apply ${name}`,
-      );
-    }
-
     // 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);

package/framework/hooks/shared/e2e-check.js

@@ -187,23 +187,40 @@ export function decideIsolation({ findings = [], insideWorktree = false } = {})
 }
 
 // HEAD alone would let a stack built before an uncommitted edit read as fresh: status and diff
-// make any edit move the stamp. `null` outside a git repo.
+// make any edit move the stamp. `.morph/` stays out, config.json aside: the verify's own commits
+// must not rebuild a stack whose source did not change. `null` outside a git repo.
 export function computeSourceStamp(cwd, exec = defaultExec) {
   const head = exec('git', ['rev-parse', 'HEAD'], { cwd });
   if (head.code !== 0) return null;
 
-  const status = exec('git', ['status', '--porcelain'], { cwd });
-  const diff = exec('git', ['diff', 'HEAD'], { cwd });
+  const tree = exec('git', ['ls-tree', 'HEAD'], { cwd });
+  const status = exec('git', ['status', '--porcelain', ...OUTSIDE_MORPH], { cwd });
+  const diff = exec('git', ['diff', 'HEAD', ...OUTSIDE_MORPH], { cwd });
+  const entries = tree.code === 0
+    ? tree.output.split('\n').filter((line) => line.split('\t')[1] !== '.morph').join('\n')
+    : head.output.trim();
 
   return createHash('sha1')
-    .update(head.output.trim())
+    .update(entries)
     .update('\0')
     .update(status.code === 0 ? status.output : '')
     .update('\0')
     .update(diff.code === 0 ? diff.output : '')
+    .update('\0')
+    .update(readConfigText(cwd))
     .digest('hex');
 }
 
+const OUTSIDE_MORPH = ['--', '.', ':(exclude).morph'];
+
+function readConfigText(cwd) {
+  try {
+    return readFileSync(join(cwd, '.morph', 'config', 'config.json'), 'utf8');
+  } catch {
+    return '';
+  }
+}
+
 export function stampPath(gitCommonDir, projectName) {
   return join(gitCommonDir, 'morph-spec', `e2e-stamp-${projectName}.json`);
 }
@@ -775,6 +792,11 @@ export function bringUpE2e(
   return result({ status: 'pass', stage: null, reason: stack.reason, hostServices: host, auth });
 }
 
+function specTimeoutFor(config) {
+  const configured = config?.e2e?.specTimeoutMs;
+  return Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_SPEC_TIMEOUT;
+}
+
 /** @returns {{ status: 'pass'|'fail'|'skip', command: string|null, output: string, reason: string|null, warnings: string[] }} */
 export function runE2eCheck(cwd, options = {}) {
   const {
@@ -787,7 +809,7 @@ export function runE2eCheck(cwd, options = {}) {
     forceFresh = false,
     insideWorktree = isSecondaryWorktree(cwd),
     healthTimeout = DEFAULT_HEALTH_TIMEOUT,
-    specTimeout = DEFAULT_SPEC_TIMEOUT,
+    specTimeout = specTimeoutFor(config),
     beforeHeavy = null,
     countSpecs = null,
     _exec: exec = defaultExec,
@@ -858,6 +880,12 @@ export function runE2eCheck(cwd, options = {}) {
   }
 }
 
+// Playwright's list reporter names a failure as `  1) [chromium] › e2e/a.spec.ts:3:5 › title`.
+function failedSpecNames(output) {
+  const names = [...String(output).matchAll(/^\s+\d+\)\s+(.+›.+)$/gm)].map((match) => match[1].trim());
+  return [...new Set(names)];
+}
+
 // The suite gets the stack's env (with PLAYWRIGHT_BASE_URL): without it the config hits a hardcoded
 // localhost:3000 while the app sits on the feature's port, an ECONNREFUSED that looks like a broken app.
 function runSpecs(cwd, { config, composeFile, up, auth, specTimeout, composeEnv, countSpecs }, exec) {
@@ -885,18 +913,27 @@ function runSpecs(cwd, { config, composeFile, up, auth, specTimeout, composeEnv,
   // Counted from the FULL output, before the tail cut; unparseable is null, never 0.
   const count = typeof countSpecs === 'function' ? (countSpecs(run.output) ?? null) : null;
 
-  if (run.code !== 0) {
+  // One rerun of the failed specs only: a flake must not cost a whole verify. `--last-failed`
+  // needs Playwright 1.44+; an older one exits non-zero, and the node stays red.
+  const retry = run.code !== 0 && spec.args.includes('playwright')
+    ? exec(spec.command, [...spec.args, '--last-failed'], { cwd: spec.cwd, timeout: specTimeout, env: composeEnv })
+    : null;
+
+  if (run.code !== 0 && retry?.code !== 0) {
     return {
       status: 'fail',
       command: commandLine,
-      output: tailLines(run.output, OUTPUT_TAIL_LINES),
+      output: tailLines(retry?.output ?? run.output, OUTPUT_TAIL_LINES),
       reason: 'e2e specs failed against the running stack',
       count,
     };
   }
 
+  const flakySpecs = retry ? failedSpecNames(run.output) : [];
+
   return {
     status: 'pass',
+    flakySpecs,
     command: commandLine,
     output: '',
     reason: notes.length ? notes.join('; ') : null,

package/framework/hooks/shared/heavy-command.js

@@ -57,6 +57,14 @@ function firstArg(args, valueFlags = new Set()) {
   return undefined;
 }
 
+const POWERSHELL_HOSTS = new Set(['powershell', 'pwsh']);
+const TEST_SCRIPT_SUFFIX = 'test-script';
+
+function runsTestScript(args) {
+  const script = args.find((a) => /\.ps1$/i.test(a));
+  return Boolean(script) && /test/i.test(script.replace(/^.*[\\/]/, ''));
+}
+
 function kindOfTokens(tokens) {
   const [head, ...args] = tokens;
   if (!head || args.some((a) => INFO_FLAGS.has(a))) return null;
@@ -64,6 +72,7 @@ function kindOfTokens(tokens) {
   const sub = firstArg(args, exe === 'docker' || exe === 'docker-compose' ? DOCKER_VALUE_FLAGS
     : PACKAGE_MANAGERS.has(exe) ? PM_DIR_FLAGS : undefined);
 
+  if (POWERSHELL_HOSTS.has(exe)) return runsTestScript(args) ? `${exe} ${TEST_SCRIPT_SUFFIX}` : null;
   if (exe === 'dotnet') return DOTNET_HEAVY.has(sub) ? `dotnet ${sub}` : null;
   if (exe === 'msbuild') return 'msbuild';
   if (exe === 'vitest' || exe === 'jest') return exe;
@@ -115,7 +124,7 @@ export const REVIEW_AGENT_TYPES = new Set(['morph-verifier', 'morph-reviewer', '
 export const QUEUE_FULL_EXIT = 3;
 
 const LIST_FLAGS = new Set(['--list', '--listTests', '--list-tests']);
-const TEST_LABEL = /^(dotnet (test|vstest)|(npx )?(vitest|jest|playwright test)|(npm|pnpm|yarn|bun) (test|run test(:\S+)?))$/;
+const TEST_LABEL = /^(dotnet (test|vstest)|(npx )?(vitest|jest|playwright test)|(npm|pnpm|yarn|bun) (test|run test(:\S+)?)|(powershell|pwsh) test-script)$/;
 const NODE_RUNNERS = new Set(['vitest', 'jest']);
 
 function morphArgs(tokens) {
@@ -158,6 +167,8 @@ const TEST_PATH = /[\\/]|\.(spec|test)\b|\.[cm]?[jt]sx?$/;
 const PATH_VALUE_FLAGS = new Set(['-c', '--config', '--project', '--root', '--workspace', '--outputFile', '--reporter', ...PM_DIR_FLAGS]);
 
 function isFilteredRun(kind, tokens) {
+  // A script's arguments are its own contract: no flag here proves it narrowed the run.
+  if (kind.endsWith(TEST_SCRIPT_SUFFIX)) return false;
   const runnerAt = executable(tokens[0]) === 'node'
     ? tokens.findIndex((t, i) => i > 0 && executable(t).replace(/\.[cm]?js$/, '') === kind)
     : 0;

package/framework/hooks/shared/next-step.js

@@ -33,7 +33,7 @@ const HOW = {
     `\`morph-spec verify ${f} --json\` sem filtro; passou de 10 min, run_in_background.`,
   ],
   fix: (f) => [
-    `Leia o \`feedback\` do último verify, corrija a causa e rode \`morph-spec verify ${f} --json\` de novo, sem filtro.`,
+    `Leia o \`feedback\` do último verify, corrija a causa e rode \`morph-spec verify ${f} --json\` de novo, sem filtro: ele começa pelas suítes vermelhas e só segue se passarem.`,
   ],
   escalate: () => [
     'AskUserQuestion com o texto do reason (aceitar/continuar/parar) e siga a resposta; não rode outro verify antes dela.',
@@ -42,7 +42,7 @@ const HOW = {
     'Siga .claude/skills/morph-apply/references/review.md.',
   ],
   finish: (f) => [
-    `AskUserQuestion header "Integração" (PR ou merge); depois \`morph-spec finish ${f} --pr\` ou \`--merge\`.`,
+    `\`morph-spec context refresh\`, commit, e \`morph-spec finish ${f} --pr\` (\`--merge\` com \`finish.mode: "merge"\` no config), sem perguntar.`,
   ],
   status: (f) => [
     `Rode \`morph-spec status ${f}\` e confira a fase em .morph/features/${f}/feature.json.`,