@polymorphism-tech/morph-spec 8.45.0 → 8.47.0

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

@@ -2,9 +2,9 @@
 name: morph-uiux
 description: Conduz a fase opcional de UI/UX — design system, mockups, componentes e fluxos — entre o Gate 1 e o plan, despachando a persona ui-designer para o trabalho visual.
 version: core
-when-to-invoke: ao tomar o ramo uiux (morph-spec advance --design), depois do Gate 1 e antes do morph-plan
-user-invokable: true
-cliVersion: "8.45.0"
+when_to_use: Use quando o ramo uiux for tomado (morph-spec advance --design), depois do Gate 1 e antes do morph-plan
+user-invocable: true
+cliVersion: "8.47.0"
 ---
 
 # morph-uiux

package/framework/standards/STANDARDS.json

@@ -721,8 +721,8 @@
         "example": "#exemplo-c-completo",
         "formats": "#formatos-e-limites"
       },
-      "digest": "Use STT when the agent receives voice input or audio files that must be transcribed to text before processing. MAF wraps the Whisper/AudioClient API. Covers supported audio formats (mp3, wav, webm, mp4), file-size limits, language hints, and streaming vs batch transcription. Anti-patterns: piping raw audio into a chat message without transcribing first.",
-      "verifiedAgainst": "OpenAI 2.13.0 + Microsoft.Extensions.AI 10.9.0 (ai-pin 2026-09-08). **Verificação documental**, sem cláusula `provado por` — o ai-kit não transcreve áudio. `AudioClient.TranscribeAudioAsync` e a ponte `AsISpeechToTextClient` foram **medidas por reflexão sobre as assemblies do pin** em 2026-09-08.",
+      "digest": "Use STT só quando o input real é áudio; se já é texto, use-o direto. Transcrição é chamada de serviço, não agente: registre o `AudioClient` (OpenAI 2.13.0) UMA vez no DI com modelo (`whisper-1`) e API key vindos de config e injete-o pelo construtor do `TranscriptionService` (nunca `new AudioClient` no chamador), e passe o texto como `string` ao `AIAgent` downstream; NÃO crie `AIAgent` para transcrever. API: `TranscribeAudioAsync(path, options)` NÃO aceita `CancellationToken` — para cancelar, `File.OpenRead` e a sobrecarga `(Stream, fileName, options, ct)`, que exige o nome do arquivo (dele se deduz o formato); `ResponseFormat = Verbose` com `TimestampGranularities = AudioTimestampGranularities.Word | Segment` (enum de flags, não coleção) dá timestamps. Limites: mp3/mp4/mpeg/mpga/m4a/wav/webm, 25 MB por request (acima, erro 413): divida client-side em chunks de ≤20 MB, com alguns segundos de overlap se o corte for crítico. Defina `Language = \"pt\"` quando o idioma é conhecido. Opcional: `ISpeechToTextClient` via `AsISpeechToTextClient()`.",
+      "verifiedAgainst": "OpenAI 2.13.0 + Microsoft.Extensions.AI 10.9.0 (ai-pin 2026-09-08). **Verificação documental**, sem cláusula `provado por` — o ai-kit não transcreve áudio. `AudioClient.TranscribeAudioAsync` e a ponte `AsISpeechToTextClient` foram **medidas por reflexão sobre as assemblies do pin** em 2026-09-08. Em 2026-10-03 os blocos da API, do `TranscriptionService`, do agente downstream (dentro de um método-invólucro) e do registro DI compilaram com `TreatWarningsAsErrors` contra `OpenAI` 2.13.0 + `Microsoft.Agents.AI` 1.20.0 (o pin de 2026-09-08, que é a data que este campo carrega).",
       "provedBy": []
     },
     {
@@ -791,7 +791,7 @@
         "example": "#exemplo-c-completo",
         "content-types": "#datacontent-vs-uricontent"
       },
-      "digest": "Use vision when the agent needs to interpret images, screenshots, scanned documents or PDFs. MAF exposes multimodal ChatMessage with DataContent (inline bytes) or UriContent (remote URL). Covers OCR, diagram understanding, UI screenshot analysis, and document extraction. Anti-patterns: sending raw Base64 blobs without MIME type, ignoring resolution limits.",
+      "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.",
       "verifiedAgainst": "Microsoft.Extensions.AI 10.9.0 + Microsoft.Agents.AI 1.20.0 (ai-pin 2026-09-08). **Verificação documental**, sem cláusula `provado por` — o ai-kit não exercita conteúdo multimodal. Os três tipos de conteúdo citados (`TextContent`, `UriContent`, `DataContent`) foram **conferidos por reflexão sobre `Microsoft.Extensions.AI.Abstractions` 10.9.0** em 2026-09-08 e continuam existindo com esses nomes.",
       "provedBy": []
     },
@@ -941,7 +941,7 @@
         "tenant": "#fonte-2-yaml-por-tenant",
         "reconciliacao": "#reconciliação"
       },
-      "digest": "WHERE an agent prompt lives, and how to prove which version actually ran. Two legitimate sources, and the one-sentence rule that picks between them: if the text varies per customer, the prompt is not a record — it is the OUTPUT OF A COMPOSITION, and what you version is the source. (1) Versioned table agent_prompts (agent_key + version + is_active, INSERT + flip, never UPDATE, unique partial index, IMemoryCache with a short TTL) for single-tenant. (2) Repo YAML per tenant + a product frame with named holes -> a deterministic composer -> a rendered spec published to a jsonb column, for product x tenant; editing prompts then costs a repo cycle, which is a product trade-off, not a free upgrade. RECONCILIATION is the section that was missing: versioning and publishing do NOT prove the active version ran (measured: v7/v8 ignored in 6 of 9 executions). The execution record must carry the EFFECTIVE version, plus the hash of the rendered blob on the composed path; the two field-proven techniques are byte-identity equivalence between source and published blob, and a single structural prompt-as-text test asserting the ABSENCE of a revoked instruction.",
+      "digest": "WHERE an agent prompt lives, and how to prove which version actually ran. Two legitimate sources, and the one-sentence rule that picks between them: if the text varies per customer, the prompt is not a record — it is the OUTPUT OF A COMPOSITION, and what you version is the source. (1) Versioned table agent_prompts (id app-assigned with Guid.CreateVersion7(), no gen_random_uuid() default; agent_key + version + is_active, INSERT + flip in one transaction, never UPDATE, unique partial index, IMemoryCache with a short TTL) for single-tenant. (2) Repo YAML per tenant + a product frame with named holes -> a deterministic composer -> a rendered spec published to a jsonb column, for product x tenant; editing prompts then costs a repo cycle, which is a product trade-off, not a free upgrade. RECONCILIATION is the section that was missing: versioning and publishing do NOT prove the active version ran (measured: v7/v8 ignored in 6 of 9 executions). The execution record must carry the EFFECTIVE version, plus the hash of the rendered blob on the composed path; the two field-proven techniques are byte-identity equivalence between source and published blob, and a single structural prompt-as-text test asserting the ABSENCE of a revoked instruction.",
       "verifiedAgainst": "Microsoft.Agents.AI 1.20.0 + Microsoft.Extensions.AI 10.9.0 (ai-pin 2026-09-08). **Verificação documental**, sem cláusula `provado por` — o ai-kit não traz loader de prompt, e os dois mecanismos descritos aqui são destilados de três produtos em produção. As **quatro** superfícies de API que este standard cita foram medidas por reflexão, e vivem em **três assemblies diferentes** — o carimbo diz onde remedir, então o nome importa: `IChatClient.AsAIAgent(instructions:, name:)` é `Microsoft.Extensions.AI.ChatClientExtensions`, em **`Microsoft.Agents.AI` 1.20.0** (medida em 2026-09-08); `AIAgent.RunAsync` (as oito sobrecargas) e `AIAgent.CreateSessionAsync` são de `Microsoft.Agents.AI.AIAgent`, na assembly **`Microsoft.Agents.AI.Abstractions` 1.20.0** — **remedidas** em 2026-09-09, porque a leitura de 2026-09-08 estava errada no *quê*, e a de 2026-09-09 estava errada no *onde* (as duas retificações estão no callout abaixo); e `builder.AddAIAgent` (§Keyed singleton) é `Microsoft.Agents.AI.Hosting.HostApplicationBuilderAgentExtensions` — cinco sobrecargas, na assembly **`Microsoft.Agents.AI.Hosting` 1.20.0.0**, que vem do pacote **`Microsoft.Agents.AI.Hosting` `1.20.0-preview.260831.1`**: ele é **prerelease** e está **FORA do `ai-pin.json`** (apurado em `scripts/api-probe/companions.json`, 2026-09-08) — quem adotar esta seção registra a dependência prerelease em `decisions.md`, como manda `ai-agents-production`. **Duas ressalvas de escopo**, porque um carimbo que não as diz promete mais do que mediu: `Microsoft.Agents.AI.Abstractions` e `Microsoft.Extensions.AI.Abstractions` são nomes de **assembly** (elas viajam dentro dos pacotes `Microsoft.Agents.AI` e `Microsoft.Extensions.AI`), não ids de pacote; e `IMemoryCache`/`DbContext`, usados no padrão de cache e na §Keyed singleton, são superfícies de ASP.NET Core e EF Core — **fora do pin, não medidas aqui, verificação documental**.",
       "provedBy": []
     },
