@polymorphism-tech/morph-spec 9.2.0 → 9.4.0

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.2.0"
+cliVersion: "9.4.0"
 ---
 
 # morph-plan
@@ -95,11 +95,11 @@ O `create` já escreveu o esqueleto em `2-plan/plan.md` (leia e preencha; `chore
 
 **Arquitetura**: componentes, fluxo de dados, edge cases **técnicos** e integrações; não repita os cenários.
 
-**Reuso**: tabela `| conceito | veredito | alvo | why |`, veredito `REUSAR` | `ESTENDER` | `CRIAR`. **`CRIAR` exige `why`** — a consulta que respondeu "não existe" (`graph explain X → not-found; grep -rn X → 0`). Conceito de duas features vai para um módulo comum, nunca import cruzado entre slices. O validador `reuse` do `verify` cobra: símbolo novo homônimo de um existente reprova na mesma feature e avisa entre features; `CRIAR` declarado rebaixa a aviso. Conceito sem fatia que o escreva: falta fatia ou o conceito não é desta feature — resolva antes do gate.
+**Reuso**: tabela `| conceito | veredito | alvo | why |`, veredito `REUSAR` | `ESTENDER` | `CRIAR`. **`CRIAR` exige `why`** — a consulta que respondeu "não existe" (`graph explain X → not-found; grep -rn X → 0`). Abstração nova (interface, base, factory, camada) soma ao `why` o segundo uso ou a próxima adição que ela barateia; sem isso é excesso (`architecture-engineering-lens#excess`). Conceito de duas features vai para um módulo comum, nunca import cruzado entre slices. O validador `reuse` do `verify` cobra: símbolo novo homônimo de um existente reprova na mesma feature e avisa entre features; `CRIAR` declarado rebaixa a aviso. Conceito sem fatia que o escreva: falta fatia ou o conceito não é desta feature — resolva antes do gate.
 
 **Fatias** (`### Fn — título`): a unidade de entrega e de relatório (`3-implement/reports/Fn.md`).
 - `persona:` obrigatório — o id sem `morph-`, cujo `domains` cobre a fatia (uma leitura de `agents.json`). Fatia que cria ou altera UI é `ui-designer`, mesmo sem o ramo de design; com `superfície:`, os standards são os daquela chave de `surfaces`.
-- `standards:` — `morph-spec standards --find "<domínio>"` por domínio (o digest decide): os da persona mais o que a fatia exige, sempre `architecture-code-comments` e o de teste do stack; agente MAF soma `--category ai-agents`.
+- `standards:` — `morph-spec standards --find "<domínio>"` por domínio (o digest decide): os da persona mais o que a fatia exige, sempre `architecture-code-comments`, `architecture-engineering-lens` e o de teste do stack; agente MAF soma `--category ai-agents`.
 - `arquivos:` — os paths planejados, testes incluídos, **no máximo 8**: acima disso o sub-agente bate no teto de turnos.
 - `depende:` opcional; `cobre:` lista os Cn — todo cenário é coberto por alguma fatia. Fatias sem `depende:` comum e sem arquivo em comum rodam em paralelo; o `plan-check` imprime as ondas.
 - Cenário que se observa por um artefato de outra fatia (rota, endpoint, componente que ela cria) faz da fatia que o cobre um `depende:` daquela — senão as duas caem na mesma onda e o teste do cenário não tem por onde provar. O `plan-check` não vê de quem é a rota: a regra é sua.

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.2.0"
+cliVersion: "9.4.0"
 ---
 
 # morph-review

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.2.0"
+cliVersion: "9.4.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.2.0"
+cliVersion: "9.4.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

@@ -496,7 +496,7 @@
         "example": "#exemplo-c-completo",
         "content-types": "#datacontent-vs-uricontent"
       },
-      "digest": "Vision em MAF usa ChatMessage multimodal (Microsoft.Extensions.AI): new ChatMessage(ChatRole.User, [new TextContent(pergunta), imagem]) passado a agent.RunAsync. Imagem em URL pública: UriContent(uri, mediaType); arquivo local: DataContent.LoadFromAsync(path), o helper canônico e preferido; bytes já em memória: new DataContent(BinaryData, mediaType). Upload de usuário ou imagem privada usa DataContent, nunca URL temporária (pode expirar); CDN estável usa UriContent. O modelo vem do alias vision no Model Registry, pois nem todo provider suporta visão. Dado tipado: RunAsync<T> com sealed record, nunca regex em response.Text. Proibido: base64 manual, imagem 4K sem resize (tokens cobrados por resolução; ex.: 800px para OCR), vision quando já há texto extraído ou um parser/OCR determinístico basta. PDF: confirme application/pdf no provider."
+      "digest": "Vision em MAF usa ChatMessage multimodal (Microsoft.Extensions.AI): new ChatMessage(ChatRole.User, [new TextContent(pergunta), imagem]) passado a agent.RunAsync. Imagem em URL pública: UriContent(uri, mediaType); arquivo local: DataContent.LoadFromAsync(path), o helper canônico e preferido; bytes já em memória: new DataContent(BinaryData, mediaType). Upload de usuário ou imagem privada usa DataContent, nunca URL temporária (pode expirar); CDN estável usa UriContent. O modelo vem do alias vision no Model Registry, pois nem todo provider suporta visão. Dado tipado: RunAsync<T> com record, nunca regex em response.Text. Proibido: base64 manual, imagem 4K sem resize (tokens cobrados por resolução; ex.: 800px para OCR), vision quando já há texto extraído ou um parser/OCR determinístico basta. PDF: confirme application/pdf no provider."
     },
     {
       "id": "ai-agents-multi-agent-patterns",
@@ -692,7 +692,7 @@
         "type": "#definindo-o-tipo-de-saída",
         "validation": "#validação-pós-call"
       },
