@polymorphism-tech/morph-spec 9.1.0 → 9.3.0

package/framework/hooks/shared/gate-event.js

@@ -0,0 +1,18 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { appendTelemetryEvent } from './telemetry-logger.js';
+
+export const GATE_EVENT = 'Gate';
+export const GATE_STEPS = ['decision', 'approve', 'unapprove'];
+
+/**
+ * The trail `cost --metrics` turns into "what did the human do with each pause":
+ * `gateDecisions` keeps only the latest decision, so the history lives here.
+ */
+export function recordGateEvent(projectPath, { feature, gate, step, pause, signal, source, approvedBy }) {
+  if (!existsSync(join(projectPath || process.cwd(), '.morph'))) return;
+  const event = { event: GATE_EVENT, feature, gate, step };
+  if (step === 'decision') Object.assign(event, { pause: pause === true, signal: signal ?? null, source: source ?? null });
+  else event.approvedBy = approvedBy ?? null;
+  appendTelemetryEvent(event, projectPath);
+}

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

@@ -0,0 +1,107 @@
+// The single rule of "what the session does next". `decideNext` is pure: collectors feed facts.
+// Hooks and the CLI share it so the SessionStart pre-fetch and `morph-spec next` never disagree.
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { derivePhaseForFeature } from './state-reader.js';
+import { sliceProgress, readySlices } from './slice-progress.js';
+
+export const FIX_ATTEMPTS = 3;
+
+const step = (action, command, reason, extra = {}) => ({ action, command, reason, ...extra });
+
+/**
+ * @param {{ feature: string, phase: string, slices: object|null, gates: object,
+ *   verification: { status?: string }|null, verificationStale?: boolean, failStreak?: number }} s
+ * `verificationStale` undefined = unknown (the hook has no git): read as fresh.
+ */
+export function decideNext(s) {
+  const f = s.feature;
+  const approved = (g) => s.gates?.[g]?.approved === true;
+  // The hotfix pipeline (scout, human approval, ship) lives in its own skill, end to end.
+  const skill = (name) => (s.workType === 'hotfix' ? `/morph-hotfix ${f}` : `/${name} ${f}`);
+
+  switch (s.phase) {
+    case 'plan':
+      return s.slices
+        ? step('gate', `morph-spec gate-check ${f} plan`, 'plano extraído: o gate do plano decide a pausa')
+        : step('plan', `/morph-plan ${f}`, 'sem checks.json: escreva o plan.md e rode plan-check até zero erro');
+
+    case 'uiux':
+      return step('design', `morph-spec gate-check ${f} uiux`, 'complete 1-design/ (morph-uiux) e passe o gate de uiux');
+
+    case 'implement': {
+      if (!s.slices) return step('plan', skill('morph-plan'), 'sem checks.json: plan.md curto (uma fatia) e plan-check até zero erro');
+      if (s.slices.done < s.slices.total) {
+        const ready = readySlices(s.slices);
+        if (!ready.length) {
+          const waiting = s.slices.slices.filter((sl) => sl.status === 'bloqueado').map((sl) => sl.id);
+          if (waiting.length) {
+            return step('decide', 'AskUserQuestion (decisão da fatia)',
+              'relatório BLOQUEADO: decida pelo plano/ADR ou pergunte, e retome o MESMO agente com a resposta — nunca re-despache',
+              { slices: waiting });
+          }
+          return step('blocked', `morph-spec report-check ${f}`, 'fatias pendentes sem dependência satisfeita');
+        }
+        const partial = ready.filter((sl) => sl.status === 'parcial').map((sl) => sl.id);
+        return step('dispatch', skill('morph-apply'),
+          partial.length ? `retome ${partial.join(', ')} (PARCIAL) e despache as prontas` : 'despache as fatias prontas',
+          { slices: ready.map((sl) => sl.id) });
+      }
+      const v = s.verification;
+      if (!v?.status || s.verificationStale === true) {
+        return step('verify', `morph-spec verify ${f}`, v?.status ? 'a árvore andou desde o último verify' : 'todas as fatias relatadas, sem verify');
+      }
+      if (v.status === 'fail') {
+        const streak = s.failStreak ?? 0;
+        if (streak > 0 && streak % FIX_ATTEMPTS === 0) {
+          return step('escalate', 'AskUserQuestion (aceitar/continuar/parar)',
+            `${streak} verifies vermelhos seguidos, nunca uma tentativa a mais por conta própria. `
+            + `aceitar → ${skill('morph-review')} (o verify vermelho pausa o gate: o humano assina lá); `
+            + 'continuar → corrija e rode o verify de novo; parar → encerre aqui. Segue `escalate` até a árvore andar');
+        }
+        return step('fix', `morph-spec verify ${f}`,
+          `corrija pelo feedback do verify e rode de novo (${FIX_ATTEMPTS - (streak % FIX_ATTEMPTS)} tentativa(s) antes de perguntar)`);
+      }
+      return step('review', skill('morph-review'), 'verify verde: Gate 3');
+    }
+
+    case 'review':
+      return approved('review')
+        ? step('finish', `morph-spec finish ${f} --pr|--merge`, 'Gate 3 aprovado: arquiva e integra num passo')
+        : step('review', skill('morph-review'), 'relatórios do Gate 3 e gate-check review');
+
+    default:
+      return step('status', `morph-spec status ${f}`, `fase desconhecida: ${s.phase ?? '—'}`);
+  }
+}
+
+export function formatNext(n) {
+  const slices = n.slices?.length ? ` [${n.slices.join(', ')}]` : '';
+  return `próximo: ${n.action}${slices} → ${n.command} — ${n.reason}`;
+}
+
+/** Facts readable from `hooks/shared`; the CLI adds `verificationStale` (git) on top. Null without feature.json. */
+export function collectNextSignals(featureName, cwd) {
+  const featureDir = join(cwd, '.morph', 'features', featureName);
+  let feature;
+  try {
+    const path = join(featureDir, 'feature.json');
+    if (!existsSync(path)) return null;
+    feature = JSON.parse(readFileSync(path, 'utf8').replace(/^/, ''));
+  } catch {
+    return null;
+  }
+  let phase = 'plan';
+  try { phase = derivePhaseForFeature(featureName, cwd) || 'plan'; } catch {}
+  return {
+    feature: featureName,
+    workType: feature.workType ?? 'feature',
+    worktreePath: feature.worktree?.path ?? null,
+    phase,
+    slices: sliceProgress(featureDir),
+    gates: feature.approvals || feature.approvalGates || {},
+    verification: feature.verification ?? null,
+    failStreak: feature.verifications?.feature?.failStreak ?? 0,
+  };
+}

