@polymorphism-tech/morph-spec 8.45.0 → 8.46.0

package/CLAUDE.md

@@ -156,6 +156,7 @@ When modifying framework components, verify the full scope of related files.
 | `src/lib/mutation/**` (`morph-spec mutate`, a mutação dirigida do Gate 3) | `src/commands/validation/mutate.js` (fina), `bin/morph-spec.js`, o bullet `mutate` de `framework/docs/CLI.md`, a seção "Prova por mutação" de `framework/evals/review-checklist.md` e o prompt do avaliador em `morph-review` §4, com os canários `test/lib/mutation/*` e `test/commands/mutate.test.js`. O mundo falso `test/helpers/mutation-world.js` reproduz o build INCREMENTAL do MSBuild (sem essa propriedade o teste da armadilha do mtime não morde). Invariantes: **no máximo 3 mutantes, cada um com `expect`** (`manifest.js` recusa com exit 2 — mutante cujo efeito o avaliador não prevê tende a ser equivalente); **com subconjunto utilizável, ele decide** (sobrevivente fica `survived` com escopo `subset`, sem escalar à suíte inteira — o subconjunto é escolhido pela ferramenta, nunca pelo avaliador); sem subconjunto, a suíte inteira roda e a morte tem de se repetir; restaurar é **escrita nova**, nunca `os.utime`; `killed` exige falha NOVA contra a rodada-base do MESMO escopo, e `inconclusive`/`build-error` nunca contam como morte; `proveBinary` compara a DLL final com a construída da árvore limpa. `dotnetBuildCommandFor` é a única grafia de "dotnet build" e `csharpClasses` a única leitura de classe de teste; o filtro do subconjunto é composto por `withFilter` (`narrowNode` recusa comando que já declara `--filter`). Dois parsers de TRX, ou um segundo "dotnet build" digitado, divergem |
 | `--record-baseline` (`recordTestBaselines` em `src/lib/tasks/test-nodes.js`) | `verify-runner.js` (`baselineTargetProblem` recusa ANTES do build; `recordBaselineFrom` só grava com todos os `runs[]` verdes), `src/commands/validation/verify.js` (`baselineStampBlock`: só a rodada que GRAVOU a baseline persiste o stamp — sem gravação, o `reason` nomeia o nó), `framework/schemas/config.schema.json` (`expectedCount`) e `atomicWriteJson` de `state-manager.js` — o número é MEDIDO por comando, nunca digitado (D8). Com `{task}` é erro de uso ANTES do build (`baselineTargetProblem`, #87), e `recordTestBaselines` recusa de novo qualquer medição com `selection` — a segunda barreira mora no gravador |
 | `src/lib/tasks/eval-node.js` | os leitores do MESMO nó `runner: "evals"`: `test-nodes.js` (o enum de `TEST_RUNNERS` e a validação fail-closed do bloco `evals`), `verify-runner.js` (`preDecideRun` faz o pré-voo — os três estados de cache reprovam ANTES de `dotnet test`; `judgeEvalRun` lê o sumário depois), `verify.js` (`evalsStatusOf` deriva `nodes.evals` do stamp) e `framework/schemas/config.schema.json`. O pin se resolve em UM lugar, `resolveAiPin` (`src/lib/ai/pin-drift.js`, o mesmo do `doctor --ai`): `.morph/framework/ai-pin.json` do projeto e, sem ele, o do pacote da CLI. O `update` nunca copia o pin, então o fallback é o caso comum — um leitor próprio do eval deixou `MORPH_EVAL_PIN` sem ser injetado em todo projeto instalado, e com ele a régua do carimbo desligada sem aviso. Subir o pin do pacote reprova (`eval-cache-stale-pin`) toda cache carimbada no anterior: é o efeito, não um defeito. **`null` é DESCONHECIDO, nunca 0**: sumário ilegível não pode fabricar queda contra `expectedCount`, e miss de cache é `fail` nomeado, JAMAIS `skip`. A unidade do nó é o CENÁRIO: só `judgeEvalRun` compara com `expectedCount` — `judgeRun` passa baseline `null` para `runner: "evals"` (#110 parte 2: os `[Fact]` do extrator contra a baseline de cenários reprovavam um 24/24), e sem sumário legível a contagem é `null`, nunca a do extrator — nem compara nem vira baseline. O sumário (`morph-eval-{id}-{pid}.json` no temp) é APAGADO antes e depois da rodada: um arquivo herdado sob o mesmo pid era lido como desta. `--linux` com nó de eval é erro de uso: o canal `MORPH_EVAL_*` carrega caminhos absolutos do host e o container roda uma cópia em `/work` |
+| `src/lib/ci/**` (`verify {f} --ci`, a prova do Gate 3 no CI) | O CI é **outra fonte do MESMO stamp**, nunca uma regra de gate: `verify.js` grava o `verify --json` que o run publicou (artefato `morph-verify`, `CI_RESULT_FILE`) pelo mesmo caminho do local, com `source: 'ci'`, `ciRun` e `sha` = `headSha` do run — `gate-check`/`risk-detector`/`approve` não mudam. Só o ARTEFATO vira prova, nunca a `conclusion` do run (workflow de lint verde não compra o Gate 3), e `findCiWorkflow` só aceita workflow que chama `morph-spec verify` E publica `morph-verify.json` — o `renderCiWorkflow` (`workflow-scaffold.js`) tem de continuar passando nele (canário em `test/lib/ci/workflow-scaffold.test.js`). O run vale por ÁRVORE, não por SHA (`treeMovedSince`): commit só de `.morph/` não invalida, e o gatilho do workflow exclui `.morph/**` menos o `config.json` pela mesma razão (senão `cancel-in-progress` cancela o run do código). `cancelled`/`skipped`/`startup_failure` não são prova. Todo "não dá" é `mode: 'local'` com razão (fallback, nunca pausa); código fora de commit é exit 2; run pendente no prazo é exit 3 sem stamp. A URL do origin é lida CRUA (`remote.origin.url`): `git remote get-url` aplica `insteadOf`, que é como os testes apontam o push para um bare local. Canários: `test/commands/verify-ci.test.js` (stub `test/helpers/gh-ci-stub.js`), `test/lib/ci/*` |
 | `nodeStatuses()` em `src/commands/validation/verify.js` | os TRÊS blocos `nodes` de `framework/schemas/feature.schema.json`, todos `additionalProperties: false` — `verification.nodes`, `verifications.feature.nodes` e `taskVerifications.*.nodes`. A função é escritora ÚNICA dos três: um campo novo aqui sem os três no schema faz o histórico violar o próprio contrato. Canário: "os DOIS escritores do mapa de nós concordam" em `test/commands/verify.test.js` |
 | `src/lib/graph/**`               | `test/lib/graph/*.test.js`, the committed fixture `test/fixtures/graph/namespace-hierarchy.graph.json` (ADR-003 regression — never hand-edit it), `doctor.js` (`codebase graph` check), `architecture-scanner.js` (centrality section), `setup-infra.js` step 18b. `isTestPath` (`sanitize.js`) é o predicado ÚNICO de teste: `god-nodes.js`, `recoverDispatch`, `graph status\|explain` e `symbol-scanner.js` (`isTestFile`, que o `code-budget` também lê) o importam, e uma segunda régua faz o grafo e o validador discordarem sobre o mesmo arquivo. A fixture `test-doubles.graph.json` saiu do graphify real (passo a passo em `docs/specs/graphify-integration/fixture-test-doubles/`) — regerar, nunca editar à mão |
 | `framework/hooks/shared/graph-freshness.js` (a regra única de "grafo em dia") | os três lados que perguntam: `graph-refresh.js` (decide se roda e se o disparo solta processo), `graph-loader.js` `getFreshness` (`graph status\|explain\|affected` e o `doctor`) e `graph build\|refresh` (gravam a rodada em `<git-common-dir>/morph-spec/graph-refresh-state.json`). O registro da rodada existe porque o `graphify update` 0.9.50 não recarimba `built_at_commit` quando a topologia não muda: sem ele, o grafo parecia velho para sempre e cada disparo rodava o graphify de novo (~80 s no MORPH_GHLBrain). As regras do `.graphifyignore` entram por CONTEÚDO (hash sem comentário, BOM e CRLF), nunca pelo relógio, e `ignoreTextOf` é a ÚNICA leitura de "as regras desta árvore": numa worktree sem arquivo próprio, as da raiz — as mesmas que o `graph refresh` põe ali durante a rodada (`prepareIgnore` em `build.js`). O arquivo temporário leva `TEMP_IGNORE_MARKER` na 1ª linha; nas duas triagens de sujeira (`finish` e `worktree remove`) `withoutLeftoverIgnore` o tira da conta ANTES das recusas e `dropLeftoverIgnore` o apaga só DEPOIS delas — apagar antes é mutação atrás de uma precondição. Mudar a grafia do marcador num lado só devolve o `worktree-dirty` de uma rodada morta no meio. Mora em `hooks/shared` porque hook não importa `src/` |

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:** 8.45.0  
+**Version:** 8.46.0  
 **Requires:** Node.js 22+, Claude Code
 
 ---
@@ -379,4 +379,4 @@ Code generated by morph-spec (contracts, templates, implementation output) belon
 
 ---
 
-*morph-spec v8.45.0 by [Polymorphism Tech](https://polymorphism.tech)*
+*morph-spec v8.46.0 by [Polymorphism Tech](https://polymorphism.tech)*

package/bin/morph-spec.js

@@ -406,6 +406,7 @@ program
   .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('--no-persist', 'Do not persist the result to feature.json')
+  .option('--ci', 'Feature scope only: 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, task, options) =>
     verifyCommand(feature, task, { ...options, noPersist: options.persist === false })
   );

package/claude-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "morph-spec",
-  "version": "8.45.0",
+  "version": "8.46.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

@@ -185,4 +185,4 @@ Never edited directly — go through CLI commands or `morph-spec update` instead
 
 ---
 
-*morph-spec v8.45.0 by Polymorphism Tech*
+*morph-spec v8.46.0 by Polymorphism Tech*

package/docs/QUICKSTART.md

@@ -249,4 +249,4 @@ morph-spec doctor
 
 ---
 
-*morph-spec v8.45.0 by Polymorphism Tech*
+*morph-spec v8.46.0 by Polymorphism Tech*

package/framework/CLAUDE.md

@@ -68,7 +68,7 @@ Se não houver feature ativa, pergunte ao usuário qual feature trabalhar.
 | `dag <f>` | DAG de `tasks.json`: sequencial/paralelo, recomenda isolamento |
 | `graph status\|build\|refresh` | Grafo de codebase. `status` reporta frescor e se há refresh em background |
 | `graph affected\|explain <sym>` | Blast radius e vizinhança saneados. Sem grafo, caia para grep — nunca é erro |
-| `verify <f> [task] [--json]` | Build+testes+validadores+e2e — a prova determinística da task e do Gate 3 |
+| `verify <f> [task] [--ci]` | Build+testes+validadores+e2e — prova da task; a do Gate 3 com `--ci` (no CI) |
 | `e2e up\|status\|down <f>` | Stack de verificação (docker compose) |
 | `doctor --worktrees [--prune]` | Reconcilia git × disco × features; só `--prune` remove algo |
 | `report-check <f> [task...] [--json]` | Audita relatório de sub-agent vs. trabalho entregue |

package/framework/MORPH.md

@@ -26,7 +26,7 @@ Entre gates, você opera com autonomia total. O dev valida. Você executa.
 
 **Regra de ouro:** dúvida que não bloqueia → resolver e registrar; dúvida que bloqueia → uma pergunta, máximo. Vale **entre gates** (plan/implement/review) — **não** vale na abertura da feature: a fase proposal pode rodar em **modo entrevista** (escolhido na pergunta de abertura, `morph-brainstorming` Parte 2), onde perguntar até fechar o entendimento é o comportamento desejado.
 
-**A prova é o código:** `morph-spec verify` (build+testes+validadores) prova o que é determinístico; o `doneCriteria` prova o comportamento. Não há nota por task — estilo e estrutura são nota do avaliador do Gate 3, nunca bloqueio.
+**A prova é o código:** `morph-spec verify` (build+testes+validadores) prova o que é determinístico; o `doneCriteria` prova o comportamento. A suíte do Gate 3 roda no CI do projeto (`verify {f} --ci`: mesmo stamp, a máquina fica livre; sem CI, local). Não há nota por task — estilo e estrutura são nota do avaliador do Gate 3, nunca bloqueio.
 
 ---
 

package/framework/docs/CLI.md

@@ -44,7 +44,8 @@
 ## Validação
 
 - **`morph-spec dag <feature>`** — análise do DAG de tasks.json com decisão sequencial vs paralelo **ponderada por effort** (raízes S vão inline, nunca ganham agente próprio). Também cruza `tasks.json` com os use cases: `usecase` apontando para um `UC-{nn}` inexistente é **erro** (exit 1, não despacha); pós-condição órfã e `doneCriteria` que parafraseou em vez de copiar são avisos. UC com nome fora do padrão `UC-{nn}-{slug}.md` (slug com maiúscula ou `_`) continua encontrado, com aviso: o `finish` não o promove ao acervo. `doneCriteria` com vocabulário de artefato (`grep`, "contém a string", "nenhum arquivo", glob `**/`…) sem `Por que artefato:` também é aviso, sob `⚠ Critérios de artefato` — o exit não muda, e o `--json` traz a chave irmã `artifactCriteria`. Os achados de ciclo de vida do `usecase check` (task sobre UC `superseded`, revogação que o `finish` não aplicaria) saem sob `⚠ Ciclo de vida do acervo`, também só aviso, na chave `lifecycle`. **Tamanho de task:** task com mais de 8 `outputs` (`MAX_TASK_OUTPUTS`) é **erro** (exit 1) enquanto o Gate 2 não foi aprovado — fatie por pós-condição — e só aviso depois dele (chore/hotfix nascem com o plano aprovado por política); o `--json` traz `taskSize: {max, oversized, blocking}`. `--mermaid` nunca é bloqueado.
-- **`morph-spec verify <feature> [task] [--json] [--timeout <ms>] [--filter <ids>] [--full] [--record-baseline] [--refresh-cache] [--linux] [--linux-image <img>] [--skip-tests] [--skip-build] [--skip-e2e] [--fresh-e2e] [--no-persist]`** — cadeia determinística build+testes+validadores+**e2e** (código antes do juiz LLM); escopo de task quando informado, senão a feature inteira. O nó `e2e` é o único que **executa** a aplicação: sobe o `docker compose` do projeto, espera todo serviço ficar saudável 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). Aplicabilidade: escopo de feature (Gate 3) **sempre** roda; escopo de task roda para `group` `frontend`/`backend`/`infra` e dispensa `tests`/`docs`. **Dispensa legítima × setup faltando:** projeto sem compose e sem a integração `docker` é `skip` com razão; projeto que **declara** `docker` e não tem compose é `fail` — é verificação que nunca foi montada, não projeto que não containeriza. **Descoberta de testes e relógio:** a varredura por `*Tests.csproj` **não enxerga worktrees** — nem os convencionais (`worktrees/`, `.worktrees/`) nem os registrados em `git worktree list` fora da convenção. 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"). O timeout do nó `tests` deixou de ser fixo: `--timeout` (que agora cobre build **e** tests) > `project.testTimeoutMs` no `config.json` > **120 s por projeto de teste encadeado** — um encadeamento nunca nasce condenado pelo tamanho. Quando o relógio estoura, o nó diz isso com nome (`timeout após N ms na execução X de Y — nenhum teste falhou`) em vez de devolver log truncado. **`--fresh-e2e` é destrutivo por definição:** derruba a stack anterior **com os volumes nomeados** (`down -v`), apaga o carimbo de frescor, sobe com `--build` e força o seed de auth a rodar de novo. 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). **No escopo de task o recorte é automático:** `verify {f} {task}` deixa o `group` da task escolher os nós e os arquivos de teste de `outputs` estreitarem o comando dentro de cada nó — o relógio de uma task não paga a suíte inteira (regras, veredito e limites em *O recorte por task*, na seção **Suítes de teste**). **`--filter <ids>` força a escolha de nós** (lista separada por vírgula, casando `id` exato ou substring; desliga a escolha pelo `group`, e o estreitamento dentro dos nós continua) e **`--full` desliga o recorte** (o `group` não escolhe nós e nenhum comando é estreitado; os nós com `e2e: true` e os de `runner: "evals"` continuam só no escopo de feature; no escopo de feature `--full` é no-op, porque ali nada é recortado). O Gate 3 continua sendo `verify {f} --json` **sem filtro**, porque a prova que o avaliador lê tem de cobrir todos os nós (o CI idem) — e um `verify {f} --filter …` de escopo de **feature** não persiste o stamp (`persisted: false`, `reason: 'filtered'`), nem um de escopo de feature com `--skip-tests` (`reason: 'skip-tests'`) ou `--skip-build` (`reason: 'skip-build'`): um nó pulado não reprova o rollup, e rodada parcial nunca fica no lugar da prova do Gate 3. No escopo de task as três gravam normalmente — o stamp já diz `task:{id}`, e o Gate 3 pausa nele. O nó não casado **aparece** em `runs[]` como `skip` nomeando o filtro, em vez de sumir — suíte que some do relatório é verde sobre código não testado. E `--filter` que não casa nenhum nó é **erro de uso (exit 2)**, checado antes do build: filtrar tudo e reportar verde seria a forma mais barata de recriar o defeito que a lista de nós existe para matar. **`--record-baseline` é a ÚNICA via de escrita da baseline:** mede cada nó numa execução real e grava `project.tests[].expectedCount` de volta no `config.json` (escrita atômica `tmp.{pid}`+rename, preservando todo o resto do arquivo). 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. Recusa alto e claro em vez de improvisar: execução **vermelha** não grava (congelaria a regressão), execução **parcial** não grava (com `--filter` alguns nós ficam sem medida, e baseline de meia frota é afirmação sobre a outra metade que ninguém fez), contagem **desconhecida** não grava (`null` nunca vira `0`), e **sem `config.json` é erro de uso (exit 2)** — o arquivo nunca é criado implicitamente. **Com `{task}` também é erro de uso (exit 2)**, recusado antes do build: no escopo de task o verify recorta nós e testes, e baseline de recorte não é baseline — o gravador ainda recusa, uma segunda vez, qualquer medição que carregue `selection`. A execução que gravou a baseline persiste o stamp; a que não gravou nada, não. **`--linux` roda as suítes dentro de um container Linux** (`mcr.microsoft.com/dotnet/sdk:10.0` por default; sobrescrevível por `--linux-image` ou por `project.tests[].linuxImage`), e a árvore sob teste é **copiada** para o filesystem do container, não montada: o bind mount do Docker Desktop no Windows atravessa 9p/gRPC-FUSE, que é **case-insensitive** — rodar em cima do mount devolveria o mesmo verde do Windows e não provaria nada sobre defeitos de caixa (`Link=`, `Uri.TryCreate`), que são exatamente os que só aparecem no Linux. A raiz é montada **read-only** em `/src` só como origem do `tar` (com exclusão de `node_modules`, `bin`, `obj`, `.git` e os diretórios-contêiner de worktree), a cópia vive em `/work`, e cada nó roda de `/work/{cwd}`. Sem Docker, **erro de uso (exit 2)**, jamais um `skip`: "não deu para checar no Linux" lido como verde é o próprio defeito. `--linux` com `--skip-tests` se anulam (erro de uso), e um nó `e2e: true` é pulado no container com motivo (docker-em-docker fora de escopo). O resultado marca `nodes.tests.environment = { kind: 'linux-container', image }` — sem isso, um verde de container e um verde de host viram indistinguíveis no `feature.json` e a próxima pessoa não sabe o que foi provado. **`--no-persist` não grava nada no `feature.json`** — nem o histórico `verifications.*` nem o stamp `verification` que o gate lê: a execução vira sonda, nunca prova para gate algum, qualquer que seja a regra de carimbo do escopo. E o `--filter` só estreita o nó de testes (build, validadores e e2e rodam igual). Por isso a execução de evidência de eval do `morph-implement` §5 é `verify {f} --filter {id-do-nó-evals} --skip-e2e --no-persist`: só o eval, sem stack, sem escrever no `feature.json`. **Onde grava:** só na árvore DONA da feature (`resolveFeatureTree`, a regra do guard dos mutadores, perguntada da raiz) — o worktree com `morph/{f}` checada, mesmo sem ponteiro `worktree.path` na raiz, ou a raiz quando nenhum worktree vivo a possui. Fora dela, `persisted: false` com `reason: 'unregistered-worktree'` (outro worktree, como o `morph-task/{n}` de um sub-agent) ou `'owner-tree-elsewhere'` (a raiz, com o dono vivo em outro lugar). **Rodada repetida:** no escopo de feature, se nada mudou fora de `.morph/` desde o verify de feature anterior (HEAD, diff, arquivos não rastreados e o `config.json`), o `--json` traz `repeatOf: { ts, status, sha }` e a saída humana avisa — é aviso, a rodada executa e carimba igual, porque só o código sabe que a árvore não mudou, não que o ambiente (Docker, banco) também não. Forma de `project.tests[]`, prefixo `[tests/{id}]` do `feedback[]`, regra de contagem/baseline e a divisão loop × suíte: seção **Suítes de teste** abaixo. **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.
+- **`morph-spec verify <feature> [task] [--json] [--timeout <ms>] [--filter <ids>] [--full] [--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); escopo de task quando informado, senão a feature inteira. O nó `e2e` é o único que **executa** a aplicação: sobe o `docker compose` do projeto, espera todo serviço ficar saudável 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). Aplicabilidade: escopo de feature (Gate 3) **sempre** roda; escopo de task roda para `group` `frontend`/`backend`/`infra` e dispensa `tests`/`docs`. **Dispensa legítima × setup faltando:** projeto sem compose e sem a integração `docker` é `skip` com razão; projeto que **declara** `docker` e não tem compose é `fail` — é verificação que nunca foi montada, não projeto que não containeriza. **Descoberta de testes e relógio:** a varredura por `*Tests.csproj` **não enxerga worktrees** — nem os convencionais (`worktrees/`, `.worktrees/`) nem os registrados em `git worktree list` fora da convenção. 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"). O timeout do nó `tests` deixou de ser fixo: `--timeout` (que agora cobre build **e** tests) > `project.testTimeoutMs` no `config.json` > **120 s por projeto de teste encadeado** — um encadeamento nunca nasce condenado pelo tamanho. Quando o relógio estoura, o nó diz isso com nome (`timeout após N ms na execução X de Y — nenhum teste falhou`) em vez de devolver log truncado. **`--fresh-e2e` é destrutivo por definição:** derruba a stack anterior **com os volumes nomeados** (`down -v`), apaga o carimbo de frescor, sobe com `--build` e força o seed de auth a rodar de novo. 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). **No escopo de task o recorte é automático:** `verify {f} {task}` deixa o `group` da task escolher os nós e os arquivos de teste de `outputs` estreitarem o comando dentro de cada nó — o relógio de uma task não paga a suíte inteira (regras, veredito e limites em *O recorte por task*, na seção **Suítes de teste**). **`--filter <ids>` força a escolha de nós** (lista separada por vírgula, casando `id` exato ou substring; desliga a escolha pelo `group`, e o estreitamento dentro dos nós continua) e **`--full` desliga o recorte** (o `group` não escolhe nós e nenhum comando é estreitado; os nós com `e2e: true` e os de `runner: "evals"` continuam só no escopo de feature; no escopo de feature `--full` é no-op, porque ali nada é recortado). O Gate 3 continua sendo `verify {f} --json` **sem filtro**, porque a prova que o avaliador lê tem de cobrir todos os nós (o CI idem) — e um `verify {f} --filter …` de escopo de **feature** não persiste o stamp (`persisted: false`, `reason: 'filtered'`), nem um de escopo de feature com `--skip-tests` (`reason: 'skip-tests'`) ou `--skip-build` (`reason: 'skip-build'`): um nó pulado não reprova o rollup, e rodada parcial nunca fica no lugar da prova do Gate 3. No escopo de task as três gravam normalmente — o stamp já diz `task:{id}`, e o Gate 3 pausa nele. O nó não casado **aparece** em `runs[]` como `skip` nomeando o filtro, em vez de sumir — suíte que some do relatório é verde sobre código não testado. E `--filter` que não casa nenhum nó é **erro de uso (exit 2)**, checado antes do build: filtrar tudo e reportar verde seria a forma mais barata de recriar o defeito que a lista de nós existe para matar. **`--record-baseline` é a ÚNICA via de escrita da baseline:** mede cada nó numa execução real e grava `project.tests[].expectedCount` de volta no `config.json` (escrita atômica `tmp.{pid}`+rename, preservando todo o resto do arquivo). 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. Recusa alto e claro em vez de improvisar: execução **vermelha** não grava (congelaria a regressão), execução **parcial** não grava (com `--filter` alguns nós ficam sem medida, e baseline de meia frota é afirmação sobre a outra metade que ninguém fez), contagem **desconhecida** não grava (`null` nunca vira `0`), e **sem `config.json` é erro de uso (exit 2)** — o arquivo nunca é criado implicitamente. **Com `{task}` também é erro de uso (exit 2)**, recusado antes do build: no escopo de task o verify recorta nós e testes, e baseline de recorte não é baseline — o gravador ainda recusa, uma segunda vez, qualquer medição que carregue `selection`. A execução que gravou a baseline persiste o stamp; a que não gravou nada, não. **`--linux` roda as suítes dentro de um container Linux** (`mcr.microsoft.com/dotnet/sdk:10.0` por default; sobrescrevível por `--linux-image` ou por `project.tests[].linuxImage`), e a árvore sob teste é **copiada** para o filesystem do container, não montada: o bind mount do Docker Desktop no Windows atravessa 9p/gRPC-FUSE, que é **case-insensitive** — rodar em cima do mount devolveria o mesmo verde do Windows e não provaria nada sobre defeitos de caixa (`Link=`, `Uri.TryCreate`), que são exatamente os que só aparecem no Linux. A raiz é montada **read-only** em `/src` só como origem do `tar` (com exclusão de `node_modules`, `bin`, `obj`, `.git` e os diretórios-contêiner de worktree), a cópia vive em `/work`, e cada nó roda de `/work/{cwd}`. Sem Docker, **erro de uso (exit 2)**, jamais um `skip`: "não deu para checar no Linux" lido como verde é o próprio defeito. `--linux` com `--skip-tests` se anulam (erro de uso), e um nó `e2e: true` é pulado no container com motivo (docker-em-docker fora de escopo). O resultado marca `nodes.tests.environment = { kind: 'linux-container', image }` — sem isso, um verde de container e um verde de host viram indistinguíveis no `feature.json` e a próxima pessoa não sabe o que foi provado. **`--no-persist` não grava nada no `feature.json`** — nem o histórico `verifications.*` nem o stamp `verification` que o gate lê: a execução vira sonda, nunca prova para gate algum, qualquer que seja a regra de carimbo do escopo. E o `--filter` só estreita o nó de testes (build, validadores e e2e rodam igual). Por isso a execução de evidência de eval do `morph-implement` §5 é `verify {f} --filter {id-do-nó-evals} --skip-e2e --no-persist`: só o eval, sem stack, sem escrever no `feature.json`. **Onde grava:** só na árvore DONA da feature (`resolveFeatureTree`, a regra do guard dos mutadores, perguntada da raiz) — o worktree com `morph/{f}` checada, mesmo sem ponteiro `worktree.path` na raiz, ou a raiz quando nenhum worktree vivo a possui. Fora dela, `persisted: false` com `reason: 'unregistered-worktree'` (outro worktree, como o `morph-task/{n}` de um sub-agent) ou `'owner-tree-elsewhere'` (a raiz, com o dono vivo em outro lugar). **Rodada repetida:** no escopo de feature, se nada mudou fora de `.morph/` desde o verify de feature anterior (HEAD, diff, arquivos não rastreados e o `config.json`), o `--json` traz `repeatOf: { ts, status, sha }` e a saída humana avisa — é aviso, a rodada executa e carimba igual, porque só o código sabe que a árvore não mudou, não que o ambiente (Docker, banco) também não. Forma de `project.tests[]`, prefixo `[tests/{id}]` do `feedback[]`, regra de contagem/baseline e a divisão loop × suíte: seção **Suítes de teste** abaixo. **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.
+- **`morph-spec verify <feature> --ci [--json]`** — a prova de escopo de feature tirada do **CI do projeto** (GitHub Actions), não da máquina: faz `git push -u origin morph/<feature>`, espera o run do commit e transforma o `verify --json` que o run publicou (artefato `morph-verify`) no **mesmo stamp** de uma rodada local, com `source: "ci"` e `ciRun` (URL do run); `sha` é o `headSha` do run, então o `verificationStale` compara o código que o CI viu com o HEAD. Nenhuma regra de gate muda: e2e pulado, escopo, evals e stale valem igual. Só o **artefato** vira prova, nunca o "verde" do run: workflow de lint, deploy ou de terceiro não compra o Gate 3. **Sem workflow** que rode `morph-spec verify` publicando `morph-verify.json`, cria e commita `.github/workflows/morph-verify.yml` na branch da feature (gatilho `push` em `morph/**`, `.morph/` fora do gatilho exceto o `config.json`, `cancel-in-progress`, setup de .NET por `global.json`/stack, install por lockfile, browsers do Playwright onde há config, e o `morph-spec` na versão de `.morph/.morphversion`). Um run sobre um commit anterior vale quando só `.morph/` andou desde ele; run `cancelled`/`skipped`/`startup_failure` não é prova. **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). 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`. **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`.
 - **Validador `code-budget` (nó `validators` do `verify`)** — mede o que a árvore **adicionou** contra a branch default: `git diff -U0` a partir do merge-base com `origin/{default}` (ou `{default}` local), arquivo novo não rastreado conta inteiro e arquivo movido sem edição não conta. Lê `.cs`/`.ts`/`.tsx`/`.js`/`.jsx`/`.mjs`/`.cjs`, fora de `.d.ts`, de `node_modules`/`bin`/`obj`/`dist`/`.morph` e de código gerado (`*.Designer.cs`, `*.g.cs`, `*ModelSnapshot.cs`). Três medidas, cada uma **um aviso, nunca erro**, mapeado em `code_quality` da rubrica: (a) **linhas de comentário adicionadas que citam processo** — `UC-nn`, `ADR-nn`, `FR-nn`, `T{n}`, `Gate N`, `spec.md`, mockup — avisa a partir de uma, com a contagem sobre o total de linhas de comentário adicionadas e até 4 `arquivo:linha` (standard `architecture-code-comments`); comentário é o que o varredor de `src/lib/ai/comment-stripper.js` separa de string, com template e regex literal de TS/JS; (b) **linhas não vazias de teste ÷ de produção** — avisa acima de **1,5×**, e só quando o teste adicionado passa de **40 linhas** (a regressão de um bug de duas linhas cabe abaixo disso); sem linha de produção, o aviso dá as duas contagens sem razão. (c) **densidade de comentário** — linhas de comentário adicionadas ÷ linhas de código adicionadas (as não vazias menos as de comentário), doc-comment (`///`, JSDoc) incluído — avisa acima de **1 a cada 10**, e só a partir de **40 linhas** de código, com até 4 arquivos mais comentados e suas contagens (o padrão do standard `architecture-code-comments` é nenhum comentário). Teste é o que o validador `reuse` já trata como teste: arquivo `.test.` ou `.spec.` com extensão `js`/`jsx`/`ts`/`tsx`, e tudo sob `__tests__/`, `test/`, `tests/` ou pasta terminada em `Test`/`Tests` (`Foo.Tests/`, `FooTests/`). O resto conta como produção, inclusive `a.test.mjs`, `a.test.cjs` e `*.e2e.ts` fora dessas pastas. 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. Fica fora do modo `light`. 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ê.
 - **`morph-spec mutate [feature] [--plan <arquivo>] [--out <arquivo>] [--no-subset] [--allow-dirty] [--jobs <n>] [--timeout <ms>] [--restore] [--json]`** — mutação **dirigida** para o avaliador do Gate 3: no máximo **3** mutantes, só quando o diff tem uma guarda que um UC exige e o avaliador não achou o teste que a morde. **Manifesto** (`--plan`, default `4-review/mutants.json`): `{"mutants":[{"id":"M1","file":"src/x.cs","line":42,"find":"a && b","replace":"a","expect":"OrdersTests.RecusaSemItens deve falhar"}]}` — `expect` é obrigatório (qual teste deve falhar e por quê, dito antes de rodar), `find` começa na `line` e é único nela; barra invertida do código vai como `{{BS}}` (o transporte do Bash a reduz). Mais de 3 mutantes ou `expect` ausente: exit 2. **Método:** recusa arquivo não commitado (`--allow-dirty` assume o risco); snapshot dos bytes fora da árvore (`<git-common-dir>/morph-spec/mutation/<run>/`) com journal — rodada que morreu se desfaz por `mutate --restore`; em .NET, uma chave `MORPH_MUTANT` por mutante de expressão e um build só (o que a chave não compila cai para rebuild real, e falha de build é `build-error`, nunca morte); depois **o subconjunto decide**: os testes que a feature alterou mais os que citam os tipos mutados (vitest/jest usam `related`) — a ferramenta escolhe, não o avaliador. `killed` = falha **nova** contra a rodada-base do mesmo escopo, com o motivo literal do TRX; `survived` no subconjunto é o veredito, com o `expect` ao lado; sem subconjunto utilizável, a suíte inteira roda e a morte tem de se repetir. **Reversão:** bytes do snapshot com md5 conferido, por escrita nova (nunca `os.utime`), rebuild forçado e DLL igual à de antes do 1º mutante. **Exit:** `0` rodou (sobrevivente é achado), `1` a árvore já não compilava, `2` uso, `3` semáforo ocupado, `4` **inseguro** (arquivo não restaurado ou binário que não bate). Segura **um** slot `heavy`.
 - **`morph-spec e2e up|status|down <feature>`** — ciclo de vida do stack de verificação, compartilhando toda a lógica com o nó `e2e` do verify. `up [--fresh]` reusa um stack quente **só** quando ele provadamente serve o código atual: o carimbo compara `HEAD` + `git status --porcelain` + `git diff HEAD`, então qualquer edição, commitada ou não, invalida o reuso (a exceção é o serviço com bind mount do código, que serve o disco por construção). Na dúvida, rebuild — o layer cache do Docker faz disso barato. O motivo impresso diz **o que** decidiu o reuso, e as duas procedências nunca se confundem: `source unchanged since build` é o carimbo, `source is bind-mounted` é o disco. E a segunda só sai quando **todo** serviço com seção `build:` monta a raiz do projeto — um sidecar Playwright montando `./e2e` ao lado de uma app compilada em imagem não fala pela stack inteira; nesse caso quem decide é o carimbo. `--fresh` derruba com volumes (`down -v`), apaga o carimbo e re-roda o seed. `status [--json]` responde a pergunta que decide se um verde vale alguma coisa (no ar? saudável? construído do código atual?) e sai 0 só com os três; o `baseUrl` do payload é o endereço real da app — é dele que a `morph-review` tira a URL que vai no prompt do avaliador, em vez de deixá-lo adivinhar `localhost:3000`. `down [--volumes]` é best-effort e nunca bloqueia. Isolamento entre worktrees: `COMPOSE_PROJECT_NAME=morph-{feature}` separa os containers e o bloco de portas do fleet (`env-allocator`) separa as portas — um compose com porta fixa não pode ser isolado, e isso é avisado. O bloco vale nos **dois** caminhos (este comando e o nó do `verify`): `PORT`, `MORPH_PORT_BASE`, `ASPNETCORE_URLS` em dotnet, mais `PLAYWRIGHT_BASE_URL` apontando para a porta alocada. Por isso o `playwright.config.ts` precisa ler a base URL do ambiente em vez de cravá-la — com a URL cravada, a suíte bate numa porta vazia e o `ECONNREFUSED` se disfarça de app quebrada.
@@ -275,8 +276,8 @@ passa com aviso de alta, e o comando grava.
 | --- | --- | --- |
 | Sub-agent implementador | só o filtro dos próprios testes, **uma vez**, antes do relatório (nunca `morph-spec verify`, nunca red→green) | A prova é do orquestrador; cada rodada extra dentro do sub-agent custa turnos que o teto corta |
 | Loop por task | `verify {f} {task}` (recorte automático: o `group` escolhe os nós, os `outputs` estreitam os testes — ver *O recorte por task*; `--filter {stack-da-task}` só para forçar os nós, `--full` para desligar) | O relógio de uma task não paga a suíte inteira; a task tocou **um** stack |
-| Gate 3 | `verify {f} --json` (sem filtro) | A prova que o avaliador lê tem de cobrir **todos** os nós |
-| CI | a suíte inteira, todos os nós | idem |
+| Gate 3 | `verify {f} --ci --json` (sem filtro; sem CI disponível, roda local) | A prova tem de cobrir **todos** os nós; no CI ela não ocupa a máquina e roda em paralelo com o avaliador |
+| 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 (task com `evidencias/` em `outputs`) | `verify {f} --filter {id-do-nó-evals} --skip-e2e --no-persist` | Só o nó `evals` (pulado no escopo de task), sem stack e sem carimbo — não é a verificação da task, é a prova que o `morph-implement` §5 grava |
 
 > **Não existe constante de 600 s neste CLI** (`grep -rn "600000" src/ framework/` → zero). O teto que
@@ -539,6 +540,6 @@ O servidor MCP (`graphify-mcp`, 10 tools, todas aceitando `project_path`) está
 | `PostToolUse` / `PostToolUseFailure` | `tool`, `toolUseId`, `durationMs`; Bash/PowerShell: `command` (redigido, ≤2000 chars) + `commandChars`, `exitCode`, `outcome` (`ok`/`error`/`timeout`/`interrupted`/`background`), `exitMasked` quando o exit gravado não é o do trabalho (pipe sem `pipefail`, `|| …`, `&` em background, ou `;` seguido de `echo`/`true`/`:` no fim); Read: `target`, `kind`, `bytes` (tamanho do arquivo), `offset`, `limit`, `bytesRead` — um Read que falhou não grava bytes, porque não trouxe nada; Agent: `persona`, `desc`, `prompt` + `promptChars`; SendMessage: `target`, `messageChars` |
 | `ToolBatch` | `size`, `tools` (contagem por ferramenta) — um por turno do modelo |
 | `SessionUsage` / `AgentUsage` | totais acumulados do transcript + `delta` desde a amostra anterior |
-| `Verify` | `scope`, `task`, `status`, `sha`, `fingerprint` (a árvore fora de `.morph/`), `tree` (`root`/`worktree`), `persisted`, `reason`, `nodes.{build,tests,validators,e2e}.{status,durationMs}`, `nodes.validators.{ran,skipped}` |
+| `Verify` | `scope`, `task`, `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}` |
 
 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/schemas/config.schema.json

@@ -9,6 +9,10 @@
       "type": "object",
       "additionalProperties": true,
       "properties": {
+        "ci": {
+          "type": "boolean",
+          "description": "false turns `verify {f} --ci` into the local verify (with the reason printed). Absent or true: the Gate 3 proof comes from the GitHub Actions workflow that runs `morph-spec verify` (created on first use), whenever origin is GitHub and gh is authenticated."
+        },
         "tests": {
           "type": "array",
           "description": "One entry per test suite. Absent (not empty) means the four-step fallback of resolveTestPlan() decides — every project created before this key existed keeps working. An empty array is an explicit declaration of 'no test suites'.",

package/framework/schemas/feature.schema.json

@@ -152,7 +152,9 @@
         "e2eReason": { "type": ["string", "null"], "description": "The LITERAL reason the e2e node skipped (e2e-check.js's own wording), or null when it did not skip. risk-detector.js's classifyE2eSkip() reads it: 'project does not containerize' / 'does not touch runtime' are legitimate dispensations and pass; 'docker is not available' / 'requested' (--skip-e2e) / anything unclassifiable — null included — are an absence of proof and pause Gate 3. A skip recorded WITHOUT a reason is refused on purpose: a nameless dispensation is a silent no-op." },
         "sha": { "type": ["string", "null"], "description": "HEAD commit SHA at verify time (git rev-parse HEAD); null when not in a git repo or no commits yet." },
         "ts": { "type": "string", "format": "date-time", "description": "Server-side timestamp, same instant as the corresponding verifications/taskVerifications entry's updatedAt." },
-        "scope": { "type": "string", "description": "'feature', or 'task:<id>' for a task-scoped verify. READ BY THE GATE, not just audit: this stamp is singular and any verify overwrites it, so a 'task:<id>' value at ship time means the last verify was NOT the feature's. risk-detector.js therefore accepts an e2e dispensation ('project'/'scope' in e2eReason) only from scope === 'feature' — a `morph-spec verify {f} {task}` of a task whose group does not touch runtime stamps exactly the legitimate-sounding reason that would otherwise buy Gate 3 for the whole feature (the last task of a feature is typically group: docs). Absent/unknown falls on the safe side, like an unclassifiable reason." }
+        "scope": { "type": "string", "description": "'feature', or 'task:<id>' for a task-scoped verify. READ BY THE GATE, not just audit: this stamp is singular and any verify overwrites it, so a 'task:<id>' value at ship time means the last verify was NOT the feature's. risk-detector.js therefore accepts an e2e dispensation ('project'/'scope' in e2eReason) only from scope === 'feature' — a `morph-spec verify {f} {task}` of a task whose group does not touch runtime stamps exactly the legitimate-sounding reason that would otherwise buy Gate 3 for the whole feature (the last task of a feature is typically group: docs). Absent/unknown falls on the safe side, like an unclassifiable reason." },
+        "source": { "type": "string", "enum": ["ci"], "description": "Present only when the stamp came from `verify --ci`: the verify --json the project CI uploaded for the pushed commit, judged by the same rules as a local run. Absent = local run." },
+        "ciRun": { "type": "string", "description": "URL of the CI run whose artifact wrote this stamp (with source: ci). `sha` is that run's headSha, so verificationStale compares the code CI saw with HEAD." }
       },
       "additionalProperties": false
     },

package/framework/skills/core/create-umbraco-lp/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a criação de uma landing page nova ponta-a-ponta a partir do
 version: core
 when-to-invoke: ao iniciar um novo projeto de LP com o template Umbraco genérico
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 stacks:
   - umbraco
 ---

package/framework/skills/core/migrate-lp-to-umbraco/SKILL.md

@@ -4,7 +4,7 @@ description: Migra uma landing page existente (React/Vite, Next.js estático ou
 version: core
 when-to-invoke: ao receber instrução "use /migrate-lp-to-umbraco {projeto}" do usuário, ou quando o usuário descrever necessidade de migrar uma LP para Umbraco
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 stacks:
   - umbraco
 ---

package/framework/skills/core/morph-apply/SKILL.md

@@ -4,7 +4,7 @@ description: Orquestra a execução autônoma de tasks de uma feature morph-spec
 version: core
 when-to-invoke: após Gate 2 aprovado, ao receber instrução "use /morph-apply" ou "implementar feature"
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-apply

package/framework/skills/core/morph-brainstorming/SKILL.md

@@ -4,7 +4,7 @@ description: Entende o negócio, os usuários e a arquitetura antes de qualquer
 version: core
 when-to-invoke: ao receber um novo request de feature, antes de morph-plan
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-brainstorming

package/framework/skills/core/morph-hotfix/SKILL.md

@@ -4,7 +4,7 @@ description: ADW cirúrgico de hotfix — resolve uma queda/bug crítico de prod
 version: core
 when-to-invoke: ao receber "/morph-hotfix {feature}", quando a morph-proposal classifica o pedido como workType hotfix (Passo 0), ou o usuário diz "produção caiu / hotfix / urgente"
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-hotfix

package/framework/skills/core/morph-implement/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a execução de cada tarefa de implementação com standard e
 version: core
 when-to-invoke: ao iniciar cada task de implementação listada em tasks.json
 user-invokable: false
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-implement

package/framework/skills/core/morph-machine/SKILL.md

@@ -4,7 +4,7 @@ description: Cuida da RAM e da CPU da máquina enquanto o morph-spec trabalha
 version: core
 when-to-invoke: quando a máquina está lenta ou sem RAM, um comando pesado esperou ou foi recusado pela fila, sobrou worktree de sub-agent, ou vários sub-agents pesados vão rodar em paralelo
 user-invokable: false
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-machine

package/framework/skills/core/morph-media/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz a AUTORIA de mídia gerada por IA — escolher o modelo pelo
 version: core
 when-to-invoke: quando a tarefa é PRODUZIR imagem ou vídeo por IA (catálogo, marketing, asset de LP) e alguém precisa decidir modelo, prompt e aprovação
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 stacks:
   - dotnet
   - nextjs

package/framework/skills/core/morph-plan/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a produção dos artefatos de planejamento de uma feature (use
 version: core
 when-to-invoke: ao iniciar a fase plan de uma feature, após o Gate 1 (proposal aprovado)
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-plan

package/framework/skills/core/morph-proposal/SKILL.md

@@ -4,7 +4,7 @@ description: Orquestra a fase de proposta+plano de uma feature morph-spec. Encad
 version: core
 when-to-invoke: ao receber instrução "use /morph-proposal" do usuário, ou ao iniciar uma nova feature
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-proposal

package/framework/skills/core/morph-review/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz a fase de revisão e produz o review-report.md para o Gate 3
 version: core
 when-to-invoke: ao iniciar a fase review, após todas as tasks de tasks.json estarem com status `done`
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-review
@@ -37,16 +37,28 @@ Fase review, com todas as tasks `done` e o `recap.md` em dia. Normalmente chamad
    - `evaluator.partial: true` (`PARCIAL` na 1ª linha): ver "PARCIAL" no passo 4.
    - Ausente ou sem veredito: siga para o passo 3.
 
-3. **Prova da suíte — uma rodada, sua.** Rode `morph-spec verify {feature} --json` **depois da
-   última task** (o `gate-check` pausa o ship se o último stamp é de escopo `task:{id}`).
-   **Sem `--filter`, sempre**: `verify {feature}` **nunca recorta**, e um verify filtrado não persiste o
+3. **Prova da suíte — uma rodada, no CI.** Depois da última task, commite o trabalho da feature na
+   branch (`git add <paths>` + `git commit`: o CI só vê commits) e rode
+   `morph-spec verify {feature} --ci --json` com `run_in_background`. Ele empurra `morph/{feature}`,
+   cria o workflow `morph-verify.yml` se o projeto não tem um, espera o run e grava o stamp do JSON que
+   o run publicou. Sem CI (sem GitHub, sem `gh`, `project.ci: false`) ele mesmo roda o verify local e
+   diz por quê. **Quando a saída mostrar `CI rodando`, despache o avaliador (passo 4) sem esperar o
+   fim**: o workflow e o push já estão commitados, então a foto `--before-eval` não os acusa como
+   mutação, e a suíte corre no CI em paralelo. Saiu `verify local`: espere o fim antes do passo 4 —
+   suíte local e `mutate` disputam a máquina. Exit 2 = trabalho fora de commit; exit 3 (`pending`/`busy`)
+   não é vermelho (ver Ritmo). Rode-a só depois da última task: o `gate-check` pausa o ship se o
+   último stamp é de escopo `task:{id}`. **Sem `--filter`, sempre**: `verify {feature}` **nunca recorta**, e um verify filtrado não persiste o
    stamp. Se o JSON vier com `repeatOf`, nada mudou desde a rodada anterior — use aquela. Esta é a
    única execução de testes do Gate 3: o avaliador não roda a suíte de novo.
-   - Nó `e2e`: `pass` → passe a URL ao avaliador (`morph-spec e2e status {feature} --json` →
-     `baseUrl`). `fail` → volte à correção. `skip` → quem classifica é o `gate-check`
-     (`classifyE2eSkip`, em `risk-detector.js`): dispensa de projeto/escopo passa; ambiente,
-     `--skip-e2e` ou razão desconhecida pausam sozinhos. Diga ao avaliador que a app não foi exercida.
-   - `traceability.warnings`: repasse ao avaliador como sinal, não bloqueio.
+   - Nó `e2e`: `pass` local → passe a URL ao avaliador (`morph-spec e2e status {feature} --json` →
+     `baseUrl`); `pass` no CI → a app foi exercida lá, não há stack local para navegar. `fail` →
+     correção (vermelho no CI: `gh run view <id> --log-failed`, impresso pelo verify). Vermelho por
+     config que só existe na máquina (`.env`, appsettings, connection string, secret) não é defeito do
+     código: pergunte ao usuário entre declarar o secret + `env:` no `morph-verify.yml` ou `project.ci: false`. `skip` → quem
+     classifica é o `gate-check` (`classifyE2eSkip`, em `risk-detector.js`): dispensa de projeto/escopo
+     passa; ambiente, `--skip-e2e` ou razão desconhecida pausam sozinhos.
+   - Vermelho com o avaliador ainda rodando: não mexa na árvore até ele voltar (passo 4); corrija junto
+     com os bloqueadores dele. `traceability.warnings` entram no review-report como sinal, não bloqueio.
 
 4. **Despache o avaliador independente** (`morph-evaluator`, contexto fresco, sem Write/Edit).
    - Tire a foto da árvore e escolha o modelo: `morph-spec report-check {feature} --before-eval --json`.
@@ -57,14 +69,14 @@ Fase review, com todas as tasks `done` e o `recap.md` em dia. Normalmente chamad
      review-report. Numa worktree com grafo stale, `morph-spec graph refresh` antes.
    ```
    dispatch Agent (subagent_type: "morph-evaluator", model: {evaluatorModel.model}) with prompt:
-     contexto: use cases + spec.md + diff da feature + JSON do verify (nós, e2e, URL)
+     contexto: use cases + spec.md + diff da feature + JSON do verify se já terminou (nós, e2e, URL)
                + blast radius + 1-design/mockups.md (se existir) + 3-implement/evidencias/*.md (se existir)
      instrução: |
        Siga .morph/framework/evals/review-checklist.md e grave
        .morph/features/{feature}/4-review/evaluator-report.md ANTES de encerrar — o arquivo é o
        retorno; não chame SendMessage. Se o arquivo já existir quando você começar, é resíduo de
        outra tentativa: não o leia antes de escrever o seu (ancoragem no veredito alheio).
-       A suíte já rodou (JSON acima): você NÃO roda verify, build nem testes. Bash é para ler
+       A suíte roda fora de você (JSON acima, ou o CI em curso): você NÃO roda verify, build nem testes. Bash é para ler
        (git diff/log/show, grep, morph-spec graph) e para no máximo UMA rodada de
        `morph-spec mutate {feature}` (até 3 mutantes com `expect`), só quando o checklist pede.
        Nada em segundo plano, nada de laço de espera. NUNCA `git checkout --`: descarta trabalho
@@ -80,8 +92,9 @@ Fase review, com todas as tasks `done` e o `recap.md` em dia. Normalmente chamad
    - `tree.sinceBeforeEval.changed` vazio e `tree.markers` vazio = árvore como antes do dispatch.
      Arquivo listado = mutação que ficou no disco: `morph-spec mutate --restore` devolve os bytes do
      snapshot conferindo md5; fora de uma rodada de mutação, desfaça linha a linha pelo diff.
-     **NUNCA `git checkout -- src/` aqui**: na árvore de
-     uma feature em review não existe nenhum commit da feature, e o checkout apaga o trabalho junto.
+     **NUNCA `git checkout -- src/` aqui**: o checkout apaga junto tudo o que não foi commitado depois
+     da prova (correção de bloqueador, trabalho de outra sessão), e no verify local a feature pode nem
+     ter commit.
    - `tree.sinceBeforeEval` `null` = sem foto; `tree` `null` = git não respondeu, nada foi conferido.
    - Não rode build/teste enquanto o agente está `running`.
 
@@ -91,8 +104,8 @@ Fase review, com todas as tasks `done` e o `recap.md` em dia. Normalmente chamad
    MESMO avaliador por `SendMessage`, colando `tree.dirty` e `tree.commits` no recado. Só se o id não
    retomar, despache um novo.
 
-5. **Bloqueadores.** `**Verdict:** FIX` ou bloqueador aberto: corrija (loop da `morph-apply`), rode o
-   verify de novo e **confirme só os bloqueadores** retomando o MESMO avaliador por `SendMessage`
+5. **Bloqueadores.** `**Verdict:** FIX` ou bloqueador aberto: corrija (loop da `morph-apply`), commite, rode o
+   `verify {feature} --ci` de novo e **confirme só os bloqueadores** retomando o MESMO avaliador por `SendMessage`
    (com `tree.dirty`/`tree.commits` e uma foto `--before-eval` nova). Ele não reavalia a feature
    inteira, e **nota nunca motiva nova rodada**. Avaliador encerrado: despache um novo dizendo que
    é uma confirmação dos bloqueadores Bn — o relatório é append-only e vale o último `**Verdict:**`.

package/framework/skills/core/morph-stack-scan/SKILL.md

@@ -4,7 +4,7 @@ description: Varre o codebase existente, detecta stack atual, compara com o stac
 version: core
 when-to-invoke: ao iniciar uma feature em projeto brownfield (codebase já existente)
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-stack-scan

package/framework/skills/core/morph-standards/SKILL.md

@@ -4,7 +4,7 @@ description: Localiza um standard específico via busca server-side (morph-spec
 version: core
 when-to-invoke: quando precisar consultar um standard específico durante a implementação
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-standards

package/framework/skills/core/morph-uiux/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz a fase opcional de UI/UX — design system, mockups, compone
 version: core
 when-to-invoke: ao tomar o ramo uiux (morph-spec advance --design), depois do Gate 1 e antes do morph-plan
 user-invokable: true
-cliVersion: "8.45.0"
+cliVersion: "8.46.0"
 ---
 
 # morph-uiux

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.45.0",
+  "version": "8.46.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/validation/verify.js

@@ -4,7 +4,7 @@ import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { runVerify, readTask, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
 import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
-import { canonicalPath } from '../../lib/tasks/test-runner.js';
+import { canonicalPath, readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { getHeadSha } from '../../lib/git/default-branch.js';
 import { EVAL_RUNNER } from '../../lib/tasks/eval-node.js';
 import { buildVerifyEvent, recordVerifyEvent, findRepeatedVerify } from '../../lib/telemetry/verify-event.js';
@@ -12,6 +12,7 @@ import { treeFingerprint } from '../../lib/git/tree-fingerprint.js';
 import { HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
+import { runCiVerify, CiUsageError } from '../../lib/ci/ci-verify.js';
 
 /** ✓ pass · ✗ fail · – skip */
 function statusIcon(status) {
@@ -190,6 +191,54 @@ function evalsStatusOf(result) {
  */
 const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'], ['skipBuild', 'skip-build']];
 
+const CI_EXCLUSIVE_FLAGS = [
+  ['filter', '--filter'], ['skipTests', '--skip-tests'], ['skipBuild', '--skip-build'], ['skipE2e', '--skip-e2e'],
+  ['freshE2e', '--fresh-e2e'], ['linux', '--linux'], ['recordBaseline', '--record-baseline'], ['refreshCache', '--refresh-cache'],
+  ['noPersist', '--no-persist'],
+];
+
+async function runLocalVerify(featureName, taskId, options) {
+  try {
+    return await runVerify(process.cwd(), featureName, taskId || null, {
+      rubric: options.rubric,
+      timeout: options.timeout,
+      skipTests: options.skipTests,
+      skipBuild: options.skipBuild,
+      skipE2e: options.skipE2e,
+      freshE2e: options.freshE2e,
+      filter: options.filter,
+      recordBaseline: options.recordBaseline,
+      refreshCache: options.refreshCache,
+      linux: options.linux,
+      linuxImage: options.linuxImage,
+      // Task scope: switch the recorte off (#87). At feature scope nothing is
+      // ever narrowed, so the flag is a documented no-op there, not an error.
+      full: options.full,
+    });
+  } catch (err) {
+    // A wrong invocation is exit 2, like an unknown feature or task — never a
+    // verdict. `--filter` that selects nothing must not print green (or red):
+    // there is no verification to report, only a command to fix.
+    if (err instanceof VerifyUsageError) {
+      console.error(chalk.red(`\n❌ ${err.message}\n`));
+      process.exit(2);
+    }
+    // Ocupado não é veredito: nada foi verificado, então não há stamp nem
+    // evento, e o exit 3 nunca é "vermelho".
+    if (err instanceof HeavyBusyError) {
+      if (options.json) {
+        const holders = err.holders.map(({ pid, label, feature, node, since }) => ({ pid, label, feature, node, since }));
+        console.log(JSON.stringify({
+          status: 'busy', persisted: false, busy: { reason: err.reason, holders, freeGb: err.freeGb, waitedMs: err.waitedMs },
+        }, null, 2));
+      }
+      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
+      process.exit(3);
+    }
+    throw err;
+  }
+}
+
 /**
  * `morph-spec verify <feature> [task]` — the deterministic code-before-judge
  * gate: build + tests + validators, BEFORE the LLM eval. See verify-runner.js
@@ -223,6 +272,14 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     process.exit(2);
   }
 
+  if (options.ci) {
+    const conflict = taskId ? `a task ${taskId} (o loop por task é local)` : CI_EXCLUSIVE_FLAGS.find(([flag]) => options[flag])?.[1];
+    if (conflict) {
+      console.error(chalk.red(`\n❌ --ci roda a suíte inteira da feature no CI; não combina com ${conflict}\n`));
+      process.exit(2);
+    }
+  }
+
   // The runner's own reader (one reader of tasks.json for verify, #87): null
   // means tasks.json or the task is missing, and both are this usage error.
   if (taskId) {
@@ -232,51 +289,36 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     }
   }
 
-  // Taken before the run: it is the tree the run is about to read.
-  const fingerprint = treeFingerprint(process.cwd());
-
-  let result;
-  try {
-    result = await runVerify(process.cwd(), featureName, taskId || null, {
-      rubric: options.rubric,
-      timeout: options.timeout,
-      skipTests: options.skipTests,
-      skipBuild: options.skipBuild,
-      skipE2e: options.skipE2e,
-      freshE2e: options.freshE2e,
-      filter: options.filter,
-      recordBaseline: options.recordBaseline,
-      refreshCache: options.refreshCache,
-      linux: options.linux,
-      linuxImage: options.linuxImage,
-      // Task scope: switch the recorte off (#87). At feature scope nothing is
-      // ever narrowed, so the flag is a documented no-op there, not an error.
-      full: options.full,
-    });
-  } catch (err) {
-    // A wrong invocation is exit 2, like an unknown feature or task — never a
-    // verdict. `--filter` that selects nothing must not print green (or red):
-    // there is no verification to report, only a command to fix.
-    if (err instanceof VerifyUsageError) {
-      console.error(chalk.red(`\n❌ ${err.message}\n`));
-      process.exit(2);
-    }
-    // Ocupado não é veredito: nada foi verificado, então não há stamp nem
-    // evento, e o exit 3 nunca é "vermelho".
-    if (err instanceof HeavyBusyError) {
-      if (options.json) {
-        const holders = err.holders.map(({ pid, label, feature, node, since }) => ({ pid, label, feature, node, since }));
-        console.log(JSON.stringify({
-          status: 'busy', persisted: false, busy: { reason: err.reason, holders, freeGb: err.freeGb, waitedMs: err.waitedMs },
-        }, null, 2));
+  let ci = null;
+  if (options.ci) {
+    try {
+      const outcome = await runCiVerify(process.cwd(), featureName, readMorphConfig(process.cwd()), {
+        log: (line) => console.error(chalk.gray(`   ${line}`)),
+      });
+      if (outcome.mode === 'ci') {
+        ci = outcome;
+      } else if (outcome.mode === 'pending') {
+        if (options.json) console.log(JSON.stringify({ status: 'pending', persisted: false, reason: outcome.reason }, null, 2));
+        console.error(chalk.yellow(`\n⏳ ${outcome.reason}. Não é vermelho e não há stamp: não repita em laço — siga e deixe o gate-check decidir.\n`));
+        process.exit(3);
+      } else {
+        console.error(chalk.yellow(`\n↪ CI indisponível (${outcome.reason}) — verify local.\n`));
       }
-      console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
-      process.exit(3);
+    } catch (err) {
+      if (err instanceof CiUsageError) {
+        console.error(chalk.red(`\n❌ ${err.message}\n`));
+        process.exit(2);
+      }
+      throw err;
     }
-    throw err;
   }
 
-  const cleanup = afterHeavyRun({
+  // Taken before the run: it is the tree the run is about to read.
+  const fingerprint = treeFingerprint(process.cwd());
+
+  const result = ci ? ci.result : await runLocalVerify(featureName, taskId, options);
+
+  const cleanup = ci ? { status: 'skipped', reason: 'ci' } : afterHeavyRun({
     projectPath: process.cwd(),
     config: readHeavyConfig(process.cwd()),
     scope: taskId ? 'task' : 'feature',
@@ -329,9 +371,10 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       status: result.status,
       nodes: nodeStatuses(result),
       e2eReason: result.nodes.e2e.status === 'skip' ? (result.nodes.e2e.reason ?? null) : null,
-      sha: getHeadSha(process.cwd()),
+      sha: ci ? ci.run.headSha : getHeadSha(process.cwd()),
       ts: now,
       scope: taskId ? `task:${taskId}` : 'feature',
+      ...(ci ? { source: 'ci', ciRun: ci.run.url } : {}),
     };
     await updateFeature(featureName, 'verification', stamp);
   }
@@ -341,9 +384,9 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   let repeatOf = null;
   try {
     const cwd = process.cwd();
-    if (!taskId && persist) repeatOf = findRepeatedVerify(cwd, { feature: featureName, task: null, scope: result.scope, fingerprint });
+    if (!taskId && persist && !ci) repeatOf = findRepeatedVerify(cwd, { feature: featureName, task: null, scope: result.scope, fingerprint });
     const tree = resolve(cwd).replace(/\\/g, '/') === resolvePrimaryRoot(cwd) ? 'root' : 'worktree';
-    recordVerifyEvent(cwd, buildVerifyEvent(result, { sha: getHeadSha(cwd), tree, persisted: persist, reason, fingerprint }));
+    recordVerifyEvent(cwd, buildVerifyEvent(result, { sha: ci ? ci.run.headSha : getHeadSha(cwd), tree, persisted: persist, reason, fingerprint, source: ci ? 'ci' : 'local' }));
   } catch { /* telemetry never changes the verdict */ }
 
   // The refusal always goes to stderr, so it survives --json (whose stdout has
@@ -355,10 +398,18 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   }
 
   if (options.json) {
-    const output = { ...result, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup };
+    const output = {
+      ...result, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup,
+      ...(ci ? { source: 'ci', ciRun: { id: ci.run.databaseId, url: ci.run.url, sha: ci.run.headSha }, workflowCreated: ci.created } : {}),
+    };
     console.log(JSON.stringify(output, null, 2));
   } else {
     console.log(formatVerifyResult(result));
+    if (ci) {
+      console.log(chalk.cyan(`fonte: CI ${ci.run.url}`));
+      if (result.status === 'fail') console.log(chalk.gray(`   log das falhas: gh run view ${ci.run.databaseId} --log-failed`));
+      console.log('');
+    }
     if (cleanup.status !== 'skipped') {
       const mark = cleanup.status === 'ran' ? chalk.green('✓') : chalk.yellow('⚠');
       console.log(chalk.gray(`${mark} dotnet build-server shutdown: ${cleanup.status}${cleanup.reason ? ` (${cleanup.reason})` : ''}\n`));

package/src/lib/ci/ci-verify.js

@@ -0,0 +1,118 @@
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getHeadSha } from '../git/default-branch.js';
+import { treeMovedSince } from '../git/evidence-staleness.js';
+import { resolveGh } from '../git/gh.js';
+import {
+  CI_WORKFLOW_DIR, CI_WORKFLOW_FILE, ciAvailability, downloadResult, findCiWorkflow, pushBranch,
+  uncommittedCode, waitForRun, workflowPushProblem,
+} from './github-ci.js';
+import { renderCiWorkflow } from './workflow-scaffold.js';
+
+export const CI_WAIT_MS = 50 * 60 * 1000;
+const APPEAR_MS = Number(process.env.MORPH_CI_APPEAR_MS ?? 90 * 1000);
+
+export class CiUsageError extends Error {}
+
+const NODE_KEYS = ['build', 'tests', 'validators', 'e2e'];
+
+function isVerifyResult(result) {
+  return Boolean(result) && ['pass', 'fail'].includes(result.status) && result.scope === 'feature'
+    && NODE_KEYS.every((k) => typeof result.nodes?.[k]?.status === 'string');
+}
+
+function scaffoldWorkflow(root, config) {
+  const rel = `${CI_WORKFLOW_DIR}/${CI_WORKFLOW_FILE}`;
+  const abs = join(root, rel);
+  if (existsSync(abs)) return { error: `${rel} já existe e não chama morph-spec verify publicando o JSON` };
+  try {
+    mkdirSync(join(root, CI_WORKFLOW_DIR), { recursive: true });
+    writeFileSync(abs, renderCiWorkflow(root, config));
+    execFileSync('git', ['add', '--', rel], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', 'ci: workflow morph-verify (prova do Gate 3 no CI)', '--', rel], { cwd: root, stdio: 'pipe' });
+    return { path: rel };
+  } catch (err) {
+    return { error: `não consegui criar ${rel}: ${(err.stderr?.toString() || err.message).trim()}` };
+  }
+}
+
+function dispatchWorkflow(root, workflow, branch) {
+  try {
+    const { bin, prefix } = resolveGh();
+    execFileSync(bin, [...prefix, 'workflow', 'run', workflow, '--ref', branch], { cwd: root, stdio: 'pipe', timeout: 15000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * `verify {f} --ci`: the feature-scope proof, run by the project's CI over the pushed commit.
+ * Every way CI cannot answer is `mode: 'local'` with the reason, and the caller runs the local
+ * verify: no CI is never a pause. Only the uploaded `verify --json` becomes a result, so the
+ * gate judges a CI run by the same stamp and the same rules as a local one.
+ *
+ * @returns {Promise<
+ *   { mode: 'local', reason: string } |
+ *   { mode: 'pending', reason: string, run: object|null } |
+ *   { mode: 'ci', result: object, run: object, created: string|null }>}
+ * @throws {CiUsageError} code CI would not see (uncommitted work)
+ */
+export async function runCiVerify(root, featureName, config, { log = () => {}, waitMs = CI_WAIT_MS, wait = waitForRun } = {}) {
+  const avail = ciAvailability(root, featureName, config);
+  if (!avail.ok) return { mode: 'local', reason: avail.reason };
+
+  const dirty = uncommittedCode(root);
+  if (dirty === null) return { mode: 'local', reason: 'git status não respondeu' };
+  if (dirty.length > 0) {
+    const shown = dirty.slice(0, 5).join(', ') + (dirty.length > 5 ? ` (+${dirty.length - 5})` : '');
+    throw new CiUsageError(`o CI só vê commits e há trabalho fora deles: ${shown}. Commite na branch da feature (git add <paths> && git commit) e rode de novo, ou rode sem --ci`);
+  }
+
+  let workflow = findCiWorkflow(root);
+  let created = null;
+  if (!workflow) {
+    const problem = workflowPushProblem(avail);
+    if (problem) return { mode: 'local', reason: problem };
+    const scaffold = scaffoldWorkflow(root, config);
+    if (scaffold.error) return { mode: 'local', reason: scaffold.error };
+    created = scaffold.path;
+    workflow = CI_WORKFLOW_FILE;
+    log(`workflow criado e commitado: ${created}`);
+  }
+
+  const pushError = pushBranch(root, avail.branch);
+  if (pushError) return { mode: 'local', reason: `push de ${avail.branch} falhou: ${pushError}` };
+
+  const head = getHeadSha(root);
+  const waitOpts = {
+    branch: avail.branch,
+    workflow,
+    isCurrent: (sha) => !treeMovedSince(root, sha, head),
+    timeoutMs: waitMs,
+    appearMs: APPEAR_MS,
+    onPending: (run) => log(`CI rodando: ${run.url}`),
+  };
+  let outcome = await wait(root, waitOpts);
+  if (outcome.state === 'no-run' && dispatchWorkflow(root, workflow, avail.branch)) {
+    log(`nenhum run para este commit; disparei ${workflow} manualmente`);
+    outcome = await wait(root, waitOpts);
+  }
+  if (outcome.state === 'no-run') return { mode: 'local', reason: `${workflow} não rodou para este commit` };
+  if (outcome.state === 'unknown') return { mode: 'local', reason: 'gh run list não respondeu' };
+  if (outcome.state === 'timeout') {
+    return { mode: 'pending', reason: `o CI não terminou em ${Math.round(waitMs / 60000)} min`, run: outcome.run ?? null };
+  }
+
+  const { run } = outcome;
+  const result = downloadResult(root, run.databaseId);
+  if (!isVerifyResult(result)) {
+    return {
+      mode: 'local',
+      reason: `run ${run.conclusion} sem o JSON do verify (${run.url}; gh run view ${run.databaseId} --log-failed)`,
+    };
+  }
+  const { persisted, reason, repeatOf, cleanup, ...verdict } = result;
+  return { mode: 'ci', result: verdict, run, created };
+}

package/src/lib/ci/github-ci.js

@@ -0,0 +1,192 @@
+import { execFileSync, spawnSync } from 'child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { resolveGh } from '../git/gh.js';
+
+export const CI_WORKFLOW_DIR = '.github/workflows';
+export const CI_WORKFLOW_FILE = 'morph-verify.yml';
+export const CI_ARTIFACT = 'morph-verify';
+export const CI_RESULT_FILE = 'morph-verify.json';
+
+// A run that never judged the code (superseded, filtered out, quota) is no proof either way.
+const NO_VERDICT = new Set(['cancelled', 'skipped', 'startup_failure', 'stale', 'neutral']);
+
+const VERIFY_CALL = /morph-spec\S*\s+verify\b/;
+
+const git = (cwd, args) => execFileSync('git', args, { cwd, stdio: 'pipe' }).toString();
+
+function gh(cwd, args, timeout = 15000) {
+  const { bin, prefix } = resolveGh();
+  return execFileSync(bin, [...prefix, ...args], { cwd, stdio: 'pipe', timeout }).toString();
+}
+
+/**
+ * The workflow that can stand in for `verify {feature}`: it must call `morph-spec verify` AND
+ * publish its JSON, because only that artifact becomes a stamp. A green run of any other
+ * workflow (lint, deploy) proves nothing about the suite.
+ *
+ * @param {string} root
+ * @returns {string|null} workflow file name, as `gh run list --workflow` takes it
+ */
+export function findCiWorkflow(root) {
+  const dir = join(root, CI_WORKFLOW_DIR);
+  if (!existsSync(dir)) return null;
+  const files = readdirSync(dir).filter((f) => /\.ya?ml$/i.test(f)).sort((a, b) =>
+    (a === CI_WORKFLOW_FILE ? -1 : b === CI_WORKFLOW_FILE ? 1 : a.localeCompare(b)));
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync(join(dir, file), 'utf8');
+    } catch {
+      continue;
+    }
+    if (VERIFY_CALL.test(text) && text.includes(CI_RESULT_FILE)) return file;
+  }
+  return null;
+}
+
+export function currentBranch(root) {
+  try {
+    return git(root, ['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+  } catch {
+    return null;
+  }
+}
+
+function originUrl(root) {
+  try {
+    return git(root, ['config', '--get', 'remote.origin.url']).trim();
+  } catch {
+    return null;
+  }
+}
+
+function ghAuthText(root) {
+  const { bin, prefix } = resolveGh();
+  const res = spawnSync(bin, [...prefix, 'auth', 'status'], { cwd: root, stdio: 'pipe', timeout: 10000 });
+  if (res.error || res.status !== 0) return null;
+  return `${res.stdout ?? ''}${res.stderr ?? ''}`;
+}
+
+/**
+ * Whether CI can answer for this feature, and why not. Never throws: every "no" is a reason the
+ * caller prints before falling back to the local verify.
+ *
+ * @param {string} root - the feature's tree
+ * @param {string} featureName
+ * @param {object|null} config - `.morph/config/config.json`
+ * @returns {{ ok: true, branch: string, https: boolean, scopes: string|null } | { ok: false, reason: string }}
+ */
+export function ciAvailability(root, featureName, config) {
+  if (config?.project?.ci === false) return { ok: false, reason: 'project.ci = false no config.json' };
+  const url = originUrl(root);
+  if (!url) return { ok: false, reason: 'sem remote origin' };
+  if (!/github\.com/i.test(url)) return { ok: false, reason: 'origin não é GitHub' };
+  const branch = currentBranch(root);
+  if (branch !== `morph/${featureName}`) {
+    return { ok: false, reason: `branch atual "${branch}" não é morph/${featureName}` };
+  }
+  const auth = ghAuthText(root);
+  if (auth === null) return { ok: false, reason: 'gh ausente ou não autenticado' };
+  const scopes = auth.match(/Token scopes:\s*(.*)/i)?.[1] ?? null;
+  return { ok: true, branch, https: /^https?:/i.test(url), scopes };
+}
+
+/**
+ * Creating a workflow file over HTTPS needs the token's `workflow` scope; without it GitHub
+ * rejects the whole push. Unknown scopes (fine-grained token, SSH remote) are not a refusal.
+ */
+export function workflowPushProblem({ https, scopes }) {
+  if (!https || scopes === null) return null;
+  return /\bworkflow\b/.test(scopes) ? null : 'o token do gh não tem o escopo "workflow" (gh auth refresh -s workflow)';
+}
+
+/**
+ * Paths CI would not see: uncommitted or untracked files outside `.morph/`, plus the config,
+ * which names the test commands.
+ *
+ * @returns {string[]|null} null when git did not answer
+ */
+export function uncommittedCode(root) {
+  let out;
+  try {
+    out = git(root, ['status', '--porcelain', '-z', '--untracked-files=all', '--no-renames']);
+  } catch {
+    return null;
+  }
+  return out.split('\0').filter(Boolean).map((line) => line.slice(3))
+    .filter((path) => !path.startsWith('.morph/') || path === '.morph/config/config.json');
+}
+
+export function pushBranch(root, branch) {
+  try {
+    git(root, ['push', '-u', 'origin', branch]);
+    return null;
+  } catch (err) {
+    return (err.stderr?.toString() || err.message).trim().split('\n').slice(-3).join(' ');
+  }
+}
+
+/** @returns {Array<object>|null} newest first; null = gh did not answer */
+export function listRuns(root, branch, workflow) {
+  try {
+    return JSON.parse(gh(root, ['run', 'list', '--branch', branch, '--workflow', workflow, '--limit', '20',
+      '--json', 'databaseId,status,conclusion,headSha,url,createdAt']));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The newest run over the same code as HEAD. `isCurrent` is a tree comparison, not SHA equality:
+ * the evaluator and the archive commit only `.morph/`, and the workflow does not re-run for them.
+ */
+export function pickRun(runs, isCurrent) {
+  return (runs || []).find((run) => !(run.status === 'completed' && NO_VERDICT.has(run.conclusion))
+    && run.headSha && isCurrent(run.headSha)) ?? null;
+}
+
+/** @returns {object|null} the parsed `verify --json` the run uploaded; null when absent or unreadable */
+export function downloadResult(root, runId) {
+  const dir = mkdtempSync(join(tmpdir(), 'morph-ci-'));
+  try {
+    gh(root, ['run', 'download', String(runId), '--name', CI_ARTIFACT, '--dir', dir], 120000);
+    return JSON.parse(readFileSync(join(dir, CI_RESULT_FILE), 'utf8'));
+  } catch {
+    return null;
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Polls until the run over the current tree completes. Never decides: the caller turns
+ * `timeout`/`no-run`/`unknown` into "no CI proof", never into red.
+ *
+ * @returns {Promise<{ state: 'completed'|'timeout'|'no-run'|'unknown', run?: object }>}
+ */
+export async function waitForRun(root, { branch, workflow, isCurrent, timeoutMs, appearMs, pollMs = 15000,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)), now = Date.now, onPending = () => {}, list = listRuns }) {
+  const start = now();
+  let seen = false;
+  let misses = 0;
+  for (;;) {
+    const runs = list(root, branch, workflow);
+    if (runs === null) {
+      if (++misses >= 3) return { state: 'unknown' };
+    } else {
+      misses = 0;
+      const run = pickRun(runs, isCurrent);
+      if (run?.status === 'completed') return { state: 'completed', run };
+      if (run) {
+        if (!seen) onPending(run);
+        seen = true;
+      }
+    }
+    const elapsed = now() - start;
+    if (!seen && elapsed >= appearMs) return { state: 'no-run' };
+    if (elapsed >= timeoutMs) return { state: 'timeout' };
+    await sleep(pollMs);
+  }
+}

package/src/lib/ci/workflow-scaffold.js

@@ -0,0 +1,122 @@
+import { existsSync, readdirSync } from 'fs';
+import { join, posix, relative, resolve } from 'path';
+import { PACKAGE_LOCATIONS } from '../detectors/index.js';
+import { CI_ARTIFACT, CI_RESULT_FILE } from './github-ci.js';
+
+const LOCKFILES = [
+  ['package-lock.json', 'npm ci'],
+  ['pnpm-lock.yaml', 'corepack enable && pnpm install --frozen-lockfile'],
+  ['yarn.lock', 'corepack enable && yarn install --frozen-lockfile'],
+];
+const PLAYWRIGHT_CONFIGS = ['playwright.config.ts', 'playwright.config.js', 'playwright.config.mjs'];
+
+function packageDirs(root, config) {
+  const dirs = [...PACKAGE_LOCATIONS];
+  if (typeof config?.project?.frontendPath === 'string') dirs.push(config.project.frontendPath);
+  for (const node of Array.isArray(config?.project?.tests) ? config.project.tests : []) {
+    if (typeof node?.cwd === 'string') dirs.push(node.cwd);
+  }
+  const seen = new Set();
+  const out = [];
+  for (const dir of dirs) {
+    const abs = resolve(root, dir.trim() || '.');
+    const rel = relative(root, abs).split('\\').join('/') || '.';
+    if (rel.startsWith('..') || seen.has(rel)) continue;
+    seen.add(rel);
+    const lock = LOCKFILES.find(([file]) => existsSync(join(abs, file)));
+    if (lock) out.push({ dir: rel, install: lock[1], playwright: PLAYWRIGHT_CONFIGS.some((f) => existsSync(join(abs, f))) });
+  }
+  return out;
+}
+
+function usesDotnet(root, config) {
+  if (existsSync(join(root, 'global.json'))) return true;
+  if (/dotnet/i.test(String(config?.project?.stack ?? ''))) return true;
+  if ((config?.project?.tests ?? []).some?.((node) => node?.runner === 'dotnet' || /\bdotnet\b/.test(node?.command ?? ''))) return true;
+  try {
+    return readdirSync(root).some((f) => /\.(sln|slnx|csproj)$/i.test(f));
+  } catch {
+    return false;
+  }
+}
+
+function dotnetSetup(root, config) {
+  if (!usesDotnet(root, config)) return [];
+  const hasGlobalJson = existsSync(join(root, 'global.json'));
+  return [
+    '      - uses: actions/setup-dotnet@v4',
+    '        with:',
+    hasGlobalJson ? '          global-json-file: global.json' : "          dotnet-version: '10.0.x'",
+  ];
+}
+
+const step = (name, dir, run) => [
+  `      - name: ${name}`,
+  ...(dir === '.' ? [] : [`        working-directory: ${posix.normalize(dir)}`]),
+  `        run: ${run}`,
+];
+
+/**
+ * The workflow `verify {f} --ci` relies on. Same judge as the local run: it calls the project's
+ * pinned morph-spec, so the suite is whatever `project.tests` says, not a second definition here.
+ * `.morph/` is out of the trigger (bookkeeping commits would cancel the run over the code) except
+ * the config, which names the commands.
+ *
+ * @param {string} root
+ * @param {object|null} config
+ * @returns {string}
+ */
+export function renderCiWorkflow(root, config) {
+  const packages = packageDirs(root, config);
+  const lines = [
+    '# Gerado por morph-spec: a prova do Gate 3 roda aqui (verify {feature} --ci).',
+    'name: morph-verify',
+    '',
+    'on:',
+    '  push:',
+    "    branches: ['morph/**']",
+    '    paths:',
+    "      - '**'",
+    "      - '!.morph/**'",
+    "      - '.morph/config/config.json'",
+    '  workflow_dispatch:',
+    '',
+    'concurrency:',
+    '  group: morph-verify-${{ github.ref }}',
+    '  cancel-in-progress: true',
+    '',
+    'jobs:',
+    '  verify:',
+    '    runs-on: ubuntu-latest',
+    '    timeout-minutes: 45',
+    '    env:',
+    "      MORPH_HEAVY: 'off'",
+    '    steps:',
+    '      - uses: actions/checkout@v4',
+    '      - uses: actions/setup-node@v4',
+    '        with:',
+    "          node-version: '22'",
+    ...dotnetSetup(root, config),
+  ];
+  for (const pkg of packages) {
+    lines.push(...step(`install (${pkg.dir})`, pkg.dir, pkg.install));
+    if (pkg.playwright) lines.push(...step(`playwright browsers (${pkg.dir})`, pkg.dir, 'npx playwright install --with-deps chromium'));
+  }
+  lines.push(
+    '      - name: morph-spec verify',
+    '        shell: bash',
+    '        run: |',
+    '          feature="${GITHUB_REF_NAME#morph/}"',
+    "          version=$(node -p \"try { require('./.morph/.morphversion').morphVersion } catch { 'latest' }\")",
+    `          npx -y "@polymorphism-tech/morph-spec@\${version}" verify "$feature" --json --no-persist > ${CI_RESULT_FILE}`,
+    '      - uses: actions/upload-artifact@v4',
+    '        if: always()',
+    '        with:',
+    `          name: ${CI_ARTIFACT}`,
+    `          path: ${CI_RESULT_FILE}`,
+    '          if-no-files-found: ignore',
+    '          retention-days: 7',
+    '',
+  );
+  return lines.join('\n');
+}

package/src/lib/telemetry/verify-event.js

@@ -14,10 +14,10 @@ const NODE_NAMES = ['build', 'tests', 'validators', 'e2e'];
 /**
  * @param {Object} result - runVerify() output
  * @param {{ sha: string|null, tree: 'root'|'worktree', persisted: boolean, reason: string|null,
- *   fingerprint?: string|null }} context
+ *   fingerprint?: string|null, source?: 'local'|'ci' }} context
  * @returns {Object}
  */
-export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerprint = null }) {
+export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerprint = null, source = 'local' }) {
   const nodes = {};
   for (const name of NODE_NAMES) {
     const node = result.nodes?.[name];
@@ -40,6 +40,7 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
     tree,
     persisted,
     reason: persisted ? null : (reason ?? null),
+    source,
     nodes,
   };
 }