@@ -1026,8 +1026,8 @@
         "tool": "#vectorsearchtool-tool-maf",
         "multi-tenant": "#multi-tenant"
       },
-      "digest": "Custom RAG on pgvector/Neon you control: chunking, embedding model via the Model Registry `embeddings` alias, HNSW with vector_cosine_ops, tenant_id filtered in every query and never exposed to the LLM. Owns DELTA INGESTION by lookup-key: a pure Plan(incoming, lookupKey, contentHash, existingHashes) returning Added/Updated/Removed/Unchanged, where Unchanged is never re-embedded, Updated is an upsert on a deterministic id, Removed is applied AFTER the writes (no empty window), and a duplicate lookup-key fails the run naming both positions. Microsoft.Extensions.DataIngestion (still preview) solves hygiene, not embedding cost — its IncrementalIngestion deletes all pre-existing chunks of a document before rewriting. Open item: similarity threshold and k per scope.",
-      "verifiedAgainst": "Microsoft.Agents.AI 1.20.0 + Microsoft.Extensions.AI 10.9.0 (ai-pin 2026-09-08); `provado por templates/dotnet/ai-kit/src/Morph.AiKit/Rag/DeltaIngest.cs` **restrito à seção \"Ingestão delta por lookup-key\"** — é a única parte deste standard que o ai-kit compila. Todo o resto (pgvector, SQL, HNSW, embeddings, multi-tenant) é **verificação documental**; a versão e o status de `Microsoft.Extensions.DataIngestion` foram apurados no nuget.org em 2026-09-08.",
+      "digest": "Custom RAG on pgvector/Neon you control: chunking, embedding model via the Model Registry `embeddings` alias with `IEmbeddingGenerator<string, Embedding<float>>` injected directly into the ingestion handler and the VectorSearchTool (no EmbeddingService wrapper; batch GenerateAsync at ingestion, GenerateVectorAsync per query), the tool querying through EF Core (`CosineDistance` LINQ, raw NpgsqlDataSource only with a decisions.md reason), ids app-assigned (deterministic V5 for delta chunks, else Guid.CreateVersion7(); no gen_random_uuid() default), HNSW with vector_cosine_ops, tenant_id filtered in every query and never exposed to the LLM. Owns DELTA INGESTION by lookup-key: a pure Plan(incoming, lookupKey, contentHash, existingHashes) returning Added/Updated/Removed/Unchanged, where Unchanged is never re-embedded, Updated is an upsert on a deterministic id, Removed is applied AFTER the writes (no empty window), and a duplicate lookup-key fails the run naming both positions. Microsoft.Extensions.DataIngestion (still preview) solves hygiene, not embedding cost — its IncrementalIngestion deletes all pre-existing chunks of a document before rewriting. Open item: similarity threshold and k per scope.",
+      "verifiedAgainst": "Microsoft.Agents.AI 1.20.0 + Microsoft.Extensions.AI 10.9.0 (ai-pin 2026-09-08); `provado por templates/dotnet/ai-kit/src/Morph.AiKit/Rag/DeltaIngest.cs` **restrito à seção \"Ingestão delta por lookup-key\"** — é a única parte deste standard que o ai-kit compila. Todo o resto (pgvector, SQL, HNSW, embeddings, multi-tenant) é **verificação documental**; a versão e o status de `Microsoft.Extensions.DataIngestion` foram apurados no nuget.org em 2026-09-08. Em 2026-10-03, contra o mesmo pin, compilaram com `TreatWarningsAsErrors` os blocos de registro do `IEmbeddingGenerator`, do `VectorSearchTool` (EF Core + Pgvector.EntityFrameworkCore 0.3.0) e do *Exemplo de uso* (a ponte `Microsoft.Extensions.AI.OpenAI` 10.9.0 resolveu `OpenAI` 2.12.0); a forma anterior `RunAsync(question, ct)` não compilava (CS1503).",
       "provedBy": [
         "templates/dotnet/ai-kit/src/Morph.AiKit/Rag/DeltaIngest.cs"
       ]
@@ -1312,8 +1312,8 @@
         "rules": "#padrões-obrigatórios",
         "cqrs": "#anti-patterns-nunca-fazer-em-vsa"
       },
-      "digest": "Organize by feature, not layer. Each slice contains Command/Query, Handler, Validator, Response. No cross-slice dependencies — shared code goes to a dedicated Shared project. Use MediatR for in-process CQRS dispatch.",
-      "verifiedAgainst": ".NET 10 + EF Core 10 + FluentValidation 12 + Scrutor 7.",
+      "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 `decisions.md`. Não misture VSA com DDD.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + EF Core 10.0.12 + FluentValidation 12.1.1 + Scrutor 7. Os blocos da slice (Handler, Validator, Endpoint) compilam com `TreatWarningsAsErrors` sobre o `Result`/`Error`/`ErrorHttpMapping` de `result-pattern.md` nos namespaces da árvore acima (`{ProjectName}` substituído; o Handler com `global using` de Abstractions/Database/Entities, o Endpoint só com os próprios `using`); Abstractions, Pipelines e DI são verificação documental.",
       "provedBy": []
     },
     {
@@ -1337,11 +1337,12 @@
         "model validation"
       ],
       "anchors": {
-        "fluent": "#validation-patterns",
-        "rules": "#validation-patterns"
+        "fluent": "#fluentvalidation-validator-in-the-slice",
+        "rules": "#validation-patterns",
+        "state": "#state-checks-in-the-handler"
       },
-      "digest": "Use FluentValidation for all request validation. Register validators as scoped services. Return 422 UnprocessableEntity with field-level error messages. Validate at API boundary — not inside domain logic. Never trust client-side validation alone.",
-      "verifiedAgainst": ".NET 10 (pure state-validation pattern — no external package).",
+      "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 decisions.md and test each.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + FluentValidation 12.1.1 + EF Core 10.0.12. The validator, `OrderStatus`, `OrderErrors` and state-check handler blocks compile with `TreatWarningsAsErrors` over the `Result`/`Error`/`ValidationError` of `result-pattern.md`.",
       "provedBy": []
     },
     {
@@ -1369,8 +1370,8 @@
         "schema": "#schema-design",
         "indexes": "#indexes"
       },
-      "digest": "Use timestamptz for all timestamps (not timestamp). UUID primary keys for public-facing IDs. Add indexes on FK columns and frequently filtered columns. Use GIN indexes for JSON/array columns. JSONB over JSON. Row-level security for multi-tenant. Never store binary in columns — use storage URLs.",
-      "verifiedAgainst": "PostgreSQL 16/17 + EF Core 10 + @neondatabase/serverless.",
+      "digest": "Neon PostgreSQL schema rules: snake_case plural tables and snake_case columns, PK 'id uuid primary key' with NO column default -- the app sets it with Guid.CreateVersion7() (rows inserted outside the app pass an explicit id; never gen_random_uuid() defaults for app ids), FK '{table}_id', booleans prefixed is_/has_, indexes 'idx_{table}_{column}'. Always include created_at/updated_at as timestamptz default now() not null, kept fresh by a handle_updated_at trigger. Always enable RLS on user-facing tables, with policies like 'auth.user_id() = user_id' (update takes both using and with check). Migrations via EF Core: dotnet ef migrations add, database update, and migrations script --idempotent to review the SQL; hand-written SQL migrations enable RLS, create indexes and always include a rollback. Index FKs and WHERE/ORDER BY/GROUP BY columns; GIN for full-text search. Select only needed columns, limit results, batch inserts, set a statement timeout, keep RLS policies simple. The Next.js frontend reads through the .NET API (proxy + TanStack Query); @neondatabase/serverless is only for Node-side tooling.",
+      "verifiedAgainst": "PostgreSQL 16/17 + EF Core 10.0.12 (Npgsql provider 10.0.3) + @neondatabase/serverless. The EF Core query blocks compile with `TreatWarningsAsErrors` inside a wrapper method over stand-in entities; the SQL is documentary.",
       "provedBy": []
     },
     {
@@ -1399,7 +1400,9 @@
         "chunking": "#📥-indexação-de-documentos",
         "retrieval": "#🔍-vector-search-com-ef-core-10"
       },