-      "digest": "Every agent whose output feeds another system returns a typed record, never free text. Form 1 is RunAsync<T>; Form 2 is ResponseFormat = ChatResponseFormat.ForJsonSchema<T>() in ChatOptions. Type is a sealed record with [Description] on the type and [JsonPropertyName] on every property. Documented limits: ResponseFormat does not accept a primitive or an array at the root (use a wrapper), and in streaming you must build the whole response with ToAgentResponseAsync() before deserialising. Schema validates shape, not semantics — always validate business rules after the call. Do not use temperature as the example of a normal ChatOption."
+      "digest": "Every agent whose output feeds another system returns a typed record, never free text. Form 1 is RunAsync<T>; Form 2 is ResponseFormat = ChatResponseFormat.ForJsonSchema<T>() in ChatOptions. Type is a record with [Description] on the type and [JsonPropertyName] on every property. Documented limits: ResponseFormat does not accept a primitive or an array at the root (use a wrapper), and in streaming you must build the whole response with ToAgentResponseAsync() before deserialising. Schema validates shape, not semantics — always validate business rules after the call. Do not use temperature as the example of a normal ChatOption."
     },
     {
       "id": "ai-agents-sweet-spot",
@@ -801,7 +801,7 @@
         "rules": "#padrões-obrigatórios",
         "cqrs": "#anti-patterns-nunca-fazer-em-vsa"
       },
-      "digest": "Uma slice por operação em Features/{Entity}Feature/{Verb}{Entity}/: Request e Response (sealed records) no mesmo arquivo do Handler, Validator FluentValidation (nenhum em GetAll) e Endpoint `IApiEndpoint` `internal sealed`. O handler implementa o `IHandler<TRequest, TResponse>` próprio, devolve `Result<T>` (erros em `{Entity}Errors`, 1 por feature), injeta `ApplicationDbContext` direto e chama `SaveChangesAsync` nas escritas; IDs com `Guid.CreateVersion7()`, nunca `Guid.NewGuid()`; o endpoint usa `result.Match()`: o sucesso recebe o valor no lambda (nunca `result.Value`) e a falha vira `error.ToHttpResult()` (status pelo `ErrorType`, ProblemDetails), nunca `Results.BadRequest` para todo erro, declarando cada status com `.ProducesProblem`. Decorators Scrutor: Logging -> Validation -> Handler. PROIBIDO: MediatR/IRequest, AggregateRoot, DomainEvent, CQRS formal, Application Service layer, DTOs compartilhados entre features e `IRepository<T>`/`IUnitOfWork` (DbSet já é repository, vira código morto); store dedicado só com justificativa em `plan.md` (`## Decisões`). Não misture VSA com DDD."
+      "digest": "Uma slice por operação em Features/{Entity}Feature/{Verb}{Entity}/: Request e Response (records) no mesmo arquivo do Handler, Validator FluentValidation (nenhum em GetAll) e Endpoint `IApiEndpoint` `internal`. O handler implementa o `IHandler<TRequest, TResponse>` próprio, devolve `Result<T>` (erros em `{Entity}Errors`, 1 por feature), injeta `ApplicationDbContext` direto e chama `SaveChangesAsync` nas escritas; o endpoint usa `result.Match()`: o sucesso recebe o valor no lambda (nunca `result.Value`) e a falha vira `error.ToHttpResult()` (status pelo `ErrorType`, ProblemDetails), nunca `Results.BadRequest` para todo erro, declarando cada status com `.ProducesProblem`. Decorators Scrutor: Logging -> Validation -> Handler. PROIBIDO: MediatR/IRequest, AggregateRoot, DomainEvent, CQRS formal, Application Service layer, DTOs compartilhados entre features e `IRepository<T>`/`IUnitOfWork` (DbSet já é repository, vira código morto); store dedicado só com justificativa em `plan.md` (`## Decisões`). Não misture VSA com DDD."
     },
     {
       "id": "backend-api-validation",
@@ -821,7 +821,7 @@
         "rules": "#validation-patterns",
         "state": "#state-checks-in-the-handler"
       },
-      "digest": "Request/DTO validation in the VSA slice: one sealed `AbstractValidator<TRequest>` (FluentValidation) next to the handler, checking SHAPE only (required, length, range, format, child items via RuleForEach/ChildRules; no DbContext; time rules read an injected TimeProvider inside the rule). The ValidationDecorator runs it before the handler and short-circuits with `Result.Failure(new ValidationError([...]))`; the endpoint maps it with `error.ToHttpResult()` to 400 ProblemDetails with `errors[]` (decorator and conversion in fluent-validation-vsa.md, ValidationError/ErrorHttpMapping in result-pattern.md). Never throw (ValidationException/InvalidOperationException), never validate in the endpoint lambda, never mix DataAnnotations with FluentValidation (minimal APIs have no ModelState). Existence/uniqueness/state checks live in the handler and return typed `{Entity}Errors` (NotFound 404, Conflict 409, Failure 400), never `Result.Failure(\"string\")`. State checks validate what is INVALID, not what is valid, so a new flow (e.g. a free flow that skips PendingPayment) does not break: ordered status enum (Created=0 ... EmailSent=4) with error states at 100+ (Failed=100, Cancelled=101, Refunded=102), blocked by `status >= Completed`, an error-state list, or `status >= Failed`. FORBIDDEN: `if (status != Expected)`, exhaustive switches over valid states, business rules mixed into the state check (keep `RequiresPayment && !IsPaid` separate). Document all flows in plan.md (## Decisões) and test each."
+      "digest": "Request/DTO validation in the VSA slice: one `AbstractValidator<TRequest>` (FluentValidation) next to the handler, checking SHAPE only (required, length, range, format, child items via RuleForEach/ChildRules; no DbContext; time rules read an injected TimeProvider inside the rule). The ValidationDecorator runs it before the handler and short-circuits with `Result.Failure(new ValidationError([...]))`; the endpoint maps it with `error.ToHttpResult()` to 400 ProblemDetails with `errors[]` (decorator and conversion in fluent-validation-vsa.md, ValidationError/ErrorHttpMapping in result-pattern.md). Never throw (ValidationException/InvalidOperationException), never validate in the endpoint lambda, never mix DataAnnotations with FluentValidation (minimal APIs have no ModelState). Existence/uniqueness/state checks live in the handler and return typed `{Entity}Errors` (NotFound 404, Conflict 409, Failure 400), never `Result.Failure(\"string\")`. State checks validate what is INVALID, not what is valid, so a new flow (e.g. a free flow that skips PendingPayment) does not break: ordered status enum (Created=0 ... EmailSent=4) with error states at 100+ (Failed=100, Cancelled=101, Refunded=102), blocked by `status >= Completed`, an error-state list, or `status >= Failed`. FORBIDDEN: `if (status != Expected)`, exhaustive switches over valid states, business rules mixed into the state check (keep `RequiresPayment && !IsPaid` separate). Document all flows in plan.md (## Decisões) and test each."
     },
     {
       "id": "backend-database-postgresql-database",
@@ -883,7 +883,7 @@
         "decorator": "#validationdecorator-pattern",
         "conversion": "#fluentvalidation-to-validationerror-conversion"
       },