package/framework/hooks/shared/slice-progress.js

@@ -4,7 +4,10 @@ import { join } from 'path';
 /** `PARCIAL` on the report's first non-blank line, tolerating heading/bold/quote typography. */
 export const PARTIAL_MARKER = /^[\s#>*_]*PARCIAL\b/;
 
-export const SLICE_STATUSES = ['pendente', 'parcial', 'feito'];
+/** `BLOQUEADO`: the slice waits on a decision only the human can make; re-dispatching it repeats the question. */
+export const BLOCKED_MARKER = /^[\s#>*_]*BLOQUEADO\b/;
+
+export const SLICE_STATUSES = ['pendente', 'parcial', 'bloqueado', 'feito'];
 
 export function checksPath(featureDir) {
   return join(featureDir, '2-plan', 'checks.json');
@@ -17,10 +20,11 @@ export function sliceReportPath(featureDir, sliceId) {
 export function sliceStatusFromReport(text) {
   if (text == null) return 'pendente';
   const first = String(text).split(/\r?\n/).find((l) => l.trim() !== '') ?? '';
+  if (BLOCKED_MARKER.test(first)) return 'bloqueado';
   return PARTIAL_MARKER.test(first) ? 'parcial' : 'feito';
 }
 
-/** @returns {{ total, done, partial, pending, slices } | null} null when the checks text is unreadable */
+/** @returns {{ total, done, partial, blocked, pending, slices } | null} null when the checks text is unreadable */
 export function sliceProgressFrom(checksText, readReport) {
   let slices;
   try {
@@ -39,7 +43,14 @@ export function sliceProgressFrom(checksText, readReport) {
       status: sliceStatusFromReport(readReport(s.id)),
     }));
   const count = (status) => out.filter((s) => s.status === status).length;
-  return { total: out.length, done: count('feito'), partial: count('parcial'), pending: count('pendente'), slices: out };
+  return {
+    total: out.length,
+    done: count('feito'),
+    partial: count('parcial'),
+    blocked: count('bloqueado'),
+    pending: count('pendente'),
+    slices: out,
+  };
 }
 
 function readOrNull(path) {
@@ -57,7 +68,7 @@ export function sliceProgress(featureDir) {
 export function readySlices(progress) {
   if (!progress) return [];
   const done = new Set(progress.slices.filter((s) => s.status === 'feito').map((s) => s.id));
-  return progress.slices.filter((s) => s.status !== 'feito' && s.depends.every((d) => done.has(d)));
+  return progress.slices.filter((s) => s.status !== 'feito' && s.status !== 'bloqueado' && s.depends.every((d) => done.has(d)));
 }
 
 // Loose on purpose: a false "complete" costs a read, a false "incomplete"
@@ -94,6 +105,8 @@ export function inspectReport(path, { covers = [] } = {}) {
   const firstLine = body.split('\n').find((l) => l.trim() !== '') ?? '';
   const partial = PARTIAL_MARKER.test(firstLine);
   if (partial) missing.push('partial');
+  const blocked = BLOCKED_MARKER.test(firstLine);
+  if (blocked) missing.push('blocked');
 
-  return { exists: true, complete: missing.length === 0, missing, partial };
+  return { exists: true, complete: missing.length === 0, missing, partial, blocked };
 }

package/framework/hooks/shared/state-writer.js

@@ -4,6 +4,7 @@
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { clearStateCache } from './state-reader.js';
+import { recordGateEvent } from './gate-event.js';
 
 const STATE_FILE = '.morph/state.json';
 const STATE_VERSION = '5.0.0';
@@ -81,10 +82,14 @@ export function setGateApproved(featureName, gate, meta = {}, projectPath) {
       ...(meta.selfAssessed ? { selfAssessed: true } : {}),
     };
     feature.updatedAt = now;
-    return persistFeature(featureName, feature, projectPath);
+    if (!persistFeature(featureName, feature, projectPath)) return false;
   } catch {
     return false;
   }
+  try {
+    recordGateEvent(projectPath, { feature: featureName, gate, step: 'approve', approvedBy: meta.approvedBy || 'manual' });
+  } catch {}
+  return true;
 }
 
 // Stamps identity so a feature born implicitly by a hook is never an anonymous

package/framework/mcp/registry.json

@@ -277,9 +277,39 @@
         "warnings": ["OAuth against your Neon account on first use. The server can delete branches and projects: keep destructive calls behind a human."],
         "setupGuide": "Run: claude mcp add --transport http neon https://mcp.neon.tech/mcp"
       }
+    },
+    "microsoft-learn": {
+      "phases": ["plan", "implement"],
+      "tools": ["microsoft_docs_search", "microsoft_docs_fetch", "microsoft_code_sample_search"],
+      "serverNames": ["microsoft-learn", "plugin_microsoft-docs_microsoft-learn"],
+      "detection": "mcpServers includes microsoft-learn or enabledPlugins includes microsoft-docs",
+      "fallback": "context7, then WebFetch on learn.microsoft.com",
+      "usage": "Official, current .NET 10 / ASP.NET Core / EF Core / Microsoft Agent Framework docs and code samples: search first, fetch the page when the excerpt is cut. Use it for any API the model may know from an older version",
+      "healthCheck": {
+        "toolPattern": "microsoft-learn",
+        "testCall": "Call microsoft_docs_search with query 'EF Core 10 what is new'",
+        "testParams": {
+          "query": "EF Core 10 what is new"
+        },
+        "successIndicator": "Returns Microsoft Learn excerpts with contentUrl",
+        "failureHint": "Microsoft Learn MCP not responding. Re-add it: claude mcp add --transport http microsoft-learn https://learn.microsoft.com/api/mcp"
+      },
+      "install": {
+        "autoInstall": false,
+        "transport": "http",
+        "config": {
+          "type": "http",
+          "url": "https://learn.microsoft.com/api/mcp"
+        },
+        "credentials": [],
+        "prerequisites": [],
+        "stackRelevance": ["dotnet"],
+        "warnings": [],
+        "setupGuide": "Run: claude mcp add --transport http microsoft-learn https://learn.microsoft.com/api/mcp"
+      }
     }
   },