-      "digest": "Chunk documents with 512 token size and 50 token overlap for RAG. Embed with text-embedding-3-small. Store embedding + metadata (source, chunk index). Retrieve top-k=5 by cosine similarity. Re-rank before injecting into LLM context. Use pgvector HNSW index for performance at scale."
+      "digest": "Pipeline RAG em slices VSA sobre EF Core 10 + PostgreSQL/pgvector (Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3, Pgvector.EntityFrameworkCore 0.3.0; Microsoft.Extensions.AI 10.9.0 e Microsoft.Agents.AI 1.20.0 do pin). Mapeamento (Document com `Pgvector.Vector` `vector(1536)`, EF não mapeia `float[]`; `UseVector()` no `UseNpgsql`; HNSW `vector_cosine_ops`) vem de neon-pgvector.md. Cada operação é um handler que injeta `ApplicationDbContext` e `IEmbeddingGenerator<string, Embedding<float>>` direto — sem EmbeddingService/SearchService; ids `Guid.CreateVersion7()`, `CreatedAt` do `TimeProvider`. Busca: `d.Embedding!.CosineDistance(query)` + OrderBy da distância (traduz para `<=>` ASC e usa o índice; o `HasOperators` tem de casar com a função ou cai em seq scan), similaridade = 1 - distância. Slice AskDocuments: top 3 por distância, `NotFound` (Result) antes de chamar o LLM quando nada é relevante, contexto no `instructions` de `chatClient.AsAIAgent(...)`, `RunAsync(...).Text`; prompt manda usar APENAS os documentos e citar o id; endpoint via `error.ToHttpResult()`. Indexação em lote com uma chamada `GenerateAsync(IEnumerable<string>)` e um SaveChanges; job Hangfire só com razão real, como entrada fina que chama o handler. text-embedding-3-small (1536) recomendado, large 3072; HNSW (m=16, ef_construction=64) padrão; IVFFlat só após popular (lists 50/100/500+).",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3 + Pgvector.EntityFrameworkCore 0.3.0 + Microsoft.Extensions.AI 10.9.0 + Microsoft.Agents.AI 1.20.0 (ai-pin 2026-09-08). Os blocos de indexação, indexação em lote, busca+geração (RAG), endpoint e job compilam com `TreatWarningsAsErrors` sobre o `Result`/`IHandler`/`ErrorHttpMapping` de `result-pattern.md`/`vertical-slice.md` e o `Document`/`ApplicationDbContext` de `neon-pgvector.md`; o registro do `IEmbeddingGenerator` por provedor, os custos e o SQL são verificação documental.",
+      "provedBy": []
     },
     {
       "id": "backend-dotnet-fluent-validation-vsa",
@@ -1427,8 +1430,8 @@
         "decorator": "#validationdecorator-pattern",
         "conversion": "#fluentvalidation-to-validationerror-conversion"
       },
-      "digest": "Use AbstractValidator<T> per request DTO in feature folders. ValidationDecorator intercepts all handlers via Scrutor, runs validators in parallel, and short-circuits to Result.Failure(ValidationError) on failure. Register AddValidatorsFromAssembly() before AddHandlersFromAssembly(). Never validate inside handlers.",
-      "verifiedAgainst": ".NET 10 + FluentValidation 11 (`AbstractValidator`/`RuleFor` API).",
+      "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`.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + FluentValidation 12.1.1. The validator block and the decorator (its three blocks assembled into one class) compile with `TreatWarningsAsErrors` over the `Result`/`ValidationError` of `result-pattern.md`, and the validator was run with `FakeTimeProvider` across a year change to show the year is read per validation.",
       "provedBy": []
     },
     {
@@ -1457,8 +1460,8 @@
         "errors": "#error-types-7--custom",
         "match": "#match-pattern"
       },
-      "digest": "Use Result<T> for all handler returns — never throw for expected failures. 7 error types (Failure, Unexpected, Validation, Conflict, NotFound, Unauthorized, Forbidden) map to HTTP status codes. Use Match() in endpoints to convert Result to IResult. Implicit conversions allow returning values or errors directly from handlers.",
-      "verifiedAgainst": ".NET 10 (pure C# pattern — no external package).",
+      "digest": "Expected failures are Result/Result<T> values, never exceptions. Endpoints convert with result.Match(onSuccess: value => Results.Ok(value), onFailure: error => error.ToHttpResult()); never read .Value outside Match (it throws on failure). Implicit conversions let a handler return the value or the Error directly. Error = record(Code, Description, ErrorType) from factories Failure/Unexpected/Validation/Conflict/NotFound/Unauthorized/Forbidden; ValidationError aggregates FluentValidation errors. Status comes from ErrorType, never a blanket BadRequest: Failure/Validation/Custom 400, NotFound 404, Conflict 409, Unauthorized 401, Forbidden 403, Unexpected 500, via Results.Problem. Each feature owns a static {Feature}Errors class. FORBIDDEN: try/catch in handlers (unexpected exceptions bubble to the global handler), returning null, codeless string errors.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + the shared framework `Microsoft.AspNetCore.App` 10 — the HTTP mapping uses `Results`/`IResult`/`StatusCodes`; the `Error`, `ValidationError`, `ResultExtensions`, `ErrorHttpMapping`, endpoint usage and `BookErrors` blocks compile with `TreatWarningsAsErrors` (the Anatomy blocks carry `{ ... }` placeholders and were compiled through a concrete stand-in).",
       "provedBy": []
     },
     {
@@ -1487,8 +1490,8 @@
         "tags": "#apitags-organization",
         "metadata": "#endpoint-metadata"
       },
-      "digest": "Use Scalar.AspNetCore 2.12.40 as API documentation UI — replaces Swagger. MapScalarApiReference() with DeepSpace theme. Group endpoints with .WithTags() and ApiTags constants. Document responses with .Produces<T>(). Guard MapOpenApi() with IsDevelopment(). No Swashbuckle needed.",
-      "verifiedAgainst": ".NET 10 + Scalar.AspNetCore 2.x + Microsoft.AspNetCore.OpenApi 10.",
+      "digest": "Scalar replaces Swagger UI: packages Microsoft.AspNetCore.OpenApi 10.0.0 + Scalar.AspNetCore 2.12.40, never Swashbuckle (ASP.NET Core 9+ generates OpenAPI natively). Program.cs order: builder.Services.AddOpenApi(); app.MapOpenApi() only inside IsDevelopment() (never expose OpenAPI in production); then app.MapScalarApiReference with WithTheme(ScalarTheme.DeepSpace) and WithDefaultHttpClient(ScalarTarget.CSharp, ScalarClient.HttpClient). MapOpenApi must come before Scalar; the UI is served at /scalar/v1. Every endpoint needs .WithTags(ApiTags.X), with tags as constants in Constants/ApiTags.cs (no magic strings), and .Produces<T>(status) for success plus .ProducesProblem(status) for every failure status the slice can return (failures go out as ProblemDetails via error.ToHttpResult()), so the docs show accurate response types. Also available: .WithName (operation id), .WithSummary, .WithDescription, .ProducesProblem, .RequireAuthorization.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Scalar.AspNetCore 2.x + Microsoft.AspNetCore.OpenApi 10. The `ApiTags` and tagged-endpoint blocks compile with `TreatWarningsAsErrors` over the `Result`/`ErrorHttpMapping` of `result-pattern.md` (ApiTags placed in `ProjectName.Constants`); the startup and metadata snippets (`async (...) => { ... }`) are fragments, checked against the docs only.",
       "provedBy": []
     },
     {
@@ -1517,7 +1520,7 @@
         "decorators": "#decorator-order",
         "endpoints": "#endpoint-auto-discovery"
       },