-      "digest": "One sealed `AbstractValidator<TRequest>` per request DTO (FluentValidation 12), in the same feature folder as the handler; no `RuleSet` grouping and no `IValidateOptions<T>`. Never validate request shape inside the handler or endpoint (existence/state checks do belong in the handler): `ValidationDecorator<TRequest, TResponse>` wraps every `IHandler` via Scrutor, collects all `IValidator<TRequest>`, runs them in parallel (`Task.WhenAll`) and on failure short-circuits to `Result.Failure(ValidationError)` (an array of `Error.Validation(code, message)`), supporting both `Result` and `Result<T>`. Never throw `ValidationException`. In Program.cs call `AddValidatorsFromAssembly()` BEFORE `AddHandlersFromAssembly()` so the decorator can resolve validators. Always give user-facing `.WithMessage()` text. Inject `TimeProvider` instead of reading `DateTime.UtcNow` and read it INSIDE the rule (`LessThanOrEqualTo(_ => timeProvider.GetUtcNow().Year)`), so the year is evaluated per validation (a value captured in the constructor goes stale in a singleton/cached validator; AddValidatorsFromAssembly defaults to Scoped) and stays testable with `FakeTimeProvider`."
+      "digest": "One `AbstractValidator<TRequest>` per request DTO (FluentValidation 12), in the same feature folder as the handler; no `RuleSet` grouping and no `IValidateOptions<T>`. Never validate request shape inside the handler or endpoint (existence/state checks do belong in the handler): `ValidationDecorator<TRequest, TResponse>` wraps every `IHandler` via Scrutor, collects all `IValidator<TRequest>`, runs them in parallel (`Task.WhenAll`) and on failure short-circuits to `Result.Failure(ValidationError)` (an array of `Error.Validation(code, message)`), supporting both `Result` and `Result<T>`. Never throw `ValidationException`. In Program.cs call `AddValidatorsFromAssembly()` BEFORE `AddHandlersFromAssembly()` so the decorator can resolve validators. Always give user-facing `.WithMessage()` text. Inject `TimeProvider` instead of reading `DateTime.UtcNow` and read it INSIDE the rule (`LessThanOrEqualTo(_ => timeProvider.GetUtcNow().Year)`), so the year is evaluated per validation (a value captured in the constructor goes stale in a singleton/cached validator; AddValidatorsFromAssembly defaults to Scoped) and stays testable with `FakeTimeProvider`."
     },
     {
       "id": "backend-dotnet-result-pattern",
@@ -988,7 +988,7 @@
         "endpoint": "#complete-endpoint-example",
         "registration": "#programcs-di-registration-order"
       },
-      "digest": "Each VSA feature is a slice in `Features/{Feature}/{UseCase}/` with 5 files: Request, Response (sealed records, may be inline), Handler, Validator, Endpoint; feature errors in `{Feature}Errors.cs` (`Error.NotFound/Conflict/Failure`). Handlers implement `IHandler<TRequest, TResponse>` (resolved from DI; NOT MediatR, decorators via Scrutor), are `sealed class` with primary constructors, inject `ApplicationDbContext` directly (`DbSet<T>` is the repository, `DbContext` the unit of work: no service layer, no `IRepository<T>`/`IUnitOfWork`), use `Guid.CreateVersion7()` (never `Guid.NewGuid()`), pass `CancellationToken` everywhere and return `Result<T>` instead of throwing for expected failures. Endpoints are `internal sealed` `IApiEndpoint`, only map HTTP and call `Match()`: success lambda receives the value (never read `.Value`), failure is `error.ToHttpResult()` (status by `ErrorType`, never `Results.BadRequest` for every error), with `.ProducesProblem` per failure status. Raw SQL or a dedicated hand-written store (outbox, lease) only with a `plan.md` (`## Decisões`) justification."
+      "digest": "Each VSA feature is a slice in `Features/{Feature}/{UseCase}/` with 5 files: Request, Response (records, may be inline), Handler, Validator, Endpoint; feature errors in `{Feature}Errors.cs` (`Error.NotFound/Conflict/Failure`). Handlers implement `IHandler<TRequest, TResponse>` (resolved from DI; NOT MediatR, decorators via Scrutor), inject `ApplicationDbContext` directly (`DbSet<T>` is the repository, `DbContext` the unit of work: no service layer, no `IRepository<T>`/`IUnitOfWork`), return `Result<T>` instead of throwing for expected failures. Endpoints are `internal` `IApiEndpoint`, only map HTTP and call `Match()`: success lambda receives the value (never read `.Value`), failure is `error.ToHttpResult()` (status by `ErrorType`, never `Results.BadRequest` for every error), with `.ProducesProblem` per failure status. Raw SQL or a dedicated hand-written store (outbox, lease) only with a `plan.md` (`## Decisões`) justification."
     },
     {
       "id": "backend-integrations-asaas-asaas-api",
@@ -1028,7 +1028,7 @@
         "jobs": "#job-types",
         "retry": "#retry--error-handling"
       },