-  "_phaseMatrixNote": "Keys must be the v5 phases from framework/phases.json. The v4 keys 'design' and 'tasks' both collapsed into 'plan'; 'review' was absent entirely, so a project in review resolved to undefined. Stack-scoped MCPs (asaas, neon) stay out of this matrix on purpose — only universal ones are listed.",
+  "_phaseMatrixNote": "Keys must be the v5 phases from framework/phases.json. The v4 keys 'design' and 'tasks' both collapsed into 'plan'; 'review' was absent entirely, so a project in review resolved to undefined. Stack-scoped MCPs (asaas, neon, microsoft-learn) stay out of this matrix on purpose — only universal ones are listed.",
   "phaseMatrix": {
     "plan": ["context7", "graphify"],
     "uiux": ["playwright", "context7", "stitch", "morph-assets"],

package/framework/rules/nextjs-standards.md

@@ -15,7 +15,7 @@ stacks:
 - **frontend-nextjs-data-fetching** (`frontend/nextjs/data-fetching.md`) — Server Component com `BACKEND_API_PREFIX`; Client Component só pelo proxy same-origin com `PROXY_API_PREFIX`. TanStack Query 5 com key factory por feature e `invalidateQueries({ queryKey })`; toda resposta passa por Zod. PROIBIDO: `useEffect(() => fetch…)` e paginar/filtrar a coleção inteira no browser.
 - **frontend-nextjs-forms** (`frontend/nextjs/forms.md`) — react-hook-form + Zod (`zodResolver`) + Field do shadcn via `Controller`; tipo por `z.infer`; nunca `useState` por campo. Submit por `useMutation`, erro em `root`. Edição reusa o schema de criação (`.partial()`). Zod 4: `z.email()`.
 - **frontend-nextjs-state-management** (`frontend/nextjs/state-management.md`) — Estado de servidor no TanStack Query, nunca copiado para `useState`. Página, ordenação, filtros e aba ativa na URL (`searchParams`). Context só para tema, usuário ou locale. NUNCA Zustand/Redux antes de esgotar Server Components + TanStack Query.
-- **frontend-nextjs-testing** (`frontend/nextjs/testing.md`) — Vitest + Testing Library; MSW para API; Playwright para e2e. Teste comportamento, não implementação. Orçamento: um teste por pós-condição + um de regressão por bug; cenários do mesmo comportamento em `it.each`; nada de teste que só confere string de copy.
+- **frontend-nextjs-testing** (`frontend/nextjs/testing.md`) — Vitest + Testing Library; MSW para API; Playwright para e2e. Teste comportamento, não implementação. Orçamento por risco: um teste por cenário com `risco:` + o de regressão do bug, componente sem risco é `leitura`/`e2e`; cenários do mesmo comportamento em `it.each`; nada de teste que só confere string de copy.
 - **frontend-nextjs-nextjs-patterns** (`frontend/nextjs/nextjs-patterns.md`) — Route Handler é BFF: `auth.getSession()` (401 sem sessão) e delega ao .NET; banco NUNCA em route handler. Zod no client e no server (`safeParse`, 400). `strict: true` + `noUncheckedIndexedAccess`; sem `any` em resposta de API. shadcn via `npx shadcn@latest add`.
 - **frontend-nextjs-motion-patterns** (`frontend/nextjs/motion-patterns.md`) — Motion via `motion/react` (nunca `framer-motion` junto). Variants em `motion/variants.ts` com durations/easings de `@/lib/design-tokens`. `useReducedMotion()` obrigatório; o `layout.tsx` raiz segue Server Component. 3–5 momentos de motion por página; cena guiada por scroll é do GSAP, nunca no mesmo elemento.
 - **architecture-code-comments** (`architecture/code-comments.md`) — Padrão é nenhum comentário: renomeie, extraia, tipe ou teste antes. Só o porquê que o código não mostra (invariante, ordem, quirk externo com link), até ~3 linhas. PROIBIDO: história de processo (task, UC, ADR, Gate), repetir o código, XML doc/JSDoc que repete a assinatura, banner, `#region`, código comentado, TODO solto. O hook `comment-guard` bloqueia.

package/framework/schemas/feature.schema.json

@@ -95,6 +95,7 @@
               "additionalProperties": false
             },
             "attempts": { "type": "integer", "minimum": 1 },