-      "digest": "Use Scrutor for convention-based DI registration. AddHandlersFromAssembly() scans for IHandler<,> implementations. Decorate<> applies pipeline decorators (validation, logging) — last registered wraps outermost. Register validators before handlers. RegisterApiEndpointsFromAssembly() auto-discovers IApiEndpoint implementations.",
+      "digest": "Scrutor 7 (.NET 10) handler/decorator registration for VSA. `AddHandlersFromAssembly` reflects over concrete classes filtered by `!t.ContainsGenericParameters` (so open-generic decorators are excluded), registers each `IHandler<,>` as `AddScoped` (handlers use DbContext, never Singleton), then calls `Decorate` for `ValidationDecorator<,>` first and `LoggingDecorator<,>` second: the last registered wraps outermost, so execution is Logging -> Validation -> Handler and logging sees validation failures. `RegisterApiEndpointsFromAssembly` adds every `IApiEndpoint` as Transient via `TryAddEnumerable`; `MapApiEndpoints` calls `MapEndpoint` on each. Program.cs order: DbContext, endpoints, `AddValidatorsFromAssembly` (must precede handlers so the ValidationDecorator can resolve validators), handlers + decorators, cross-cutting. Never register handlers one by one.",
       "verifiedAgainst": ".NET 10 + Scrutor 7 (`Scan`/`Decorate` API).",
       "provedBy": []
     },
@@ -1582,8 +1585,8 @@
         "endpoint": "#complete-endpoint-example",
         "registration": "#programcs-di-registration-order"
       },
-      "digest": "Each VSA feature is 5 files: Request, Response, Handler, Validator, Endpoint. Use IHandler<TReq,TRes> (not MediatR). Sealed records for DTOs, primary constructors for DI, Guid.CreateVersion7() for IDs. Handler injects ApplicationDbContext directly — no service layer, no generic repository (DbSet<T> is the repository, DbContext is the unit of work). CancellationToken in every async call.",
-      "verifiedAgainst": ".NET 10 (minimal APIs, primary constructors, `Guid.CreateVersion7()`).",
+      "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 `decisions.md` justification.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview; minimal APIs, primary constructors, `Guid.CreateVersion7()`). The \"Complete Endpoint Example\" block compiles with `TreatWarningsAsErrors` over the `Result`/`ErrorHttpMapping` of `result-pattern.md` (in `ProjectName.Abstractions`/`ProjectName.Extensions`, reached only through the block's own `using`s); the other blocks are documentary.",
       "provedBy": []
     },
     {
@@ -1611,8 +1614,8 @@
         "payments": "#create-pix-payment",
         "webhooks": "#webhook-handler"
       },
-      "digest": "Use AsaasClient SDK — never call REST API directly. Register as scoped service. Implement webhook signature verification. Map SDK enums to domain enums at integration boundary. Use idempotency keys for retry safety. Test with Asaas sandbox environment.",
-      "verifiedAgainst": "Asaas REST API v3 (no official Node SDK — direct REST).",
+      "digest": "Asaas from the .NET 10 backend (the Next.js frontend never calls Asaas; it calls the backend through the proxy). No official .NET SDK: REST v3 through a typed HttpClient `AsaasClient` (an external-API port, injected into the slice handler next to the DbContext), registered with AddHttpClient + options bound from config `Asaas` (ValidateOnStart; key in user-secrets/Coolify env, never in code). Base URL https://api.asaas.com/v3/ or https://api-sandbox.asaas.com/v3/ WITH trailing slash and relative paths without leading slash (otherwise HttpClient drops /v3). Every request sends `access_token` (not Bearer), Content-Type and `User-Agent` (mandatory for root accounts created from 06/11/2024). Responses become Result: 400 `{ errors: [{ code, description }] }` -> Error.Validation (ValidationError if several, e.g. invalid_cpfCnpj), 404 -> NotFound, other non-success -> Unexpected; endpoints map with error.ToHttpResult(); no try/catch, network failures propagate. No duplicate charges: Asaas documents no idempotency-key header and create is not idempotent, so set `externalReference` to your id and `GET /payments?externalReference=` before creating; never auto-retry payWithCreditCard. PIX: POST /payments billingType PIX with dueDate as today in America/Sao_Paulo via TimeProvider, then GET /payments/{id}/pixQrCode (payload + encodedImage). Webhooks are not HMAC-signed: compare the `asaas-access-token` header to the configured authToken with CryptographicOperations.FixedTimeEquals, 401 on mismatch; delivery is at-least-once, so store processed event ids (unique) and answer 200 (only 200 counts; 15 consecutive failures interrupt the queue). Validate CPF (11 digits) and CNPJ (14, alphanumeric from July 2026, ASCII-48 mod-11), never store card data; local ids via Guid.CreateVersion7(), no gen_random_uuid defaults.",
+      "verifiedAgainst": "Asaas REST API v3 (docs read via context7 on 2026-10-03: headers, `POST /payments`, `GET /payments?externalReference=`, `pixQrCode`, webhook payload, delivery and error rules) + .NET 10 (SDK 10.0.400-preview, `IHttpClientFactory` from the ASP.NET Core shared framework) + EF Core 10.0.12. The options, client, registration, PIX slice, webhook slice/endpoint and CPF/CNPJ blocks compile with `TreatWarningsAsErrors` over the `Result`/`ErrorHttpMapping` of `result-pattern.md`; the CPF/CNPJ validator was run against valid and invalid documents (numeric and the alphanumeric `12.ABC.345/01DE-35`), and the `BaseUrl` trailing-slash rule and the `dueDate` JSON shape were checked by running them; the SQL is documentary.",
       "provedBy": []
     },
     {
@@ -1641,8 +1644,8 @@
         "jobs": "#job-types",
         "retry": "#retry--error-handling"
       },
-      "digest": "Use IDbContextFactory for scoped DB operations in jobs — never inject DbContext directly into job classes. BackgroundJob.Enqueue for fire-and-forget, RecurringJob.AddOrUpdate for cron. Add RetryCountAttribute for retries. Secure Hangfire Dashboard with auth in production. Never put long-running work in a single job — decompose.",
-      "verifiedAgainst": ".NET 10 + Hangfire 1.8 (Core/SqlServer/AspNetCore).",
+      "digest": "Hangfire 1.8.25 on .NET 10, only with a real reason (survive restarts, schedules, deferred retries) recorded in decisions.md; 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).",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Hangfire.Core/Hangfire.AspNetCore 1.8.25 + Hangfire.PostgreSql 1.21.1 + Newtonsoft.Json 13.0.4. The startup, job/handler, dashboard-filter and idempotency blocks compile with `TreatWarningsAsErrors`; the Job Types calls compile inside a wrapper method; the per-job DI scope (`AspNetCoreJobActivator` → `IServiceScopeFactory`) and the `PostgreSqlStorageOptions` defaults were read by reflection on those assemblies; the pooled-endpoint limits (LISTEN/NOTIFY, migrations on the direct string) come from the Neon connection-pooling docs. Cron strings are documentary.",
       "provedBy": []
     },
     {
@@ -1719,7 +1722,7 @@
         "sending": "#send-email-api-route",
         "templates": "#common-email-templates"
       },
-      "digest": "Register ResendClient as singleton. Provide both HTML and plain-text alternatives. Handle bounce/complaint webhooks to maintain sender reputation. Never send from test domains in production. Queue emails via Hangfire for reliability — don't send inline in request handlers.",
+      "digest": "Resend transactional email via REST API (not SMTP; 100 free emails/day) for Next.js and .NET. Next.js: `resend` + React Email templates, one `new Resend(process.env.RESEND_API_KEY)` in `lib/resend.ts`. .NET: `Resend` package, `AddHttpClient<ResendClient>()` plus `IResend` registered transient, token from the `Resend:ApiKey` config. Always send asynchronously: do not block HTTP requests, enqueue with Hangfire (`BackgroundJob.Enqueue`); retry with Polly (3 attempts, exponential backoff); rate-limit sends (Upstash sliding window, 10/hour). Webhooks are signed with Svix: verify the RAW body with `resend.webhooks.verify()` using the `svix-id`/`svix-timestamp`/`svix-signature` headers and `RESEND_WEBHOOK_SECRET`; do NOT hand-roll an HMAC (it rejects valid webhooks). Handle `email.delivered`/`bounced`/`complained`. Verify the sending domain first (SPF, DKIM, DMARC; up to 72 hours).",
       "verifiedAgainst": "Resend Node SDK 4 + Resend .NET SDK + React Email.",
       "provedBy": []
     },
@@ -1750,8 +1753,8 @@
         "patterns": "#cache-aside-pattern",
         "invalidation": "#ttl-strategy"
       },