-      "digest": "Hangfire 1.8.25 on .NET 10, only with a real reason (survive restarts, schedules, deferred retries) recorded in plan.md (## Decisões); work that fits in the request stays in the slice handler. Storage is Neon Postgres via Hangfire.PostgreSql 1.21.1 with `UsePostgreSqlStorage(o => o.UseNpgsqlConnection(cs))` (the string overloads are [Obsolete]) and `HangfireConnection` on the direct/unpooled endpoint (schema install at startup is a migration, which Neon routes to the direct string; EnableLongPolling uses LISTEN/NOTIFY, unsupported by Neon's PgBouncer transaction mode); reference Newtonsoft.Json 13.0.4 explicitly or restore fails with NU1903 (Hangfire.Core pulls 11.0.1). A job is a thin sealed class in the slice that calls the slice handler (`IHandler<TRequest, Result>`); no XService layer. Hangfire.AspNetCore's AspNetCoreJobActivator opens a DI scope per job, so inject the ApplicationDbContext/handler directly (IDbContextFactory only for parallel work inside one job); never capture request-scoped services into Enqueue. Jobs are idempotent (check state, return). Expected failures come back as Result and the job logs and completes; unexpected ones are the exceptions EF/HttpClient already throw, uncaught, which `[AutomaticRetry(Attempts = 3, DelaysInSeconds = [60, 300, 900])]` retries; no try/catch, no manual retry loops. API: `BackgroundJob.Enqueue<TJob>(j => j.RunAsync(id, CancellationToken.None))`, `Schedule`, `RecurringJob.AddOrUpdate` with a stable id and cron (UTC), `ContinueJobWith`. Dashboard: IDashboardAuthorizationFilter requiring authenticated Admin, dev bypass only via IHostEnvironment.IsDevelopment() (never Request.Host, which the client controls)."
+      "digest": "Hangfire 1.8.25 on .NET 10, only with a real reason (survive restarts, schedules, deferred retries) recorded in plan.md (## Decisões); work that fits in the request stays in the slice handler. Storage is Neon Postgres via Hangfire.PostgreSql 1.21.1 with `UsePostgreSqlStorage(o => o.UseNpgsqlConnection(cs))` (the string overloads are [Obsolete]) and `HangfireConnection` on the direct/unpooled endpoint (schema install at startup is a migration, which Neon routes to the direct string; EnableLongPolling uses LISTEN/NOTIFY, unsupported by Neon's PgBouncer transaction mode); reference Newtonsoft.Json 13.0.4 explicitly or restore fails with NU1903 (Hangfire.Core pulls 11.0.1). A job is a thin class in the slice that calls the slice handler (`IHandler<TRequest, Result>`); no XService layer. Hangfire.AspNetCore's AspNetCoreJobActivator opens a DI scope per job, so inject the ApplicationDbContext/handler directly (IDbContextFactory only for parallel work inside one job); never capture request-scoped services into Enqueue. Jobs are idempotent (check state, return). Expected failures come back as Result and the job logs and completes; unexpected ones are the exceptions EF/HttpClient already throw, uncaught, which `[AutomaticRetry(Attempts = 3, DelaysInSeconds = [60, 300, 900])]` retries; no try/catch, no manual retry loops. API: `BackgroundJob.Enqueue<TJob>(j => j.RunAsync(id, CancellationToken.None))`, `Schedule`, `RecurringJob.AddOrUpdate` with a stable id and cron (UTC), `ContinueJobWith`. Dashboard: IDashboardAuthorizationFilter requiring authenticated Admin, dev bypass only via IHostEnvironment.IsDevelopment() (never Request.Host, which the client controls)."
     },
     {
       "id": "backend-integrations-neon-auth-neon-auth",
@@ -1857,7 +1857,7 @@
         "reais": "#exemplos-reais",
         "regras": "#regras"
       },
-      "digest": "A tool that carries business rule keeps apart three things that change for different reasons: the RULE (sealed class XOps(...), primary constructor, explicit AddScoped; never *Service, which MORPH.md bans as a layer between handler and data), the sentence the MODEL reads, and the EFFECT a human sees. Each Ops method returns a typed outcome (abstract record XDesfecho, one sealed record per case); the model-facing text (description, refusal, self-correction, success, the ToolUnavailable decision) lives in the adapter, in public static object Render(XDesfecho), while human text delivered by code (task body, note, ack) stays in Ops because it is an effect. Checkable by grep: Ops names no tool and instructs no model. The adapter (AIFunctionFactory.Create) only builds the typed request, calls Ops and returns Render: zero rule, not a line count, and a long dynamic description stays byte for byte. Two test layers: Ops tests assert outcome, calls and order on the fake, never text; contract tests assert Render's exact literal and .Description, with a golden of name, description and schema per real tenant. A neutral refactor is proven before any test moves: a proof commit with the old suite untouched and green (offline evals included), then the migration, with mutation run only against the new tests. \"Already covered\" needs proof assertion by assertion (11 of 22 such claims had lost one); the tests left at the origin must be identical to the base; mutation on the new tests found rules the old suite never protected. The C# blocks were compiled against the pin and the three xunit tests run."
+      "digest": "A tool that carries business rule keeps apart three things that change for different reasons: the RULE (class XOps(...), explicit AddScoped; never *Service, which MORPH.md bans as a layer between handler and data), the sentence the MODEL reads, and the EFFECT a human sees. Each Ops method returns a typed outcome (abstract record XDesfecho, one record per case); the model-facing text (description, refusal, self-correction, success, the ToolUnavailable decision) lives in the adapter, in public static object Render(XDesfecho), while human text delivered by code (task body, note, ack) stays in Ops because it is an effect. Checkable by grep: Ops names no tool and instructs no model. The adapter (AIFunctionFactory.Create) only builds the typed request, calls Ops and returns Render: zero rule, not a line count, and a long dynamic description stays byte for byte. Two test layers: Ops tests assert outcome, calls and order on the fake, never text; contract tests assert Render's exact literal and .Description, with a golden of name, description and schema per real tenant. A neutral refactor is proven before any test moves: a proof commit with the old suite untouched and green (offline evals included), then the migration, with mutation run only against the new tests. \"Already covered\" needs proof assertion by assertion (11 of 22 such claims had lost one); the tests left at the origin must be identical to the base; mutation on the new tests found rules the old suite never protected. The C# blocks were compiled against the pin and the three xunit tests run."
     },
     {
       "id": "frontend-design-system-art-direction",
@@ -1879,6 +1879,53 @@
         "prototype": "#section-7-prototype-and-self-review"
       },
       "digest": "Order beats talent: before any component of a new or changed screen, write 1-design/direcao.md with the concept in one sentence, the visual metaphor, what makes it memorable, and what it must NOT look like. New screens and brand moments (login, onboarding, first screen, empty state, success) explore 2-3 DISTINCT directions and recommend one with a product reason. Avoid template tells (raw shadcn look, white card centered on gray, generic icon list, default fonts, flat backgrounds, mobile as stacked desktop, decorative fade-ins, made-up numbers); three or more means raise it. Mobile is composed at 390px on its own (bottom sheet, thumb zone, 44px targets). Motion tells something with the lightest tool (CSS keyframes > scroll-driven CSS > Framer Motion > GSAP), transform/opacity only, and a composed reduced-motion version. Prove it in 1-design/prototipos/{screen}.html with the project REAL tokens, screenshotted at 1280 and 390 and revised until it passes."