+            "failStreak": { "type": "integer", "minimum": 0, "description": "Persisted red verifies in a row, reset to 0 by a green one. Read by `morph-spec next` (decideNext in framework/hooks/shared/next-step.js) to turn the fix loop into an escalation every FIX_ATTEMPTS reds. Absent on entries written before the field existed, which is why it is NOT in required." },
             "updatedAt": { "type": "string", "format": "date-time" }
           },
           "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_use: Use quando for iniciar um novo projeto de LP com o template Umbraco genérico
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.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_use: Use quando o usuário pedir "use /migrate-lp-to-umbraco {projeto}" ou descrever a necessidade de migrar uma LP para Umbraco
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 stacks:
   - umbraco
 ---

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

@@ -4,7 +4,7 @@ description: Executa as fatias do plano de uma feature morph-spec — dispatch p
 version: core
 when_to_use: Use com o gate do plano aprovado, em "use /morph-apply {feature}" ou "implementar feature"
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 ---
 
 # morph-apply
@@ -78,7 +78,7 @@ relatório) está no corpo da persona gerada e chega a todo dispatch sem ser col
 ```
 dispatch Agent (subagent_type: "morph-{id}") with prompt:
 Fatia F{n} — <título>
-cobre: <cada Cn com o texto literal do cenário e a `prova:`>
+cobre: <cada Cn com o texto literal do cenário, a `prova:` e o `risco:`>
 arquivos: <os `arquivos:` da fatia>
 standards: <por id: o digest de `morph-spec standards --find` + as 3-8 regras que ESTA fatia aplica>
 reuso: <as linhas de `## Reuso` que tocam a fatia — conceito, veredito, alvo>
@@ -108,6 +108,7 @@ relatório, não a mensagem** — a mensagem final pode não chegar ou vir resum
 | `ok` | siga |
 | `report-stale` | **não re-despache**: o agente escreveu depois de relatar; leia `observed` e atualize o relatório |
 | `report-incomplete` + `resume` | `PARCIAL` na 1ª linha = a fatia não está pronta — o `report-check` o acusa como `report-incomplete`. Retome o MESMO agente por `SendMessage`, colando `tree.dirty`, `tree.commits` e o que falta |
+| `report-blocked` + `ask-human` | `BLOQUEADO` na 1ª linha = decisão que não é do agente; a pergunta e as opções estão no relatório. **Não re-despache.** Plano ou ADR já decide → decida e registre; senão `AskUserQuestion`. Retome o MESMO agente com a resposta |
 | `report-incomplete` + `complete-degraded` | complete a partir da mensagem, carimbe DEGRADADO e registre a falha no relatório |
 | `work-landed-report-missing` | não re-despache; grave você o relatório, DEGRADADO |
 | `no-work-no-report` / `report-missing-evidence-unknown` | re-despache uma vez; segunda ausência sem trabalho = escale |
@@ -128,10 +129,11 @@ config **antes** do verify: o stamp grava o HEAD, e código ou `config.json` com
 
 Depois `morph-spec verify {feature} --json`, **sem filtro** — nunca recorte o
 verify da feature. `--filter` é do loop do próprio sub-agente; o Gate 3 e o CI rodam a suíte