-      "digest": "IDistributedCache for cache-aside pattern. Set TTL on every entry — never cache without expiry. Serialize with System.Text.Json. Sliding expiration for sessions, absolute for computed results. Invalidate by key prefix. Redis eviction policy must be set (allkeys-lru). Never cache PII without encryption.",
-      "verifiedAgainst": ".NET 10 + StackExchange.Redis 2.x + Microsoft.Extensions.Caching.StackExchangeRedis.",
+      "digest": "Redis (on the Coolify VPS or managed) is a distributed cache for sessions, rate limiting and hot reads, never the primary store. Packages: Microsoft.Extensions.Caching.StackExchangeRedis 10.0.12 (depends on StackExchange.Redis >= 2.7.27); reference StackExchange.Redis explicitly at the latest 2.x (2.13.17) only when injecting IConnectionMultiplexer -- 3.x is a new major the caching package has not adopted. Register one shared IConnectionMultiplexer as a LAZY singleton and hand it to the cache via AddOptions<RedisCacheOptions>().Configure<IServiceProvider>(... ConnectionMultiplexerFactory ...) -- never Connect during registration (an unreachable Redis would block boot) and never BuildServiceProvider inside the factory, InstanceName prefix (e.g. 'myapp:'), connection string from configuration (user-secrets / Coolify env ConnectionStrings__Redis). Cache-aside lives in the slice handler with IDistributedCache next to the ApplicationDbContext (no CachedXService/repository wrapper): read the key, on a miss project the response DTO from the DbContext, return Result NotFound (never null) when absent, write with DistributedCacheEntryOptions; the writing handler invalidates the exact key with RemoveAsync after SaveChangesAsync; key builders in one static class per feature. TTLs: user session 30 min sliding, product catalog 15 min absolute, rate-limit counters 1 min, computed aggregates 1 h, reference data 24 h. Rate limit across instances: StringIncrementAsync, KeyExpireAsync 1 min when count == 1, minute from TimeProvider (single instance: built-in AddRateLimiter). FORBIDDEN: caching passwords/tokens/PII without encryption, omitting TTL, swallowing RedisConnectionException in an empty catch (DB fallback during an outage is a decisions.md decision, implemented once at the cache boundary).",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Microsoft.Extensions.Caching.StackExchangeRedis 10.0.12 + StackExchange.Redis 2.13.17 + EF Core 10.0.12. The registration, cache-aside handler, invalidation and rate-limit blocks compile with `TreatWarningsAsErrors` over the `Result` of `result-pattern.md`; package dependencies read from the nuget.org nuspec on 2026-10-03.",
       "provedBy": []
     },
     {
@@ -1777,10 +1780,10 @@
       ],
       "anchors": {
         "modeling": "#container-design",
-        "queries": "#repository-pattern"
+        "queries": "#handler-in-the-slice"
       },
-      "digest": "Choose partition key with high cardinality for even distribution. Design documents for single-partition reads. Enable TTL for ephemeral data. Prefer point reads (O(1)) over cross-partition queries. Set provisioned throughput based on measured RUs. Use change feed for event-driven processing.",
-      "verifiedAgainst": ".NET 10 + Microsoft.Azure.Cosmos SDK v3.",
+      "digest": "OPTIONAL — outside the baked-in stack. The default store is Neon (Postgres) via EF Core; Cosmos needs a decisions.md entry saying why Neon does not serve (multi-region writes, event-stream throughput, per-tenant schema never joined) — never for joined data, small datasets or 'flexible schema' (jsonb covers it). Stack rules still hold: one singleton CosmosClient with System.Text.Json, the Container as a keyed singleton injected straight into the slice handler (no CosmosRepository<T>), ids from Guid.CreateVersion7(), time from TimeProvider. Use ReadItemStreamAsync/CreateItemStreamAsync and map StatusCode 404/409 to Result errors instead of catching CosmosException. Parameterized queries with the PartitionKey pinned in QueryRequestOptions (no fan-out). Microsoft.Azure.Cosmos 3.x needs an explicit Newtonsoft.Json reference or the build fails.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Microsoft.Azure.Cosmos 3.63.2 + Newtonsoft.Json 13.0.4 — every `csharp` block below compiles with `TreatWarningsAsErrors` against the `Result`/`Error` types of `backend-dotnet-result-pattern`.",
       "provedBy": []
     },
     {
@@ -1808,7 +1811,7 @@
         "strategies": "#chunking-strategies",
         "retrieval": "#chunking-strategies"
       },
-      "digest": "Recursive character splitting: 512 token chunks, 50 token overlap. Embed with text-embedding-3-small (1536 dims). Store chunk + metadata (source, page, section). Retrieve top-k=5 by cosine similarity. Re-rank with cross-encoder before LLM injection. Evaluate retrieval quality with RAGAS.",
+      "digest": "Strategies: fixed-size baseline (sample defaults size 512, overlap 50, applied to characters), sentence-aware (recommended for prose, `maxTokens` 256) and semantic (best quality, higher cost; split at markdown headers `^#{1,3} `). By document type: legal -> sentence-aware 256 tokens; technical docs -> semantic by headers; Q&A -> keep whole Q+A; code -> whole function; news -> paragraph, 512 tokens. Estimate tokens as chars/4 for English (about 3 chars per token for Portuguese), or tiktoken if available. Always store chunk metadata (DocumentId, DocumentTitle, SourceUrl, ChunkIndex, StartCharIndex, Section, IndexedAt) for filtering and citation. Checklist: overlap 10-20% so boundaries do not cut context, minimum 50 tokens, maximum about 512 (far below the 8192-token embedding input limit), and re-index when a document changes, detected via a content hash.",
       "verifiedAgainst": ".NET 10 (chunking algorithms — language-level, no external package).",
       "provedBy": []
     },
@@ -1918,7 +1921,7 @@
         "tokens": "#stagger--timing",
         "principles": "#css-animation-patterns"
       },
-      "digest": "Use CSS custom properties for durations: --duration-fast (100ms), --duration-normal (200ms), --duration-slow (300ms). Prefer transform/opacity for GPU-accelerated animations. Always respect prefers-reduced-motion. No decorative animations over 300ms. Ease-out for entrances, ease-in for exits.",
+      "digest": "CSS animation library for design-system.css: keyframes (fadeIn/Out, slideIn Up/Down/Left/Right, scaleIn, bounce, pulse, spin, shimmer) exposed as `.animate-*` classes (0.3s fade/scale, 0.5s slides; bounce 1s, pulse 2s, spin 1s infinite) plus `.duration-fast/normal/slow` (150/300/500ms), `.stagger-1..10` (0.1s steps) and `.ease-bounce`. For staggered lists set `animation-delay` AND `animation-fill-mode: backwards` (marked CRITICAL: otherwise elements flash before the delay). Skeletons use `.shimmer` (1.5s infinite). Hover/focus transitions run 0.15s to 0.3s. Always include the `@media (prefers-reduced-motion: reduce)` block (0.01ms durations, one iteration). Beyond CSS: Motion (formerly Framer Motion) for simple enter/exit, layout and gesture transitions (`frontend/nextjs/motion-patterns.md`); GSAP for ScrollTrigger, SVG morph, timelines (`frontend/gsap/gsap-core.md`).",
       "verifiedAgainst": "CSS animations/transitions (language-level, no framework).",
       "provedBy": []
     },
@@ -1946,7 +1949,7 @@
         "blocks": "#bem-for-reusable-components",
         "tokens": "#css-variables-with-namespace"
       },
-      "digest": "BEM for CSS: .block__element--modifier. Design tokens: --color-primary-500, --spacing-4, --font-size-base. Component names PascalCase (React/Next.js) / kebab-case (CSS). No generic names (blue, big). Semantic names only: --color-action, --spacing-page-gutter. Tokens are the single source of truth.",
+      "digest": "CSS naming rests on four principles: a page prefix prevents conflicts, BEM for components gives clear hierarchy, namespaced variables avoid library collisions, and state suffixes keep modifiers consistent. Page-specific elements take the page name as prefix (.home-hero, .checkout-form, .dashboard-stats, .auth-form); reusable components use BEM: block .card, element .card__header, modifier .card--featured. Rule: BEM for reusable components, page prefix for page-specific elements. Custom properties go in :root under the --app- namespace (--app-primary, --app-spacing-md, --app-font-heading). State modifiers use fixed suffixes: --active, --disabled, --loading, --error (.button, .button--active, .button--disabled).",
       "verifiedAgainst": "CSS (BEM + custom properties — language-level, no framework).",
       "provedBy": []
     },
@@ -2017,7 +2020,7 @@
         "performance": "#section-7-performance",
         "accessibility": "#section-8-accessibility"
       },