+    },
+    {
+      "id": "architecture-engineering-lens",
+      "name": "engineering lens",
+      "path": "architecture/engineering-lens.md",
+      "category": "architecture",
+      "subcategory": null,
+      "tags": [
+        "architecture",
+        "clean-code",
+        "review"
+      ],
+      "stacks": [
+        "*"
+      ],
+      "anchors": {
+        "fragility": "#fragilidade",
+        "dead-code": "#código-morto",
+        "excess": "#excesso",
+        "readability": "#legibilidade",
+        "extensibility": "#extensibilidade",
+        "ai-vs-code": "#ia-e-código",
+        "git": "#git",
+        "review-blockers": "#o-que-bloqueia-no-gate-3"
+      },
+      "digest": "Write for whoever inherits the repo tomorrow: the project convention beats taste, the simplest thing that works beats the general one, fix the root cause. Fragility: no swallowed catch, handle null/absence from boundaries (HTTP, DB, file, LLM), no hidden order dependency, no strict parser on real data, no blind guard, no test that passes without proving the rule. Dead code: a symbol, endpoint, flag, config or table without a real consumer goes, and so does commented-out code; two paths doing the same thing become one. Excess: no abstraction without a second use today, no pass-through layer, no speculative config, no reinvented stdlib; a plan CREATE of an abstraction names the second use or the next addition it makes cheaper. Readability: descriptive searchable domain names, nouns for classes and verbs for methods, small single-purpose functions, at most 3 parameters, no boolean flag that forks the method (two methods), no hidden side effect, positive conditionals, repeated literals become constants. Extensibility: the next likely addition touches few files and no scattered switch. AI: an unbreakable rule stays in code (ai-agents-guardrails); hand-written NL classification may become structured output only when measured by eval. Git: branch morph/{f}; Conventional Commits <type>(<scope>): <subject>, enforced by the conventional-commit hook. Gate 3 blocks only what the DIFF introduced: swallowed exception, boolean flag parameter, hidden side effect, symbol/flag/config without consumer or commented-out code, abstraction without second use nor plan why, repeated magic literal in a comparison; everything else is a note."
+    },
+    {
+      "id": "backend-dotnet-analyzers",
+      "name": "analyzers",
+      "path": "backend/dotnet/analyzers.md",
+      "category": "backend",
+      "subcategory": "dotnet",
+      "tags": [
+        "backend",
+        "dotnet",
+        "analyzers"
+      ],
+      "stacks": [
+        "dotnet"
+      ],
+      "anchors": {
+        "files": "#arquivos",
+        "rules": "#o-que-cada-regra-compra",
+        "not-a-rule": "#o-que-não-é-regra"
+      },
+      "digest": "Rules with a reason that must never break are build errors, not prose: three files at the solution root, no .csproj change. Directory.Build.props adds Microsoft.CodeAnalysis.BannedApiAnalyzers 5.6.0 (PrivateAssets=all), BannedSymbols.txt as AdditionalFiles and morph.globalconfig as GlobalAnalyzerConfigFiles (with Central Package Management the version goes to Directory.Packages.props). BannedSymbols.txt bans M:System.Guid.NewGuid (use Guid.CreateVersion7(): time-ordered, does not fragment the Postgres PK index). morph.globalconfig sets RS0030 and CA2016 (a CancellationToken received and not forwarded) to error. A new banned API is one BannedSymbols.txt line with the reason after the semicolon, never a prose rule. sealed, primary constructors, var, expression bodies and using order are taste: neither prose nor analyzer; follow the neighbouring file."
     }
   ]
 }

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": {
@@ -1223,6 +1223,34 @@
       ],
       "verifiedAgainst": "the `login-ciclo-do-produto` design round (2026-10-06): a correct, plain design was rejected; a second round with a written direction, an HTML prototype and a screenshot self-review was approved on first sight.",
       "provedBy": []