-inteira. Nó de teste sem `expectedCount`: acrescente `--record-baseline` a ESTA rodada — ela mede e
+inteira. Nó de teste sem `expectedCount`, ou fatia que apagou teste de propósito (limpeza, `morph-spec tests-audit`): acrescente `--record-baseline` a ESTA rodada — ela mede e
 prova de uma vez; nunca um segundo verify só para gravar a baseline. Vermelho: corrija com `verify.feedback` (direto no código, ou re-despachando a fatia dona)
 e rode de novo; **3 tentativas** sem verde → `AskUserQuestion` ("Verify de {feature} vermelho após 3
-tentativas — aceitar com ressalva, continuar tentando, ou parar?").
+tentativas — aceitar com ressalva, continuar tentando, ou parar?"). Quem conta é o `feature.json`:
+`morph-spec next {feature}` devolve `fix` enquanto há tentativa e `escalate` na 3ª vermelha seguida.
 
 **Cenário que julga saída de LLM** (`prova: eval`): a evidência é rodar, não ler código. Com nó
 `runner: "evals"`: `morph-spec verify {feature} --filter {id-do-nó-evals} --skip-e2e --no-persist`

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_use: Use quando chegar "/morph-hotfix {feature}", quando a morph-plan rotear o pedido como workType hotfix, ou quando o usuário disser "produção caiu / hotfix / urgente" a respeito de um incidente
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 ---
 
 # morph-hotfix
@@ -53,8 +53,8 @@ Escreva o `plan.md` mínimo (~25 linhas) numa única escrita: o hotfix nasce com
 
 - `## Problema` — o sintoma em produção, o root cause que o scout localizou e o blast radius.
 - `## Cenários` — dois, sempre:
-  - **C1** — o sintoma ausente: dado o estado que quebrava, quando a ação que falhava, então o resultado certo. `prova: teste` (ou `e2e`).
-  - **C2** — a regressão do blast radius: o que o fix poderia quebrar continua funcionando. `prova: teste`.
+  - **C1** — o sintoma ausente: dado o estado que quebrava, quando a ação que falhava, então o resultado certo. `prova: teste` (ou `e2e`) e `risco: regressão` — o teste do bug real, o único que o hotfix escreve; o `plan-check` recusa o plano sem ele.
+  - **C2** — o blast radius: o que o fix poderia quebrar continua funcionando. `prova: leitura` (o caminho tocado, citado por `arquivo:linha`) ou um teste existente que já o cobre — nunca um teste novo.
 - `## Decisões` com `### Conflitos com o acervo` (`nenhum` vale).
 - `## Fatias` — uma, `### F1 — fix`, com `persona:`, `arquivos:` e `cobre: C1, C2`.
 

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_use: Use quando a máquina estiver 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-invocable: false
-cliVersion: "9.1.0"
+cliVersion: "9.3.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_use: Use quando a tarefa for PRODUZIR imagem ou vídeo por IA (catálogo, marketing, asset de LP) e alguém precisar decidir modelo, prompt e aprovação
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 stacks:
   - dotnet
   - nextjs

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

@@ -4,7 +4,7 @@ description: Leva uma feature do pedido ao plano aprovado — roteia o tipo de t
 version: core
 when_to_use: Use quando uma feature, bug ou chore começar ("/morph-plan {feature}", "vamos planejar X"), ou ao retomar uma feature cujo gate plan ainda não foi aprovado
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 ---
 
 # morph-plan
@@ -66,19 +66,21 @@ Exit ≠ 0 → descarte o mapa e re-despache **uma** vez com as `failures` colad
 
 O `create` já escreveu o esqueleto em `2-plan/plan.md` (leia e preencha; `chore` e `hotfix` nascem com o gate carimbado e criam o arquivo numa única escrita); gramática completa: `morph-spec plan-check --help`. `plan-check` é o único leitor; o que ele não reconhece, ninguém lê.
 
-**Cenários** (`## Cenários`): `- **Cn** — Dado …, quando …, então …`, com `prova:` (`teste` | `e2e` | `eval` | `manual`) **na linha seguinte, sem linha em branco** — linha vazia encerra o cenário.
-- **Observável em teste**: que asserção eu escreveria? Sem resposta, reescreva ou descarte.
+**Cenários** (`## Cenários`): `- **Cn** — Dado …, quando …, então …`, com `prova:` (`teste` | `e2e` | `eval` | `manual` | `leitura`) **na linha seguinte, sem linha em branco** — linha vazia encerra o cenário.
+- **Teste é por risco, não por código novo.** `prova: teste` exige `risco:` (`regra` | `dinheiro` | `contrato` | `concorrência` | `dado` | `regressão`) na linha abaixo: ramo de regra de negócio, valor, contrato externo, corrida, integridade de dado ou o bug real. Sem risco (CRUD, DTO, mapping, wiring, constante, texto, layout) a prova é `leitura` — o verificador fecha citando `arquivo:linha` — ou `e2e` quando o fluxo é o que importa. O `plan-check` recusa `teste` sem `risco:`.
+- **Observável**: que asserção (ou que linha de código) prova? Sem resposta, reescreva ou descarte.
 - **Artefato não é comportamento.** Cenário que cita `grep`, "contém a string", "o binário", "nenhum arquivo", "arquivo/pasta/diretório em" ou glob `**/` descreve o repositório. Tente o efeito em runtime; se o artefato É o entregável, justifique em `> Por que artefato:` logo abaixo (nunca na mesma linha, nunca `> [!note]`).
 - **Saída de LLM** (o que o modelo responde) prova-se por `eval` de runtime, nunca pelo texto do prompt: evidência em `3-implement/evidencias/{Cn}.md`, path listado em `arquivos:` da fatia; com nó `runner: "evals"` (standard `ai-agents-evals-with-cache`) o cenário mora no dataset. No máximo 1 teste de estrutura da fonte do prompt.
 - **"O comando de teste da raiz roda de ponta a ponta"** prova-se pelo `verify {feature}` (o nó `e2e` e o nó de teste `e2e: true` já percorrem a cadeia): nomeie essa rodada como a prova, nunca uma execução avulsa. Precisando mesmo rodar fora dele, numa linha só (o Bash não guarda o env entre chamadas): `eval "$(morph-spec env {feature})" && morph-spec heavy run -- <comando>` — o `COMPOSE_PROJECT_NAME` da feature é o que o `finish` derruba com os volumes. `prova: manual` registra passo e resultado em `3-implement/evidencias/{Cn}.md`.
-- **Orçamento de teste**: um teste por cenário, um de regressão por bug; acima disso, uma linha de porquê. Cenários do mesmo comportamento são linhas de tabela (`[Theory]`/`it.each`); nenhum teste que só fixa texto. O `verify` avisa quando o teste passa de 1,5× a produção.
+- **Orçamento de teste**: um teste por cenário de risco — o cenário é a unidade, nunca a pós-condição nem o componente; variantes são linhas de tabela (`[Theory]`/`it.each`); acima disso, o porquê na linha do cenário. Nenhum teste que só fixa texto, prompt ou constante, nenhum de DTO/mapping, e o mesmo comportamento numa camada só (handler **ou** endpoint). Teste além do orçamento é escopo para o revisor. O `verify` avisa quando o teste passa da produção.
 
 ```markdown
 ## Cenários
 - **C1** — Dado um tenant com `criterion_overrides`, quando ele é publicado, então a publicação é recusada nomeando a chave.
   prova: teste
+  risco: contrato
 - **C2** — Nenhum arquivo em `tenants/**` contém a chave `criterion_overrides`.
-  prova: teste
+  prova: leitura
   > Por que artefato: a chave saiu do contrato; nenhum leitor de runtime a consulta.
 
 ## Fatias
@@ -136,7 +138,7 @@ A pergunta **nomeia a feature**: é por ela que o hook `state-sync` grava a apro
 
 ## 8. Deltas por tipo
 
-- **`bug` (bug-lean):** a varredura roda inteira; a árvore é de repro, diagnóstico e comportamento do sistema, não de negócio; no modo automático, no máximo 1 pergunta de repro, e só se o pedido não deixar claro. `## Problema` traz repro, diagnóstico e causa provável; os cenários são o sintoma ausente e a regressão; `### Conflitos com o acervo` continua presente.
+- **`bug` (bug-lean):** a varredura roda inteira; a árvore é de repro, diagnóstico e comportamento do sistema, não de negócio; no modo automático, no máximo 1 pergunta de repro, e só se o pedido não deixar claro. `## Problema` traz repro, diagnóstico e causa provável; um cenário é o sintoma ausente com `prova: teste` e `risco: regressão` (o `plan-check` recusa bug sem ele) — esse é o teste que fica; `### Conflitos com o acervo` continua presente.
 - **`chore`:** nasce com o gate `plan` carimbado por política. Escreva o plan.md curto numa única escrita (o gate já aprovado congela o arquivo depois de criado): `## Problema`, um ou dois cenários, `## Decisões` só com `### Conflitos com o acervo`, uma fatia. `plan-check` e `Skill(morph-apply)`.
 - **`hotfix`:** é da `morph-hotfix`.
 

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

@@ -4,7 +4,7 @@ description: Conduz o Gate 3 — despacha verificador ∥ revisor (∥ seguranç
 version: core
 when_to_use: Use quando a fase review começar, com todas as fatias com relatório final e o verify da feature verde
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 ---
 
 # morph-review
@@ -32,14 +32,15 @@ Commite o trabalho da feature (`git add <paths>` + `git commit`) e rode
 `morph-spec verify {feature} --ci --json` com `run_in_background`. Ele empurra a branch, espera o run
 e grava o stamp do artefato que o run publicou; sem CI, roda local e diz por quê.
 **Sem `--filter`, sempre**: o Gate 3 roda a suíte inteira. Esta é a única execução de testes do Gate 3 — nenhum agente
-roda a suíte de novo. `repeatOf` no JSON = nada mudou, use aquela rodada; `reason: "stamp-reused"` = sem CI e
-nada fora de `.morph/` andou desde o último verify verde: ele vale, não rode de novo.
+roda a suíte de novo. `repeatOf` no JSON = nada mudou, use aquela rodada; `reason: "stamp-reused"` = nada
+fora de `.morph/` andou desde o último verify verde (local ou CI): ele vale e o CI não roda de novo.
 - **Quando a saída mostrar `CI rodando`, despache (passo 3) sem esperar o fim**: o push e o
   workflow já estão commitados e a foto da árvore não os acusa. Saiu `verify local`: espere o fim
   antes do passo 3 — suíte local e `mutate` disputam a máquina. Exit 2 = trabalho fora de commit.
 - Nó `e2e`: `pass` local → `morph-spec e2e status {feature} --json` → `baseUrl` vai ao verificador.
   `fail` → correção (CI: `gh run view <id> --log-failed`). `skip` → quem classifica é o `gate-check`
-  (`classifyE2eSkip`): dispensa de projeto passa; ambiente, `--skip-e2e` ou razão desconhecida pausam.
+  (`classifyE2eSkip`): dispensa de projeto e `not applicable` (feature sem UI/spec/container no diff e sem
+  `prova: e2e`) passam; ambiente, `--skip-e2e` ou razão desconhecida pausam.
 - `traceability.warnings` do verify vão ao revisor como sinal.
 
 ## 3. Dispatch — verificador ∥ revisor (∥ segurança)
@@ -49,7 +50,8 @@ Anote `base` (merge-base com a default) e `sha` (`git rev-parse HEAD`). Blast ra
 símbolo público do diff, `morph-spec graph affected <símbolo> --prod --json`; sem grafo
 (`no-graph`/`not-found`/`ambiguous`), siga sem o blast radius — o revisor cai para `git grep` — e
 registre a ausência no recado a ele. Cada agente nasce com contexto fresco e **nunca recebe relatório anterior** (ancoragem).
-Despache todos na mesma resposta:
+`chore` tem review leve: só o revisor (∥ segurança, quando exigida) — sem verificador, sem cobertura de
+`Cn`, sem mutação. Despache todos na mesma resposta:
 ```
 dispatch Agent (subagent_type: "morph-verifier", model: {reviewModels.verifier.model}) with prompt:
   feature, base, sha, JSON do verify (nós, e2e, URL) se já terminou, 1-design/mockups.md e
@@ -92,7 +94,8 @@ retomar, despache um novo.
 ## 5. Bloqueadores
 O avaliador também erra: **antes de editar, reverifique cada bloqueador no código** — evidência que
 não se reproduz vira pergunta ao mesmo agente, não correção. Confirmado: corrija (loop da
-`morph-apply`), commite, rode o `verify {feature} --ci` de novo e uma foto `--before-eval` nova.
+`morph-apply`), commite, rode `verify {feature}` local (o stamp verde dele é a prova: um `--ci` depois
+reusa, não roda de novo) e uma foto `--before-eval` nova.
 Retome por `SendMessage` TODO agente exigido, com o `sha` novo e `tree.dirty`/`tree.commits`: quem
 abriu bloqueadores **confirme só os bloqueadores** (retomando o MESMO agente que os abriu); os outros
 julgam só o delta `{sha anterior}..{sha novo}` — o que a correção abriu. `reviewModels.security.required`

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_use: Use quando precisar consultar um standard específico durante a implementação
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 ---
 
 # morph-standards

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

@@ -4,7 +4,7 @@ description: Conduz a fase opcional de UI/UX de uma feature com plano aprovado
 version: core
 when_to_use: Use quando o ramo de design for tomado (morph-spec advance {feature} --design, depois do gate do plano) e antes de /morph-apply
 user-invocable: true
-cliVersion: "9.1.0"
+cliVersion: "9.3.0"
 ---
 
 # morph-uiux
@@ -22,6 +22,7 @@ Entra depois do gate do plano, quando a `morph-plan` §6 decidiu que a feature c
 
 - WCAG AA e todos os estados de componente interativo (default/hover/focus/disabled/loading/error), não só o caminho feliz.
 - Reusa token e componente existentes antes de criar; token novo precisa de justificativa. Sistemas, não telas isoladas.
+- Tarefa principal da tela em até 3 interações, uma ação primária por tela, voltar/cancelar sempre à vista. Erro diz o que fazer a seguir; conteúdo gerado por IA aparece marcado como tal.
 - **Toda tela sai com o checklist de tela preenchido.** O `advance --design` já escreveu `1-design/mockups.md` a partir do template do pacote, a fonte única dos dez itens (tabela `### Checklist de tela` dentro de cada `## Tela:`). "Não se aplica" vale se escrito; `…`, vazio ou "a definir" reprovam. Design sem tela nova ou alterada (só componente ou estilo): apague o `1-design/mockups.md` semeado. É o checklist que faz a lista de 2 000 linhas paginar: o verificador do Gate 3 cobra cada item decidido em `## Checklist de tela`. Tela de dados segue os standards de `admin-app` (lista/tabela, formulário, feedback, estrutura de página); login, onboarding, primeira tela, estado vazio de destaque e sucesso são `brand-moment`.
 - **Conformidade não basta: a régua estética vale junto.** Direção escrita antes de componente (`1-design/direcao.md`: conceito, metáfora, o que torna a tela memorável, o que ela não pode parecer; 2 ou 3 direções para tela nova ou momento de marca), celular desenhado e não derivado, movimento com versão estática digna. A régua é o standard `frontend-design-system-art-direction`.
 - **Toda tela nova ou alterada tem protótipo renderizado e conferido por print.** `1-design/prototipos/{tela}.html` autossuficiente, com os tokens reais do projeto (lidos do CSS de tokens), desktop e celular lado a lado, controles animado/estático/pausar; prints `{tela}-1280.png` e `{tela}-390.png` ao lado, saídos do laço de autocrítica. A `## Tela:` aponta o protótipo na linha `**Protótipo:**`.

package/framework/standards/STANDARDS.json

@@ -966,7 +966,7 @@
         "errorbody": "#rule-2--error-path-tests-assert-the-response-body-not-just-the-status-code",
         "test-budget": "#test-budget"
       },
-      "digest": "Inject TimeProvider (never DateTime.UtcNow / DateOnly.FromDateTime(DateTime.UtcNow) directly in a handler or validator) and fake it with FakeTimeProvider (Microsoft.Extensions.TimeProvider.Testing) in integration tests — deterministic, no midnight-UTC flake, boundary dates (today vs. yesterday) become facts about the fake clock instead of when the suite happens to run. xUnit + WebApplicationFactory error-path tests (400/404/409) must assert the ProblemDetails response BODY (title/detail/violated field or error code), never just the HTTP status code — a status-only assertion lets the wrong validation rule or the wrong error branch pass silently as long as the status matches. Test budget per task: one test per postcondition plus one regression test per bug, more only with a one-line justification in the task; scenarios of the same behavior (edge cases included) are rows of one [Theory], never copied [Fact]s; no test whose only assertion is a copy, config or prose string (that is an analyzer or a publish-time validation, outside the suite count); shared fixtures before new helpers; bugs and pure logic get tests in any order — the implementer runs its own filter once, never red-green cycles nor production mutation (the Gate 3 mutation proof shows the test bites); a surviving mutant is killed by tightening an assertion or adding a row, not by a new test."
+      "digest": "Inject TimeProvider (never DateTime.UtcNow / DateOnly.FromDateTime(DateTime.UtcNow) directly in a handler or validator) and fake it with FakeTimeProvider (Microsoft.Extensions.TimeProvider.Testing) in integration tests — deterministic, no midnight-UTC flake, boundary dates (today vs. yesterday) become facts about the fake clock instead of when the suite happens to run. xUnit + WebApplicationFactory error-path tests (400/404/409) must assert the ProblemDetails response BODY (title/detail/violated field or error code), never just the HTTP status code — a status-only assertion lets the wrong validation rule or the wrong error branch pass silently as long as the status matches. Tests are paid for by risk, not new code: one test per plan scenario with risco: (rule, money, contract, concurrency, data, regression) plus the regression test of the bug fixed, more only with a one-line justification on the scenario; a scenario without risk (CRUD, DTO, mapping, wiring, constants) is prova: leitura and gets no test; one layer per behavior (handler or endpoint, not both); scenarios of the same behavior (edge cases included) are rows of one [Theory], never copied [Fact]s; no test whose only assertion is a copy, config or prose string (that is an analyzer or a publish-time validation, outside the suite count); shared fixtures before new helpers; bugs and risky scenarios get tests in any order — the implementer runs its own filter once, never red-green cycles nor production mutation (the Gate 3 mutation proof shows the test bites); a surviving mutant is killed by tightening an assertion or adding a row, not by a new test."
     },
     {
       "id": "backend-dotnet-vsa-handler-patterns",
@@ -1516,7 +1516,7 @@
         "e2e": "#test-file-co-location",
         "test-budget": "#test-budget"
       },
-      "digest": "Vitest for unit tests, React Testing Library for component tests. Mock next/navigation with vi.mock. Test Server Actions with direct function calls. Use MSW for API mocking in component tests. Playwright for E2E tests against running app. Never test implementation details — test user behavior and output. Test budget per task: one test per postcondition plus one regression test per bug, more only with a one-line justification in the task; scenarios of the same behavior are rows of one it.each, never copied it() blocks; no test whose only assertion is a copy string (lint or publish-time validation instead); shared wrappers, MSW handlers and factories before new helpers; bugs and pure logic get tests in any order — the implementer runs its own filter once, never red-green cycles nor production mutation."
+      "digest": "Vitest for unit tests, React Testing Library for component tests. Mock next/navigation with vi.mock. Test Server Actions with direct function calls. Use MSW for API mocking in component tests. Playwright for E2E tests against running app. Never test implementation details — test user behavior and output. Tests are paid for by risk, not new code: one test per plan scenario with risco: plus the regression test of the bug fixed, more only with a one-line justification on the scenario; a component is not a budget unit — rendering, layout and copy are prova: leitura or e2e; scenarios of the same behavior are rows of one it.each, never copied it() blocks; no test whose only assertion is a copy string (lint or publish-time validation instead); shared wrappers, MSW handlers and factories before new helpers; bugs and risky scenarios get tests in any order — the implementer runs its own filter once, never red-green cycles nor production mutation."
     },
     {
       "id": "frontend-scroll-driven-frame-scrub",

package/framework/standards/STANDARDS.meta.json

@@ -1123,7 +1123,7 @@
         "MCP server",
         "MCP client"
       ],
-      "verifiedAgainst": "Claude Code 2.1.282 MCP tooling — context7, Playwright (as plugin and as a project MCP server); GitHub via `gh` CLI; Neon via its MCP or `neonctl`.",
+      "verifiedAgainst": "Claude Code 2.1.282 MCP tooling — context7, Playwright (as plugin and as a project MCP server); GitHub via `gh` CLI; Neon via its MCP or `neonctl`; Microsoft Learn MCP (`https://learn.microsoft.com/api/mcp`, tools listed by `tools/list` on 2026-10-17).",
       "provedBy": []
     },
     "frontend-admin-app-data-table": {

package/framework/standards/ai-agents/setup.md

@@ -331,6 +331,8 @@ AIAgent instrumented = agent.AsBuilder()
 
 ## 7. What NOT to do (anti-patterns)
 
+`morph-spec stack-scan` cobra três linhas desta tabela no código: Semantic Kernel, hosted agent service e versão flutuante.
+
 | Wrong | Right |
 |-------|-------|
 | `using Microsoft.SemanticKernel` | `using Microsoft.Agents.AI` |

package/framework/standards/backend/dotnet/testing.md

@@ -115,8 +115,12 @@ respectively and the test suite stays green.
 
 ## Test budget
 
-The plan (`morph-plan`) gives each task a budget: **one test per postcondition, plus one
-regression test per bug fixed**. Going above it takes a one-line justification in the task.
+Tests are paid for by **risk, not by new code**. The plan (`morph-plan`) marks each scenario
+with `prova:` and, for a test, a `risco:` (business rule, money, external contract, concurrency,
+data integrity, regression). The budget is **one test per risky scenario, plus the regression test of
+the bug being fixed**; going above it takes a one-line justification on the scenario. A scenario
+without risk — CRUD, DTO, mapping, wiring, constants, layout — is `prova: leitura`: the Gate 3
+verifier proves it by reading the code, and it gets no test.
 
 - **Table before copy.** Scenarios of the same behavior — including its edge cases (null, empty,
   boundary) — are rows of one `[Theory]` (`[InlineData]`/`[MemberData]`), never N `[Fact]` methods
@@ -125,11 +129,13 @@ regression test per bug fixed**. Going above it takes a one-line justification i
   UI copy, tenant config or prose proves the file's version, not behavior. Enforce it with an
   analyzer, a lint rule or a validation at publish time, outside the suite count. The versioned
   prompt case (at most one structural test) is `ai-agents-testing-ai`.
+- **One layer per behavior.** A rule tested in the handler is not tested again through the
+  endpoint or the SQL integration: pick the cheapest layer that bites (wiring is the verifier's).
 - **Shared fixture by default.** Reuse the project's `WebApplicationFactory` fixture, fakes and
   builders. Before writing a new helper, look for the existing one (`morph-spec graph explain
   <Name>`; fallback without a graph: `grep -rn`).
-- **Order is free, proof is not the implementer's:** a bug gets a regression test, and pure logic
-  gets its tests, in whatever order the code comes out. The implementer does not run red→green
+- **Order is free, proof is not the implementer's:** a bug gets a regression test, and a risky
+  scenario gets its test, in whatever order the code comes out. The implementer does not run red→green
   cycles nor mutate production code to watch a test fail; it runs its own filter once before the
   report, and the Gate 3 mutation proof is what shows the test bites.
 - **A surviving mutant** of the Gate 3 mutation proof is killed by tightening an existing assertion