-      "digest": "Use gsap.to/from/fromTo for imperative animations. In React, always use useGSAP() hook from @gsap/react with scope ref for automatic cleanup. Timelines sequence with position parameter. Animate only transforms + opacity for 60fps. Check prefers-reduced-motion. Import durations/easings from design tokens.",
+      "digest": "GSAP 3.13 + `@gsap/react` in Next.js. Use GSAP for ScrollTrigger, SVG morph/draw, complex timelines, SplitText and Draggable+Inertia; use Framer Motion for simple enter/exit, layout, gestures and AnimatePresence. NEVER animate one DOM element with both (they fight over inline styles). All GSAP code lives in `'use client'` components, inside `useGSAP()` (never `useEffect`) with ALWAYS `{ scope: containerRef }`, which cleans up automatically; handlers outside the callback need `contextSafe()`. Register plugins once at app init (`layout.tsx`/`providers.tsx`), not in components. Prefer `autoAlpha` over `opacity`; animate only transforms and opacity, never width/height/top/left; `gsap.quickTo()` for cursor followers. Honoring `prefers-reduced-motion` is MANDATORY (`gsap.matchMedia()`). Never hardcode durations or easings: import `durations`/`easings` from `@/lib/design-tokens`.",
       "verifiedAgainst": "GSAP 3.13 + @gsap/react.",
       "provedBy": []
     },
@@ -2051,7 +2054,7 @@
         "morphsvg": "#morphsvg",
         "drawsvg": "#drawsvg"
       },
-      "digest": "Flip for layout animations (getState then from). SplitText for char/word/line reveals (always revert on cleanup). MorphSVG for path morphing. DrawSVG for stroke animation. MotionPath for path-following. Draggable for drag with bounds/snap. Observer for gesture detection. Register all plugins before use.",
+      "digest": "GSAP 3.13 + @gsap/react: core and every plugin (Flip, SplitText, MorphSVG, DrawSVG, MotionPath, Draggable...) are free from the public `gsap` package (`npm install gsap @gsap/react`); the old `gsap@npm:@gsap/shockingly` private-registry instruction is obsolete. Call `gsap.registerPlugin(...)` ONCE at app init (`'use client'`); animate with `useGSAP` + `scope`. Flip: `Flip.getState()`, change the DOM, `Flip.from(state, { absolute: true })`; with ScrollTrigger, call `ScrollTrigger.refresh()` after the layout change. SplitText: `SplitText.create` with `autoSplit: true`, animate inside `onSplit`; it adds `<div>` wrappers that affect layout, and `useGSAP` reverts it. MorphSVG needs `<path>` elements (`convertToPath` for others); DrawSVG needs a visible stroke (not fill); ScrollToPlugin `autoKill: true`; Draggable `throwProps` needs InertiaPlugin; Observer normalizes wheel/touch/pointer.",
       "verifiedAgainst": "GSAP 3.13 + @gsap/react.",
       "provedBy": []
     },
@@ -2084,7 +2087,7 @@
         "pin": "#section-4-pinning",
         "batch": "#section-5-batch-processing"
       },
-      "digest": "Register ScrollTrigger plugin client-side only. Use scrub for scroll-linked progress. Pin sections with pin:true. Batch-process list items with ScrollTrigger.batch(). Call ScrollTrigger.refresh() after dynamic content. Kill all triggers in useGSAP cleanup.",
+      "digest": "GSAP 3.13 ScrollTrigger in Next.js: all code lives in 'use client' components inside useGSAP(() => {...}, { scope }), which auto-kills tweens and triggers on unmount (without it, use gsap.context() and ctx.revert()); orphaned triggers leak memory and break later routes. gsap.registerPlugin(ScrollTrigger) once at app init, never inside useEffect or loops; never ScrollTrigger.create() at module scope. Scrub needs ease 'none'; scrub: true is 1:1, use 0.3-1 in production. Pin: pin: true with anticipatePin: 1; pinSpacing: false only for intentional overlap; never nest pins. Use ScrollTrigger.batch for grids (20+ items), snap durations under 0.8s. Responsive: define both desktop and mobile cases, exclusive breakpoints (767/768). Call ScrollTrigger.refresh() after dynamic content, layout shifts, route changes and image onLoad; normalizeScroll(true) helps iOS Safari.",
       "verifiedAgainst": "GSAP 3.13 ScrollTrigger + @gsap/react.",
       "provedBy": []
     },
@@ -2112,7 +2115,7 @@
         "layout": "#root-layout--required-providers",
         "routing": "#app-directory-structure"
       },
-      "digest": "Server Components by default — only add 'use client' when needed (interactivity, browser APIs, hooks). Layouts persist across navigations. Parallel Routes with @folder for simultaneous views. Route Groups with (folder) to organize without affecting URL. Use generateMetadata() for dynamic SEO metadata.",
+      "digest": "Next.js 15 App Router, TypeScript only (no .js/.jsx). Server Components by default; add `'use client'` only for interaction (onClick, useState/useEffect/useRef), browser APIs, TanStack Query hooks and interactive shadcn/ui. `app/` is for routing only: business logic goes to `features/`, never in `page.tsx`. Never fetch data in a Client Component when a Server Component can, and never fetch in `useEffect`: use a Server Component or TanStack Query. Co-locate `loading.tsx` and `error.tsx` (`error.tsx` must be a Client Component) beside `page.tsx`. Server Components call the .NET backend directly using the dedicated `BACKEND_API_PREFIX` from `@/lib/api/prefixes`, never the same-origin proxy prefix used by Client Components; always check `res.ok`. Avoid `route.ts` API routes (use the .NET API). The root `layout.tsx` wraps children in `QueryProvider` and the sonner `Toaster`.",
       "verifiedAgainst": "Next.js 15.",
       "provedBy": []
     },
@@ -2140,7 +2143,7 @@
         "patterns": "#three-tier-hierarchy",
         "shadcn": "#tier-1--shadcnui-primitives"
       },
-      "digest": "Three tiers: components/ui is shadcn CLI output (never edit, wrap instead); components/ composes primitives with no domain knowledge; features/*/components knows the domain. 'use client' only for hooks, events or browser APIs; never pass raw API data as props — type and validate it first. The shared data table is specified once, in admin-app/data-table.md.",
+      "digest": "Three tiers (Next.js 16 + shadcn 4 CLI): `components/ui/` is shadcn CLI output (add via `npx shadcn@latest add`, NEVER edit because the CLI regenerates it; wrap it in `components/` instead); `components/` holds shared composed components with no business logic and NEVER imports from `features/`; `features/*/components/` is feature-scoped and may know the domain. Add `'use client'` only if the component uses hooks, events or browser APIs (not on every component: unnecessary client JS). Never pass raw API/fetch data as props: transform it into typed props and validate with Zod first. Props interfaces always accept an optional `className` for Tailwind override. The shared data table is specified once in `admin-app/data-table.md`: do not write a second `components/data-table.tsx`; a feature list is a Tier 3 component that owns the columns and the URL-to-table mapping.",
       "verifiedAgainst": "Next.js 16 + shadcn 4 CLI (the code blocks typecheck under `tsc --strict`).",
       "provedBy": []
     },
@@ -2168,7 +2171,7 @@
         "server": "#server-component--tanstack-query-handoff",
         "client": "#usequery-hook-pattern"
       },
-      "digest": "Server Components: fetch() with caching tags for static/ISR. Client Components: TanStack Query useQuery/useMutation for client-side state. Server Actions for mutations from Client Components. Never fetch in useEffect — use TanStack Query. Set revalidate intervals for ISR. Use React Suspense for loading states.",
+      "digest": "Server Components do the initial load and call the .NET backend directly with BACKEND_API_PREFIX; Client Components never call the backend — they hit a same-origin proxy route with PROXY_API_PREFIX. Two named constants, never one shared API_PREFIX: the side that drifts breaks silently at runtime. Client data is TanStack Query 5: useQuery for reads, useMutation for writes, then invalidateQueries({ queryKey: userKeys.lists() }) (object syntax). Keys come from a per-feature key factory, never hardcoded ['users']. Every response is parsed with a Zod schema. QueryClient: staleTime 60s, retry 1, created once in useState; the Server Component passes initialData to the client hook. FORBIDDEN: useEffect(() => fetch…, []) and fetching a whole collection to page/sort/filter in the browser — page on the server, query in the URL.",
       "verifiedAgainst": "Next.js 15 + TanStack Query 5 + Zod 4.",
       "provedBy": []
     },
@@ -2227,8 +2230,8 @@
         "scroll": "#section-3-scroll-animations",
         "accessibility": "#section-7-wcag-accessibility-mandatory"
       },