+    },
+    "architecture-engineering-lens": {
+      "aliases": [
+        "clean code",
+        "código limpo",
+        "código morto",
+        "dead code",
+        "fragilidade",
+        "excesso",
+        "extensibilidade",
+        "flag argument",
+        "conventional commits"
+      ],
+      "verifiedAgainst": "C#, TypeScript e JavaScript (convenção de linguagem, sem pacote externo); Conventional Commits 1.0.0.",
+      "provedBy": []
+    },
+    "backend-dotnet-analyzers": {
+      "aliases": [
+        "analyzer",
+        "roslyn analyzer",
+        "banned api",
+        "BannedSymbols",
+        "Guid.NewGuid",
+        "CreateVersion7",
+        "CA2016"
+      ],
+      "verifiedAgainst": ".NET SDK 10.0.402, Microsoft.CodeAnalysis.BannedApiAnalyzers 5.6.0 (sonda: `Guid.NewGuid()` → erro RS0030, token não repassado → erro CA2016, código conforme → 0 erros).",
+      "provedBy": []
     }
   },
   "sharedAliases": {

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/architecture/engineering-lens.md

@@ -0,0 +1,100 @@
+# Lente de engenharia — código para quem herda amanhã
+
+> **Scope:** universal
+> **Layer:** 0 (resumo injetado pelas rules `csharp-standards` (`**/*.cs`, `**/*.csproj`) e `nextjs-standards` (`**/*.ts`, `**/*.tsx`); texto completo sob demanda via `morph-spec standards --find`)
+> **Keywords:** clean code, código limpo, fragilidade, código morto, excesso, legibilidade, extensibilidade, flag booleana, efeito colateral, conventional commits
+> **Load When:** escrevendo, planejando ou revisando código em qualquer stack
+
+**Verified against:** C#, TypeScript e JavaScript (convenção de linguagem, sem pacote externo); Conventional Commits 1.0.0. Last-verified: 2026-10-18.
+
+---
+
+## Quem herda amanhã
+
+Escreva para quem abre o repo amanhã e precisa entregar uma feature na semana seguinte. A
+convenção que o projeto já usa vence o seu gosto. O mais simples que resolve vence o mais geral.
+Bug se corrige na causa raiz, nunca no sintoma.
+
+## Fragilidade
+
+Código que quebra fácil:
+
+- `catch` vazio, ou que só loga e segue como se nada tivesse acontecido.
+- Null ou ausência vindo de fronteira (HTTP, banco, arquivo, LLM) sem tratamento.
+- Dependência de ordem implícita: método que só funciona se outro rodou antes.
+- Parser estrito diante de dado real (campo opcional tratado como obrigatório, enum fechado para
+  valor externo).
+- Guard cego: a checagem e o dado saem do mesmo serializador, então ela nunca falha.
+- Teste que passa sem provar a regra (ver `backend-dotnet-testing` / `frontend-nextjs-testing`).
+
+## Código morto
+
+Símbolo, endpoint, flag, config ou tabela sem consumidor real sai. Feature começada e largada
+sai. Dois caminhos que fazem a mesma coisa viram um. Quando "X só é usado por Y", pergunte para
+quê Y existe: muitas vezes os dois saem. Código comentado sai, porque o git guarda o antigo.
+
+## Excesso
+
+- Abstração (interface, factory, base class, strategy) sem um segundo uso hoje.
+- Camada que só repassa a chamada.
+- Config ou parâmetro para um caso que ninguém pediu (o "e se um dia eu quiser voar com o carro":
+  construa as asas quando for voar).
+- Stdlib, plataforma ou dependência já instalada reinventada à mão.
+
+No plano, todo CRIAR de abstração diz no `why` o segundo uso ou a próxima adição que ela barateia.
+
+## Legibilidade
+
+- **Nomes:** descritivos, pronunciáveis, buscáveis, na linguagem do domínio. Distinção com
+  significado (`sourceAccount`/`targetAccount`, nunca `account1`/`account2`). Sem prefixo de tipo
+  nem caractere especial. Classe é substantivo, método é verbo, e um padrão aparece no nome
+  (`InvoiceFactory`). Um idioma por identificador.
+- **Funções:** pequenas, com um objetivo só. Poucos parâmetros (passou de 3, agrupe num tipo).
+  Sem efeito colateral fora do próprio objeto que o nome não anuncie.
+- **Sem flag booleana que bifurca o método** — são dois métodos:
+
+```ts
+// ruim
+sendInvoice(invoice, true);
+// bom
+sendInvoiceByEmail(invoice);
+sendInvoiceByWhatsApp(invoice);
+```
+
+- **Condicional positiva:** `if (order.isEmpty)` em vez de `if (!order.hasItems)`; o `!` some na leitura.
+- **Literal repetido vira constante** (detalhe em `architecture-code-comments`).
+- **Estrutura:** por feature/slice (`architecture-vertical-slice-vertical-slice`); variável declarada
+  perto do uso; funções de cima para baixo, a chamadora antes da chamada; funções afins juntas; sem
+  alinhamento horizontal; formatação pelo formatter do projeto.
+- **Comentários:** `architecture-code-comments` é a regra única.
+
+## Extensibilidade
+
+A próxima adição provável (uma skill nova, um campo novo de config refletido na tela, um provider
+novo) deve tocar poucos arquivos e nenhum `switch` espalhado. Se exige editar N lugares que precisam
+concordar, o atrito é o registro que falta, não a falta de uma camada genérica.
+
+## IA e código
+
+Regra que nunca pode ser quebrada fica em código, nunca vira prompt (`ai-agents-guardrails`). O
+inverso também vale: regex, heurística ou árvore de `if` que classifica linguagem natural é candidata
+a structured output, e a troca só entra medida por eval (`ai-agents-evals-with-cache`).
+
+## Git
+
+A branch é `morph/{f}`, criada pelo CLI. Commits seguem Conventional Commits:
+`<tipo>(<escopo>): <assunto>`, com o tipo em `feat`, `fix`, `refactor`, `test`, `chore`, `docs`,
+`perf`, `ci`, `build`, `style` ou `revert`. O hook `conventional-commit` recusa outra forma.
+
+## O que bloqueia no Gate 3
+
+Só o que o **diff introduziu**. O que já existia no arquivo vira nota.
+
+1. `catch` que engole a exceção.
+2. Flag booleana que bifurca o método.
+3. Efeito colateral escondido: o método muda estado alheio e o nome não diz.
+4. Símbolo, flag ou config sem consumidor, ou código comentado.
+5. Abstração ou camada sem segundo uso e sem `why` no plano.
+6. Literal mágico repetido em comparação.
+
+O resto (nome, tamanho, ordem, "eu faria diferente") é nota.

package/framework/standards/architecture/vertical-slice/vertical-slice.md

@@ -380,20 +380,18 @@ app.MapApiEndpoints();
 | Errors class | `{Entity}Errors` | `BookErrors` (static, shared por feature) |
 | DTO record (GetAll) | `{Entity}Dto` | `BookDto` |
 | API tag constant | `ApiTags.{Entities}` | `ApiTags.Books` |
-| Entity class | `{Entity}` (`sealed`) | `Book` |
+| Entity class | `{Entity}` | `Book` |
 
 ---
 
 ## Padrões Obrigatórios
 
 1. **Handler records no mesmo arquivo**: `Request` e `Response` são declarados no mesmo arquivo `.cs` que o `Handler`.
-2. **`sealed` em tudo**: handlers, endpoints, validators, request/response records usam `sealed`.
-3. **`Guid.CreateVersion7()`** para gerar IDs (não `Guid.NewGuid()`).
-4. **`result.Match()`** nos endpoints — o sucesso recebe o valor no lambda (nunca ler `result.Value`) e a falha vira `error.ToHttpResult()` (status pelo `ErrorType`, nunca `Results.BadRequest` para todo erro).
-5. **IApiEndpoint `internal sealed`** — endpoints não são públicos.
-6. **`{Entity}Errors` compartilhado** por todas as operações da feature (1 arquivo por feature, não por slice).
-7. **`ApplicationDbContext` direto no slice**: CRUD por chave via `DbSet<T>`; queries específicas (joins, projeção, paginação) via LINQ no handler. Nunca uma Application Service layer entre handler e dados; nunca repository genérico (`IRepository<T>`/`IUnitOfWork`).
-8. **`SaveChangesAsync()`** explícito em operações de escrita (Create, Update, Delete).
+2. **`result.Match()`** nos endpoints — o sucesso recebe o valor no lambda (nunca ler `result.Value`) e a falha vira `error.ToHttpResult()` (status pelo `ErrorType`, nunca `Results.BadRequest` para todo erro).
+3. **IApiEndpoint `internal`** — endpoints não são públicos.
+4. **`{Entity}Errors` compartilhado** por todas as operações da feature (1 arquivo por feature, não por slice).
+5. **`ApplicationDbContext` direto no slice**: CRUD por chave via `DbSet<T>`; queries específicas (joins, projeção, paginação) via LINQ no handler. Nunca uma Application Service layer entre handler e dados; nunca repository genérico (`IRepository<T>`/`IUnitOfWork`).
+6. **`SaveChangesAsync()`** explícito em operações de escrita (Create, Update, Delete).
 9. **Sem validator em GetAll** — GetAllBooksHandler não tem validator (sem parâmetros para validar).
 
 ---
@@ -402,7 +400,7 @@ app.MapApiEndpoints();
 
 | Anti-pattern | Por quê não |
 |--------------|-------------|
-| `AggregateRoot` | VSA não usa DDD — entidade simples com `sealed class` |
+| `AggregateRoot` | VSA não usa DDD — entidade simples |
 | `DomainEvent` | VSA não tem Domain Events — reações são handlers separados |
 | `MediatR` / `IRequest` / `IRequestHandler` | Substituído por `IHandler<TRequest, TResponse>` próprio |
 | DTOs compartilhados entre features | Cada slice define seus próprios records |

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

@@ -0,0 +1,59 @@
+# Analyzers .NET — o build cobra, a prosa não repete
+
+> **Scope:** dotnet
+> **Layer:** 0 (resumo injetado pela rule `csharp-standards` (`**/*.cs`, `**/*.csproj`); o `stack-scan` acusa o projeto sem estes arquivos)
+> **Keywords:** analyzer, roslyn, BannedApiAnalyzers, BannedSymbols, globalconfig, Guid.NewGuid, CreateVersion7, CancellationToken, CA2016, RS0030
+> **Load When:** projeto .NET sem `BannedSymbols.txt`, ou o build acusou RS0030/CA2016
+
+**Verified against:** .NET SDK 10.0.402, Microsoft.CodeAnalysis.BannedApiAnalyzers 5.6.0 (sonda: `Guid.NewGuid()` → erro RS0030, token não repassado → erro CA2016, código conforme → 0 erros). Last-verified: 2026-10-18.
+
+---
+
+Regra de código que tem motivo e nunca pode ser quebrada vira **erro de build**, não frase que o
+agente relê a cada sessão. Estes três arquivos na raiz da solution bastam; nenhum `.csproj` muda.
+
+## Arquivos
+
+`Directory.Build.props` (se já existe, some o `ItemGroup` ao dele):
+
+```xml
+<Project>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="5.6.0" PrivateAssets="all" />
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)BannedSymbols.txt" />
+    <GlobalAnalyzerConfigFiles Include="$(MSBuildThisFileDirectory)morph.globalconfig" />
+  </ItemGroup>
+</Project>
+```
+
+Com Central Package Management (`Directory.Packages.props`), a versão vai lá e o
+`PackageReference` fica sem `Version`.
+
+`BannedSymbols.txt`:
+
+```text
+M:System.Guid.NewGuid;Use Guid.CreateVersion7(): ordenado, nao fragmenta o indice da PK
+```
+
+`morph.globalconfig`:
+
+```ini
+is_global = true
+dotnet_diagnostic.RS0030.severity = error
+dotnet_diagnostic.CA2016.severity = error
+```
+
+## O que cada regra compra
+
+| Diagnóstico | Bloqueia | Por quê |
+|---|---|---|
+| RS0030 | `Guid.NewGuid()` | UUID v4 é aleatório: PK nele fragmenta o índice B-tree do Postgres a cada insert; `Guid.CreateVersion7()` é ordenado no tempo |
+| CA2016 | método que recebe `CancellationToken` e não o repassa | requisição cancelada continua segurando conexão do banco e chamada ao LLM |
+
+API nova para banir entra como linha no `BannedSymbols.txt` (formato `M:`/`T:`/`P:` com a
+mensagem depois do `;`), com o porquê na mensagem. Nunca uma regra nova em prosa.
+
+## O que não é regra
+
+`sealed`, primary constructor, `var`, expression-bodied member e ordem de `using` são gosto: nem
+prosa nem analyzer. Siga o arquivo vizinho, e o formatter do projeto decide a forma.

package/framework/standards/backend/dotnet/vsa-handler-patterns.md

@@ -11,7 +11,7 @@
 
 ## Overview
 
-Each feature in VSA is a self-contained slice with 5 files in a feature folder. Handlers implement `IHandler<TRequest, TResponse>` (not MediatR). Dependencies use primary constructors. The data path is `Handler -> ApplicationDbContext` — no service layer, no generic repository in between.
+Each feature in VSA is a self-contained slice with 5 files in a feature folder. Handlers implement `IHandler<TRequest, TResponse>` (not MediatR). The data path is `Handler -> ApplicationDbContext` — no service layer, no generic repository in between.
 
 ---
 
@@ -108,11 +108,8 @@ public sealed class CreateBookHandler(
 
 ### Key Patterns
 
-- **`sealed class`** — handlers are never inherited
-- **`sealed record`** — DTOs are immutable value types
-- **Primary constructors** — `(ApplicationDbContext db)` replaces field + constructor boilerplate
-- **`Guid.CreateVersion7()`** — time-sortable, index-friendly UUID (not `Guid.NewGuid()`)
-- **`CancellationToken`** — passed through every async call
+- **`record`** — DTOs are immutable value types
+- **`Guid.CreateVersion7()` and a forwarded `CancellationToken`** — enforced by the build (`backend-dotnet-analyzers`), not by review
 - **`Result<T>` return** — never throw for expected failures
 
 ---
@@ -149,7 +146,7 @@ internal sealed class CreateBookEndpoint : IApiEndpoint
 
 ### Endpoint Conventions
 
-- **`internal sealed`** — endpoints are not public API
+- **`internal`** — endpoints are not public API
 - **`IApiEndpoint`** — single interface for auto-discovery
 - **Handler injected via DI** — resolved as `IHandler<TReq, TRes>` parameter
 - **`Match()` for responses** — the success lambda receives the value (never read `.Value` directly); the failure lambda is `error.ToHttpResult()` from `Extensions/ErrorHttpMapping.cs` (`backend/dotnet/result-pattern.md`), which maps `ErrorType` to the status — never `Results.BadRequest` for every error
@@ -299,13 +296,9 @@ builder.Services.AddExceptionHandler<CustomExceptionHandler>()
 | Use MediatR `IRequest`/`Send()` | Use `IHandler<TReq, TRes>` resolved directly from DI |
 | Create a service/manager layer | Handler uses `ApplicationDbContext` directly |
 | Add a generic repository (`IRepository<T>`/`IUnitOfWork`) | `DbSet<T>` is the repository; `DbContext` is the unit of work |
-| Use `Guid.NewGuid()` | Use `Guid.CreateVersion7()` for time-sortable IDs |
-| Make handler classes non-sealed | Always `sealed class` |
-| Use mutable DTOs (class with setters) | Always `sealed record` with positional parameters |
-| Omit `CancellationToken` from async methods | Pass `CancellationToken` through every async call |
+| Use mutable DTOs (class with setters) | Always `record` with positional parameters |
 | Put business logic in endpoints | Endpoints only map HTTP and call `Match()` |
 | Share handlers across features | Each feature has its own handler, even if similar |
-| Use constructor + field for DI | Use primary constructors: `class Handler(IDep dep)` |
 | Group by technical concern (Controllers/, Services/) | Group by feature: `Features/BookFeature/CreateBook/` |
 | Route data access through any indirection layer | Inject `DbContext` and write LINQ in the slice; dedicated store only with `plan.md` (`## Decisões`) justification |
 | Use raw SQL (`FromSqlRaw` / `ExecuteQuery(string)`) by default | Use LINQ; raw SQL only with a `plan.md` (`## Decisões`) justification |

package/framework/standards/integration/mcp/mcp-tools.md

@@ -5,7 +5,7 @@
 > **Keywords:** mcp, model-context-protocol, mcp-tools, context7, playwright, mcp-client
 > **Load When:** an MCP tool is used in any morph-spec phase
 
-**Verified against:** 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`. Last-verified: 2026-09-24.
+**Verified against:** 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). Last-verified: 2026-10-17.
 
 ---
 
@@ -138,6 +138,7 @@ Fallback: manual image creation, stock photos, or placeholder divs.
 |------|----------|---------|
 | **Neon CLI (`neonctl`) / psql** | Database schema, tables, relationships, RLS | `psql <DB_URL> -c "SELECT ..."` |
 | **Context7** | Library docs for architecture decisions | `mcp__context7__query-docs()` |
+| **Microsoft Learn** (stack .NET) | Official docs for a .NET/EF Core/MAF decision (limits, what is new, migration) | `mcp__microsoft-learn__microsoft_docs_search({ query })` |
 | **GitHub CLI (`gh`)** | Check existing code patterns, PRs | `gh search code` (Bash) |
 
 ```bash
@@ -213,6 +214,7 @@ gh issue create --title "F1: Create Entity Lead" \
 | **Neon CLI (`neonctl`) / psql** | Run migrations, create RLS policies | `dotnet ef database update` |
 | **GitHub CLI (`gh`)** | Create PR, push branches | `gh pr create` (Bash) |
 | **Context7** | Look up API usage during coding | `mcp__context7__query-docs()` |
+| **Microsoft Learn** (stack .NET) | Current .NET 10 / EF Core / ASP.NET Core / MAF API: search, then fetch the page when the excerpt is cut | `mcp__microsoft-learn__microsoft_docs_search({ query })` → `microsoft_docs_fetch({ url })`; `microsoft_code_sample_search` for snippets |
 | **Playwright** | Smoke test deployed features, verify UI | `mcp__playwright__browser_navigate()` |
 | **Vercel** | Deploy, check logs, manage env vars | `mcp__vercel__list_projects()` |
 | **Azure CLI** | Resource management, deployments | `az` commands |

package/framework/templates/README.md

@@ -36,7 +36,6 @@ framework/templates/
 │
 ├── integrations/      # asaas-client, asaas-webhook, neon-auth-config
 ├── ui/                # design-system.css
-├── meta-prompts/      # fusion, squad-leaders, validators
 ├── examples/          # design-system-examples.md
 └── REGISTRY.json      # template metadata — the index every consumer reads
 ```