-      "digest": "Canonical Framer Motion variants (fadeIn, slideIn, scaleIn, stagger, pageTransition) with design token bridge. Use whileInView for scroll reveals. Respect prefers-reduced-motion via useReducedMotion() — strip transforms, keep opacity.",
-      "verifiedAgainst": "Motion for React 12 (`motion`, imports from `motion/react`).",
+      "digest": "Component-level motion with Motion for React (the stack table's 'Framer Motion', its former name; motion 12+, current npm major 14): npm install motion and import from 'motion/react'. framer-motion is not deprecated (motion depends on it and re-exports it), but a codebase keeps one import path, motion/react, and never adds framer-motion alongside it. Variants live in motion/variants.ts (fadeIn, slideInUp/Down/Left/Right, scaleIn, staggerContainer, staggerItem, pageTransition) and take durations and easings from @/lib/design-tokens (fast 0.15, base 0.3); never hardcode duration numbers or easing arrays. Scroll reveals: whileInView with viewport once: true for simple cases, useInView for control. Page transitions: AnimatePresence mode='wait' keyed by usePathname(), subtle (y: 8), inside a 'use client' PageTransition provider -- the root app/layout.tsx stays a Server Component (no 'use client', keeps metadata) and just renders the provider. WCAG is mandatory: useReducedMotion() strips x/y/scale and keeps opacity, plus a prefers-reduced-motion CSS fallback. Skeletons use CSS animate-pulse, not motion. Limit motion to 3-5 moments per page. Scroll-driven scenes (ScrollTrigger, Lenis) belong to GSAP; never share an element with it.",
+      "verifiedAgainst": "Motion for React 12+ (`motion`, imports from `motion/react`); the npm registry and the `motion`/`framer-motion`/`motion-dom` 14.0.0 typings were read on 2026-10-03 (`motion/react` re-exports `framer-motion`, which re-exports `motion-dom`: `Variants`, `useInView`, `AnimatePresence`, `useReducedMotion`, `staggerChildren`/`delayChildren` all present). The TSX snippets are documentary.",
       "provedBy": []
     },
     {
@@ -2255,7 +2258,7 @@
         "files": "#complete-reference-table",
         "components": "#complete-reference-table"
       },
-      "digest": "Pages: lowercase kebab-case (user-profile/page.tsx). Components: PascalCase (UserProfile.tsx). Hooks: camelCase with 'use' prefix (useUserProfile.ts). API routes: kebab-case. Types: PascalCase. No default exports except page.tsx and layout.tsx. Feature-based co-location preferred.",
+      "digest": "Next.js naming (prevents Linux case-sensitivity bugs). File names are ALWAYS kebab-case (`user-card.tsx`, never `UserCard.tsx`); exports are PascalCase for components (`UserCard`) and camelCase with a `use` prefix for hooks, whose files are kebab-case too (`use-users.ts` -> `useUsers`, `use-user.ts` for a single GET, `use-create-user.ts`, `use-update-user.ts`, `use-delete-user.ts`). Zod schema files end in `.schemas.ts` (`createUserSchema`) and type files in `.types.ts`, with types derived via `z.infer` instead of hand-written duplicates. Components use named exports (`export function UserCard`, not `export default`); `page.tsx` exports `default`. A feature `index.ts` re-exports. Never mix cases within a category (no `UserCard.tsx` next to `user-profile.tsx`).",
       "verifiedAgainst": "Next.js 15 + Zod 4.",
       "provedBy": []
     },
@@ -2283,7 +2286,7 @@
         "auth": "#route-handlers-bff-pattern",
         "caching": "#react-query--neon"
       },
-      "digest": "Middleware for auth redirects (use matcher config). next/image for all images (auto-optimization). next/link for navigation (prefetching). loading.tsx for Suspense boundaries per route. error.tsx for error boundaries. Use unstable_cache for expensive server computations with tag-based revalidation.",
+      "digest": "Next.js 15 App Router (not Pages Router): Server Components by default, `'use client'` only for state, effects, events or browser APIs; colocate `loading.tsx` and `error.tsx` (the latter MUST be `'use client'`) with `page.tsx`. Route Handlers act as a BFF: check `auth.getSession()` (401 if absent) and delegate to the .NET API; database access lives in the .NET backend via EF Core, NEVER in Next.js route handlers. Validate input with Zod on client and server (`safeParse`, 400). Fetch with TanStack Query (`useQuery`/`useMutation`, `staleTime: 60_000`, `retry: 1`, `invalidateQueries` on success), never `useEffect` for data fetching. Forms: react-hook-form + `zodResolver`. shadcn is copied via `npx shadcn@latest add`, not an npm dependency. Keep `\"strict\": true` plus `noUncheckedIndexedAccess` (agents self-correct from compiler errors); no `any` for API responses (Zod schema + `z.infer`).",
       "verifiedAgainst": "Next.js 15 + TanStack Query 5 + Zod 4 + react-hook-form 7.",
       "provedBy": []
     },
@@ -2310,7 +2313,7 @@
         "structure": "#canonical-folder-tree",
         "organization": "#feature-index-pattern"
       },
-      "digest": "src/app/ for routes, src/components/ for shared UI, src/lib/ for utilities, src/hooks/ for custom hooks, src/types/ for TypeScript types. Co-locate feature components near their routes. Public API via components/index.ts. Avoid barrel files in app/ directory. Keep pages thin — logic in hooks and utilities.",
+      "digest": "Next.js 15 App Router, src/ layout with the @/ alias, feature-based. src/app/ is routing only (layout, page, loading, error) and imports from features/, never the reverse. Each src/features/{feature-name}/ holds components/, hooks/ (TanStack Query hooks such as use-users.ts, use-create-user.ts), types/ (*.types.ts plus *.schemas.ts with Zod and z.infer) and an index.ts that is the explicit public API: import from '@/features/users', never from deep paths. NEVER import one feature from another (extract to components/ or lib/); components/ must not import features/, is presentation only with NO business logic, and components/ui/ is shadcn, never edited directly. Shared hooks/ make no API calls. lib/ holds api-client.ts (typed fetch wrapper for the .NET API) and query-client.tsx; types/api.ts has PaginatedResponse<T> and ApiError; env.mjs validates env vars with Zod.",
       "verifiedAgainst": "Next.js 15 (App Router, `src/` layout).",
       "provedBy": []
     },
@@ -2338,7 +2341,7 @@
         "patterns": "#state-decision-tree",
         "server": "#server-state-tanstack-query"
       },
-      "digest": "TanStack Query for server state (caching, background sync, optimistic updates). Zustand for global client state (auth, theme, user preferences). URL params for shareable UI state (filters, pagination). useState for local component state. Avoid Redux — Zustand is sufficient for most Next.js use cases.",
+      "digest": "Server state (anything from the .NET API) lives in TanStack Query, never copied into `useState` via `useEffect`; derive state from server data instead of syncing it. Local UI state (modal open, form step, selected id) uses `useState`. A list's page, sort and filters, and a page's active tab, go in the URL (`searchParams`), never `useState`, so a refresh or shared link reopens the same view. Do not use React Context for server state (no caching or dedup); Context is for truly global theme, auth user or locale, and prop drilling 2-3 levels is fine. NEVER install Zustand or Redux before exhausting Server Components + TanStack Query. Zustand is justified only if ALL hold: state needed in 5+ unrelated components, complex update logic, Context causes measurable re-render problems, and the state is not from the server.",
       "verifiedAgainst": "Next.js 15 + TanStack Query 5 + Zustand 5.",
       "provedBy": []
     },
@@ -2542,8 +2545,8 @@
         "deployment": "#zero-downtime-deploys",
         "ssh": "#triggering-a-deploy-via-ssh--api"
       },
-      "digest": "Coolify is the self-hosted Docker PaaS. No MCP/CLI exists — all access is via SSH into the VPS, hitting the Coolify API at localhost:8000/api/v1 with a server-side token (never printed, never leaves the SSH session). Configure environment variables in Coolify UI/API — not in Dockerfile. Configure /health endpoint for health checks. HTTPS via Let's Encrypt automatic (Traefik). Redeploys trigger via GET /deploy?uuid={uuid} over SSH.",
-      "verifiedAgainst": ".NET 10 + Next.js 15 + Node 22 (Docker base images).",
+      "digest": "Coolify is the self-hosted Docker PaaS. We use no Coolify MCP/CLI — all access is via SSH into the VPS, hitting the Coolify API at localhost:8000/api/v1 with a server-side token (never printed, never leaves the SSH session). Configure environment variables in Coolify UI/API — not in Dockerfile. Configure /health endpoint for health checks. HTTPS via Let's Encrypt automatic (Traefik). Redeploys trigger via POST /api/v1/deploy?uuid={uuid} over SSH (Coolify 4.3.23 answers GET with \"This endpoint has changed to a POST request\" and deploys nothing); a queued deploy returns a deployment_uuid, its absence means nothing was deployed.",
+      "verifiedAgainst": ".NET 10 + Next.js 15 + Node 22 (Docker base images) + Coolify 4.x API. The `POST /api/v1/deploy` contract was checked against the Coolify docs/OpenAPI on 2026-10-03, and Coolify 4.3.23 was observed answering `GET /deploy` with \"This endpoint has changed to a POST request\"; Dockerfiles and snippets are documentary.",
       "provedBy": []
     },
     {
@@ -2606,7 +2609,7 @@
         "setup": "#install-pgrag",
         "pipeline": "#full-rag-pipeline-example"
       },
-      "digest": "Use pgrag extensions (rag, rag_bge_small_en_v15, rag_jina_reranker_v1_tiny_en) for chunking, embedding, search, and reranking entirely in SQL. No external embedding service needed for basic RAG. Combine with pgvector HNSW indexes for production performance.",
+      "digest": "pgrag (Neon `rag` extension family) is EXPERIMENTAL: use it for prototyping and simple SQL-only RAG, not production without testing. Run `SET neon.allow_unstable_extensions='true'` before `CREATE EXTENSION rag CASCADE` (also `rag_bge_small_en_v15`, `rag_jina_reranker_v1_tiny_en`). Local bge-small embeddings are 384 dims, OpenAI text-embedding-3-small is 1536: NEVER mix models in one column or use the local one when the app uses another model (dimension mismatch breaks search). Chunk with `rag.chunks_by_character_count` (1000 chars, 200 overlap); `embedding_for_passage` for documents, `embedding_for_query` for queries; create the pgvector HNSW index (m=16, ef_construction=64) after the initial load; rerank with `rerank_distance` (sort ASC). Keep API keys out of SQL scripts. For production .NET needing custom logic, use a typed MAF tool over pgvector (`ai-agents-rag-custom-pgvector`).",
       "verifiedAgainst": "Neon pgrag (`rag` extension family — experimental, see Core Rules).",
       "provedBy": []
     },
@@ -2635,8 +2638,8 @@
         "setup": "#enable-pgvector",
         "queries": "#similarity-search"
       },
-      "digest": "Enable: CREATE EXTENSION vector. Define column as vector(1536) for OpenAI embeddings. Create HNSW index with tuned maintenance_work_mem. Use direct SQL for similarity search. Batch insert embeddings (100 at a time). RLS policies apply to vector queries.",
-      "verifiedAgainst": ".NET 10 + Pgvector.EntityFrameworkCore + pgvector (HNSW).",
+      "digest": "pgvector on Neon with .NET VSA: packages Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3 + Pgvector.EntityFrameworkCore 0.3.0 (snake_case columns mapped with HasColumnName, no naming-convention package); HasPostgresExtension('vector') in OnModelCreating emits CREATE EXTENSION in the migration. Map the column as Pgvector `Vector` (`vector(1536)` for text-embedding-3-small; EF does not map float[] or ReadOnlyMemory<float>) and call `npgsql.UseVector()` inside UseNpgsql (NpgsqlDataSourceBuilder.UseVector only for raw Npgsql). ALWAYS an HNSW index (HasMethod('hnsw'), vector_cosine_ops, m 16, ef_construction 64); the operator class must match the LINQ function (CosineDistance/L2Distance/MaxInnerProduct) or Postgres seq-scans. Query in the slice handler through ApplicationDbContext: `d.Embedding!.CosineDistance(query)`, filter by distance <= 1 - minSimilarity, OrderBy distance ASC (similarity = 1 - distance, never ORDER BY similarity DESC), return Result; no DocumentRepository, no raw SQL from C# (SQL functions such as match_documents/hybrid search only with a decisions.md justification). Ids from Guid.CreateVersion7() in the handler, never gen_random_uuid() defaults. ef_search (default 40) on the pooled endpoint needs SET LOCAL inside the query's transaction.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3 + Pgvector.EntityFrameworkCore 0.3.0 + Microsoft.Extensions.AI 10.9.0 (ai-pin 2026-09-08). The entity, configuration, DbContext, search-handler and raw-Npgsql blocks compile with `TreatWarningsAsErrors` (handler over the `Result`/`IHandler` of `result-pattern.md`/`vertical-slice.md`), and the handler's query shape was translated with `ToQueryString()` to `ORDER BY d.embedding <=> @query`; the SQL (index DDL, `ef_search`, the two SQL functions) is documentary, checked against the pgvector README.",
       "provedBy": []
     },
     {
@@ -2664,8 +2667,8 @@
         "setup": "#neon-cli-setup",
         "connection": "#connection-strings"
       },
-      "digest": "Use neonctl CLI for project management and connection strings. Two connection strings: pooled (-pooler) for application code, direct for EF Core migrations. Configure connection retry for scale-to-zero cold starts. Use database branches for PR previews.",
-      "verifiedAgainst": ".NET 10 + Npgsql/EF Core 10 + neonctl.",
+      "digest": "Neon serverless Postgres with .NET/EF Core. Two connection strings read through IConfiguration: `ConnectionStrings:DefaultConnection` = pooled `-pooler` endpoint for application traffic (Neon's DATABASE_URL) and `ConnectionStrings:MigrationConnection` = direct endpoint for migrations, `dotnet ef` and advisory locks (Neon's DATABASE_URL_UNPOOLED; PgBouncer does not support advisory locks; the `IDesignTimeDbContextFactory` reads it via appsettings + AddUserSecrets + AddEnvironmentVariables). Never hardcode or commit them: user-secrets in development, Coolify env vars (`ConnectionStrings__DefaultConnection`) in production, appsettings.json keeps empty values. Use the keyword format (`Host=...;SSL Mode=Require`): Npgsql 10 rejects the console's `postgresql://` URI, and `Trust Server Certificate` is obsolete (does nothing). Scale-to-zero suspends compute after 5 minutes idle by default (about 300-500ms cold start), so configure `EnableRetryOnFailure(maxRetryCount: 5, maxRetryDelay: 10s)` and `CommandTimeout(30)`; suspend timeout is set at branch creation (`--suspend-timeout`, `--cu` range) or for an existing compute via Console/API (`suspend_timeout_seconds`, 60-604800), never by recreating main. Branches are copy-on-write: never leave them without expiration (`--expires-at`); `feature/*` 7 days, `ci-*` 1 day, `main` and `dev` never. neonctl: `auth`, `branches create|reset|delete`.",
+      "verifiedAgainst": ".NET 10 (SDK 10.0.400-preview) + Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3 + neonctl. The DbContext registration, design-time factory and cold-start blocks compile with `TreatWarningsAsErrors`; that Npgsql 10 rejects `postgresql://` URIs and marks `Trust Server Certificate` as \"no longer needed and does nothing\" was measured on 10.0.3; the suspend-timeout API and `--cu` ranges were checked against the Neon docs (context7). neonctl commands are documentary.",
       "provedBy": []
     },
     {

package/framework/standards/ai-agents/evals-with-cache.md

@@ -252,7 +252,7 @@ O detector é por caminho, e as três formas conhecidas de escapar dele estão d
 alta, porque um detector que se apresenta como completo e não é vale menos que nenhum:
 
 1. **eval trivialmente verde** — um cenário só, asserção vazia. É a mesma classe de contorno
-   de um teste vazio, e a resposta é a rubrica de prova, não uma segunda regra determinística
+   de um teste vazio, e a resposta é o avaliador do Gate 3 (bloqueador `teste`: teste que não morde), não uma segunda regra determinística
    que também seria contornável;
 2. **prompt publicado direto no banco**, sem tocar arquivo;
 3. **modelo trocado por variável de ambiente** no provedor de deploy — invisível ao

package/framework/standards/ai-agents/llm-runtime-defaults.md

@@ -11,7 +11,7 @@
 
 ## Fronteira com o Model Registry
 
-`ai-agents-providers-model-registry` é **Layer 0** (sempre carregado) e continua dono do **schema**:
+`ai-agents-providers-model-registry` é **Layer 0** (lido pela persona `maf-expert` e pela rule `ai-agents-standards`) e continua dono do **schema**:
 o formato do documento, `defaultAlias`, o fallback e a tabela de providers. **Este** standard é dono
 dos **valores e dos botões de runtime**: timeout, retry, strict, amostragem, esforço de raciocínio e
 o pin de versão do SDK.