@polymorphism-tech/morph-spec 8.38.0 → 8.40.0

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/DeltaIngestTests.cs

@@ -3,47 +3,23 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios do <see cref="DeltaIngest"/> (T14). A afirmacao central e uma so, e ela e
-/// <b>demonstrada</b> contra um acervo, nao afirmada: <b>ingerir a mesma coisa duas vezes nao
-/// duplica nada, e mudar um campo atualiza em vez de acrescentar</b>.
-/// </summary>
 public sealed class DeltaIngestTests
 {
-    /// <summary>Um documento de acervo: identidade estavel + conteudo que muda.</summary>
     private sealed record Doc(string Slug, string Body);
 
     private static string Key(Doc d) => d.Slug;
 
-    /// <summary>
-    /// Hash de conteudo do teste. Nao precisa ser criptografico — precisa mudar quando o
-    /// conteudo muda, que e a unica propriedade que o <see cref="DeltaIngest"/> usa.
-    /// </summary>
     private static string Hash(Doc d) => $"h:{d.Body.Length}:{d.Body.GetHashCode(StringComparison.Ordinal)}";
 
-    /// <summary>
-    /// Um acervo minusculo que <b>aplica</b> o plano — e a unica forma de a idempotencia ser
-    /// medida no que ficou guardado, em vez de nos nomes das listas do plano.
-    /// </summary>
-    /// <remarks>
-    /// Modela um acervo de verdade: <c>Added</c> vira <b>INSERT</b> numa lista de linhas,
-    /// <c>Updated</c> vira UPDATE da linha existente e <c>Removed</c> vira DELETE. O indice de
-    /// hashes e mantido a parte, como um indice de banco. Isso importa: se o acervo fizesse
-    /// upsert de tudo, uma re-ingestao que classificasse errado sairia invisivel — aqui ela
-    /// aparece como linha duplicada, que e o defeito real que esta task combate.
-    /// </remarks>
     private sealed class Corpus
     {
         private readonly List<Doc> _rows = [];
         private readonly Dictionary<string, string> _index = new(StringComparer.Ordinal);
 
-        /// <summary>Quantos embeddings foram pagos ao todo. Nao sobe numa ingestao no-op.</summary>
         public int EmbeddingCalls { get; private set; }
 
-        /// <summary>As linhas guardadas, na ordem em que entraram.</summary>
         public IReadOnlyList<Doc> Rows => _rows;
 
-        /// <summary>O indice lookup-key para hash, que alimenta o proximo plano.</summary>
         public IReadOnlyDictionary<string, string> Hashes => _index;
 
         public DeltaPlan<Doc> Ingest(IEnumerable<Doc> incoming)
@@ -52,21 +28,21 @@ public sealed class DeltaIngestTests
 
             foreach (var doc in plan.Added)
             {
-                _rows.Add(doc);                 // INSERT
+                _rows.Add(doc);
                 _index[doc.Slug] = Hash(doc);
                 EmbeddingCalls++;
             }
 
             foreach (var doc in plan.Updated)
             {
-                _rows[_rows.FindIndex(r => r.Slug == doc.Slug)] = doc;   // UPDATE
+                _rows[_rows.FindIndex(r => r.Slug == doc.Slug)] = doc;
                 _index[doc.Slug] = Hash(doc);
                 EmbeddingCalls++;
             }
 
             foreach (var slug in plan.Removed)
             {
-                _rows.RemoveAll(r => r.Slug == slug);                    // DELETE
+                _rows.RemoveAll(r => r.Slug == slug);
                 _index.Remove(slug);
             }
 
@@ -81,14 +57,6 @@ public sealed class DeltaIngestTests
         new("garantia", "Garantia de 12 meses."),
     ];
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria: os quatro baldes
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Os quatro baldes numa unica passada: um item novo, um com hash mudado, um com hash
-    /// igual e uma chave que sumiu da origem.
-    /// </summary>
     [Fact]
     public void TheFourBucketsAreSortedInASinglePass()
     {
@@ -109,7 +77,6 @@ public sealed class DeltaIngestTests
         Assert.Equal(3, plan.WriteCount);
     }
 
-    /// <summary>Acervo vazio: tudo e novo, nada e removido.</summary>
     [Fact]
     public void AnEmptyCorpusMakesEverythingNew()
     {
@@ -121,12 +88,6 @@ public sealed class DeltaIngestTests
         Assert.Empty(plan.Removed);
     }
 
-    /// <summary>
-    /// Remessa vazia com acervo cheio: <b>tudo</b> sai em <c>Removed</c>. E o comportamento
-    /// correto e tambem o mais perigoso — e por isso o plano e um plano: quem decide se
-    /// aplica um <c>Removed</c> de 100% e o projeto, que sabe se a origem realmente esvaziou
-    /// ou se o crawler falhou.
-    /// </summary>
     [Fact]
     public void AnEmptyShipmentAgainstAFullCorpusRemovesEverything()
     {
@@ -140,15 +101,6 @@ public sealed class DeltaIngestTests
         Assert.Empty(plan.Updated);
     }
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria: IDEMPOTENCIA, medida no acervo
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// <b>A prova principal.</b> Ingerir a mesma remessa duas vezes: na segunda o plano e
-    /// vazio nos tres baldes de escrita, o acervo tem exatamente os mesmos documentos e
-    /// <b>nenhum embedding a mais foi pago</b>.
-    /// </summary>
     [Fact]
     public void IngestingTheSameShipmentTwiceLeavesTheCorpusUntouched()
     {
@@ -168,21 +120,14 @@ public sealed class DeltaIngestTests
         Assert.Equal(0, second.WriteCount);
         Assert.Equal(3, second.Unchanged.Count);
 
-        // O acervo e o custo nao se mexeram: 3 documentos, os mesmos, 3 embeddings ao todo.
-        Assert.Equal(3, corpus.Rows.Count);   // <- a linha que morre se a mesma coisa duplicar
+        Assert.Equal(3, corpus.Rows.Count);
         Assert.Equal(before, corpus.Rows.OrderBy(d => d.Slug, StringComparer.Ordinal));
         Assert.Equal(3, corpus.EmbeddingCalls);
 
-        // E uma terceira, para que "duas vezes" nao pareca coincidencia.
         Assert.True(corpus.Ingest(shipment).IsNoOp);
         Assert.Equal(3, corpus.EmbeddingCalls);
     }
 
-    /// <summary>
-    /// <b>Mudar um campo atualiza, nao acrescenta.</b> A contagem do acervo nao sobe, o slug
-    /// continua unico e o corpo e o novo — que e a diferenca entre uma ingestao delta e a
-    /// ingestao apaga-tudo que este tipo existe para substituir.
-    /// </summary>
     [Fact]
     public void ChangingOneFieldUpdatesInPlaceInsteadOfAppending()
     {
@@ -192,7 +137,7 @@ public sealed class DeltaIngestTests
         Doc[] revised =
         [
             new("politica-troca", "Trocas em ate 7 dias."),
-            new("prazo-entrega", "Entrega em 1 dia util."),   // <- unico campo alterado
+            new("prazo-entrega", "Entrega em 1 dia util."),
             new("garantia", "Garantia de 12 meses."),
         ];
 
@@ -203,22 +148,15 @@ public sealed class DeltaIngestTests
         Assert.Empty(plan.Removed);
         Assert.Equal(2, plan.Unchanged.Count);
 
-        Assert.Equal(3, corpus.Rows.Count);                              // nao apendou
-        Assert.Single(corpus.Rows, d => d.Slug == "prazo-entrega");      // uma so linha
+        Assert.Equal(3, corpus.Rows.Count);
+        Assert.Single(corpus.Rows, d => d.Slug == "prazo-entrega");
         Assert.Equal("Entrega em 1 dia util.", corpus.Rows.Single(d => d.Slug == "prazo-entrega").Body);
         Assert.Equal(4, corpus.EmbeddingCalls);                          // 3 iniciais + 1 mudanca
 
-        // E a re-ingestao da remessa revisada volta a ser no-op.
         Assert.True(corpus.Ingest(revised).IsNoOp);
         Assert.Equal(4, corpus.EmbeddingCalls);
     }
 
-    /// <summary>
-    /// A mesma afirmacao dita como <b>contagem de linhas</b>, e antes de qualquer outra
-    /// asserçao: re-ingerir nao insere uma segunda copia. E a linha que fica vermelha com
-    /// "6" no lugar de "3" quando a comparacao por lookup-key se quebra — a duplicacao
-    /// literal, e nao um nome de balde trocado.
-    /// </summary>
     [Fact]
     public void ReIngestingDoesNotInsertASecondCopyOfTheSameDocument()
     {
@@ -233,10 +171,6 @@ public sealed class DeltaIngestTests
         Assert.Equal(3, corpus.EmbeddingCalls);
     }
 
-    /// <summary>
-    /// Idempotencia sobrevive a reordenacao: a mesma remessa embaralhada continua sendo
-    /// no-op. A identidade e a chave, nunca a posicao na lista.
-    /// </summary>
     [Fact]
     public void OrderDoesNotMakeAShipmentLookDifferent()
     {
@@ -249,15 +183,6 @@ public sealed class DeltaIngestTests
         Assert.Equal(3, corpus.EmbeddingCalls);
     }
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria: chave duplicada falha de forma explicita
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Chave repetida derruba o plano dizendo a chave <b>e as duas posicoes</b>. Ficar com o
-    /// ultimo gravaria um dos dois ao acaso; deduplicar sozinho esconderia o defeito da
-    /// origem, que e onde ele tem conserto.
-    /// </summary>
     [Fact]
     public void ADuplicateLookupKeyFailsNamingTheKeyAndBothPositions()
     {
@@ -277,7 +202,6 @@ public sealed class DeltaIngestTests
         Assert.Contains("deixa de ser deterministico", failure.Message, StringComparison.Ordinal);
     }
 
-    /// <summary>Chave em branco colapsaria itens distintos num so — e recusada.</summary>
     [Theory]
     [InlineData("")]
     [InlineData("   ")]
@@ -289,10 +213,6 @@ public sealed class DeltaIngestTests
         Assert.Contains("posicao 0", failure.Message, StringComparison.Ordinal);
     }
 
-    /// <summary>
-    /// Hash em branco e recusado: sem versao nao ha como separar "nao mudou" de "mudou", e
-    /// tratar a ausencia como "mudou" reintroduz o re-embedding de tudo — o defeito original.
-    /// </summary>
     [Fact]
     public void ABlankContentHashIsRefusedInsteadOfMeaningChanged()
     {
@@ -302,7 +222,6 @@ public sealed class DeltaIngestTests
         Assert.Contains("politica-troca", failure.Message, StringComparison.Ordinal);
     }
 
-    /// <summary>Argumento nulo e defeito de chamada, e falha na chamada.</summary>
     [Fact]
     public void TheRequiredArgumentsAreNotOptional()
     {
@@ -314,15 +233,6 @@ public sealed class DeltaIngestTests
         Assert.Throws<ArgumentNullException>(() => DeltaIngest.Plan(ThreeDocs(), Key, Hash, null!));
     }
 
-    // ---------------------------------------------------------------------------------
-    // Identidade e versao sao perguntas diferentes
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// A comparacao de chave e <b>ordinal</b>: <c>Politica</c> e <c>politica</c> sao dois
-    /// documentos. Deixar a cultura decidir faria o mesmo corpus produzir planos diferentes
-    /// conforme a maquina que roda a ingestao.
-    /// </summary>
     [Fact]
     public void KeysAreComparedOrdinallySoThePlanDoesNotDependOnTheMachine()
     {
@@ -341,11 +251,6 @@ public sealed class DeltaIngestTests
         Assert.Equal(["politica-troca"], plan.Removed);
     }
 
-    /// <summary>
-    /// O plano nao le o corpo do item: um documento cuja chave e hash nao mudaram e
-    /// <c>Unchanged</c> ainda que o objeto seja outra instancia. E o que permite ao acervo
-    /// reprocessar so o que mudou de verdade.
-    /// </summary>
     [Fact]
     public void EqualityIsDecidedByKeyAndHashNotByInstance()
     {
@@ -357,7 +262,6 @@ public sealed class DeltaIngestTests
         Assert.True(corpus.Ingest(reconstructed).IsNoOp);
     }
 
-    /// <summary>A remessa e enumerada uma unica vez — importa quando ela vem de um stream.</summary>
     [Fact]
     public void TheShipmentIsEnumeratedExactlyOnce()
     {

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/Evals/EvalAssertionTests.cs

@@ -4,35 +4,11 @@ using Xunit;
 
 namespace Morph.AiKit.Tests.Evals;
 
-/// <summary>
-/// A REGUA, testada contra a resposta ERRADA.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Este arquivo nasceu de um achado do Gate 3: das seis <see cref="EvalAssertionKind"/>,
-/// afrouxar CINCO para sempre-passar nao matava um unico teste. A suite continuava
-/// "152 total, 0 falhou" com o motor de assercao praticamente inerte — e duas das cinco
-/// (<c>NoPii</c> e <c>JsonHasKey</c>) sao usadas pelo dataset commitado, ou seja, os quatro
-/// cenarios exemplares dependiam de reguas que nunca haviam sido provadas.
-/// </para>
-/// <para>
-/// A causa e a mesma de todo canario inerte desta base: testava-se que a assercao APROVA o
-/// que deve aprovar, nunca que ela REPROVA o que deve reprovar. Uma regua so separa duas
-/// coisas se for exercitada dos DOIS lados — e a que so viu o lado bom e indistinguivel de
-/// <c>return true</c>.
-/// </para>
-/// <para>
-/// Por isso cada teste aqui carrega o PAR: a resposta que passa e a resposta que deveria
-/// reprovar. Afrouxar qualquer <see cref="EvalAssertionKind"/> mata o teste que a nomeia.
-/// </para>
-/// </remarks>
 public sealed class EvalAssertionTests
 {
-    /// <summary>Resposta so de texto — a superficie que as assercoes de texto leem.</summary>
     private static ChatResponse Text(string text)
         => new(new ChatMessage(ChatRole.Assistant, text));
 
-    /// <summary>Resposta que escolheu uma ferramenta, com argumentos.</summary>
     private static ChatResponse Tool(string name, params (string Key, object? Value)[] args)
     {
         var arguments = new Dictionary<string, object?>(StringComparer.Ordinal);
@@ -45,8 +21,6 @@ public sealed class EvalAssertionTests
         return new ChatResponse(message);
     }
 
-    // ---------------------------------------------------------------- Contains
-
     [Fact]
     public void ContainsSeparatesTheAnswerThatCarriesTheTextFromTheOneThatDoesNot()
     {
@@ -68,8 +42,6 @@ public sealed class EvalAssertionTests
         Assert.False(assertion.Evaluate(Text("ola")).Passed);
     }
 
-    // ------------------------------------------------------------- NotContains
-
     [Fact]
     public void NotContainsSeparatesTheCleanAnswerFromTheOneThatLeaksTheForbiddenText()
     {
@@ -82,8 +54,6 @@ public sealed class EvalAssertionTests
         Assert.Contains("desconto", reproved.Reason, StringComparison.Ordinal);
     }
 
-    // -------------------------------------------------------------- JsonHasKey
-
     [Fact]
     public void JsonHasKeySeparatesTheObjectThatCarriesTheKeyFromTheOneThatDoesNot()
     {
@@ -109,15 +79,12 @@ public sealed class EvalAssertionTests
     [Fact]
     public void JsonHasKeyReprovesAJsonArrayEvenWhenItParses()
     {
-        // Um array parseia como JSON valido: se a regua so perguntasse "parseia?", ela
-        // aprovaria uma resposta em que a chave nao pode nem existir.
+        // Um array e JSON valido: a regua tem de cobrar a chave, nao so o parse.
         var assertion = new EvalAssertion { Name = "tem-total", Kind = EvalAssertionKind.JsonHasKey, Target = "total" };
 
         Assert.False(assertion.Evaluate(Text("""[1, 2, 3]""")).Passed);
     }
 
-    // ------------------------------------------------------------------- NoPii
-
     [Theory]
     [InlineData("Entre em contato pelo lucas@example.com quando puder.", "e-mail")]
     [InlineData("O CPF do titular e 123.456.789-01.", "CPF")]
@@ -139,8 +106,6 @@ public sealed class EvalAssertionTests
         Assert.True(assertion.Evaluate(Text("Bom dia! Como posso ajudar voce hoje?")).Passed);
     }
 
-    // -------------------------------------------------------------- ToolCalled
-
     [Fact]
     public void ToolCalledSeparatesTheRightToolFromAnotherToolAndFromNoToolAtAll()
     {
@@ -155,8 +120,6 @@ public sealed class EvalAssertionTests
         Assert.False(assertion.Evaluate(Text("vou escalar para um humano")).Passed);
     }
 
-    // ------------------------------------------------------------ ToolArgument
-
     [Fact]
     public void ToolArgumentSeparatesTheRightArgumentFromTheWrongValueAndTheMissingKey()
     {
@@ -179,13 +142,9 @@ public sealed class EvalAssertionTests
             "ToolArgument aceitou uma chamada sem a CHAVE exigida");
     }
 
-    // ------------------------------------- o veredito diz QUEM julgou (B2)
-
     [Fact]
     public void EveryOutcomeCarriesTheNameAndTheKindOfTheAssertionThatProducedIt()
     {
-        // Sem este carimbo, uma falha chega a jusante como contador e o sumario nao consegue
-        // nomear nada — foi assim que o eval mordia anonimamente.
         var assertion = new EvalAssertion { Name = "saudacao", Kind = EvalAssertionKind.Contains, Value = "Bom dia" };
 
         foreach (var outcome in new[] { assertion.Evaluate(Text("Bom dia")), assertion.Evaluate(Text("nada")) })

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/Evals/EvalCacheMissTests.cs

@@ -4,16 +4,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests.Evals;
 
-/// <summary>
-/// Miss de cache sem credencial REPROVA, nomeado. Jamais <c>skip</c>.
-/// </summary>
-/// <remarks>
-/// A tentacao do <c>skip</c> e real ("nao da para avaliar, entao nao avalio") e recria
-/// exatamente o buraco que este harness fechou duas vezes: gate verde sobre verificacao que
-/// nao aconteceu. E ha razao positiva: em CI, com cache commitada, um miss significa UMA
-/// coisa so — o prompt ou o modelo mudou e ninguem regravou. O miss e o veredito, nao o
-/// obstaculo.
-/// </remarks>
 public sealed class EvalCacheMissTests
 {
     private static async Task<EvalWorkspace> SeededAsync(params string[] scenarioNames)
@@ -41,21 +31,16 @@ public sealed class EvalCacheMissTests
     {
         using var ws = await SeededAsync("a-primeiro");
 
-        // Cenario NOVO, que a cache nunca viu — a situacao literal de "mudou o prompt e
-        // ninguem regravou". O prefixo "b-" e deliberado: os cenarios rodam em ordem ordinal
-        // de caminho, e o teste abaixo depende de o cenario BOM ter rodado antes do miss.
+        // Prefixo "b-": os cenarios rodam em ordem ordinal de caminho, e o miss tem de vir depois do cenario bom.
         ws.WriteScenario("triagem", "acme", "b-novo", "pergunta inedita", """[ { "kind": "contains", "value": "resposta" } ]""");
 
         await using var offline = EvalFixture.Create(ws.Options(EvalMode.Offline));
         var error = await Assert.ThrowsAsync<EvalCacheMissException>(
             () => offline.RunAllAsync(TestContext.Current.CancellationToken));
 
-        // O cenario que faltou, e nao "algum cenario".
         Assert.Equal("triagem.acme.b-novo", error.ScenarioName);
         Assert.Contains("eval-cache-miss", error.Message, StringComparison.Ordinal);
 
-        // P3: a mensagem carrega o comando de regravacao e o arquivo de credencial esperado.
-        // Um "cache miss" seco mandaria o leitor procurar os dois.
         Assert.Contains(EvalCacheMissException.RefreshCommand, error.Message, StringComparison.Ordinal);
         Assert.Contains(".env.evals", error.Message, StringComparison.Ordinal);
         Assert.Contains(ws.CacheRoot, error.Message, StringComparison.Ordinal);
@@ -67,33 +52,22 @@ public sealed class EvalCacheMissTests
         using var ws = await SeededAsync("a-primeiro");
         ws.WriteScenario("triagem", "acme", "b-novo", "pergunta inedita", """[ { "kind": "contains", "value": "resposta" } ]""");
 
-        // O sumario da SEMEADURA, byte a byte. Ele e a linha de base: o que este teste cobra
-        // e que o run que morreu por miss nao escreva NADA por cima dele.
         var summaryBeforeTheMiss = File.ReadAllBytes(ws.SummaryPath);
 
         await using var offline = EvalFixture.Create(ws.Options(EvalMode.Offline));
         await Assert.ThrowsAsync<EvalCacheMissException>(
             () => offline.RunAllAsync(TestContext.Current.CancellationToken));
 
-        // Nao ha caminho pelo qual o cenario ausente apareca como avaliado: a contagem so tem
-        // o que de fato resolveu, e o sumario NAO foi reescrito. Um sumario dizendo
-        // "1 cenario, 1 passou, cache warm" aqui seria exatamente a mentira que a excecao
-        // existe para impedir — e o CLI, que le o ARQUIVO, acreditaria nela.
         Assert.Single(offline.Results);
         Assert.Equal("triagem.acme.a-primeiro", offline.Results[0].Scenario);
         Assert.Equal(summaryBeforeTheMiss, File.ReadAllBytes(ws.SummaryPath));
 
-        // E o contador do cliente interno registra a tentativa: a arvore de cache nao
-        // respondeu, e isso e um FATO medido, nao uma inferencia.
         Assert.Equal(1, offline.Offline!.Invocations);
     }
 
     [Fact]
     public async Task AFailedAssertionMakesTheScenarioREDWithoutAnyCacheMiss()
     {
-        // A outra metade do contrato: reprovar por conteudo e diferente de reprovar por
-        // cache. Uma so mensagem para os dois casos mandaria o leitor procurar no lugar
-        // errado metade das vezes.
         using var ws = new EvalWorkspace();
         ws.WriteScenario("triagem", "acme", "saudacao", "bom dia", """[ { "kind": "contains", "value": "jamais aparece" } ]""");
 
@@ -130,9 +104,6 @@ public sealed class EvalCacheMissTests
         await using var offline = EvalFixture.Create(ws.Options(EvalMode.Offline));
         var summary = await offline.RunAllAsync(TestContext.Current.CancellationToken);
 
-        // Um cenario que nao cobra nada nao pode contar como cobertura. Deixa-lo verde e o
-        // mesmo defeito de um teste vazio — pior aqui, porque ele apareceria na contagem
-        // como se tivesse verificado algo.
         Assert.Equal(1, summary.Failed);
         Assert.Equal(0, summary.Passed);
     }

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/Evals/EvalCacheStampTests.cs

@@ -4,14 +4,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests.Evals;
 
-/// <summary>
-/// O carimbo: por que a arvore de cache precisa dizer sob quais versoes foi gravada.
-/// </summary>
-/// <remarks>
-/// A funcao de hash que produz a chave nao promete estabilidade entre versoes da biblioteca.
-/// Sem carimbo, subir o pin chega como N misses inexplicaveis num dia em que ninguem mexeu
-/// em nada; com carimbo, chega como uma frase que nomeia as DUAS versoes.
-/// </remarks>
 public sealed class EvalCacheStampTests
 {
     private static readonly FakeClock Today = new(new DateTimeOffset(2026, 9, 8, 12, 0, 0, TimeSpan.Zero));
@@ -51,8 +43,6 @@ public sealed class EvalCacheStampTests
         using var ws = new EvalWorkspace();
         Stamp(ws.CacheRoot);
 
-        // Ler de VOLTA do disco, e nao comparar o objeto com ele mesmo: o carimbo e um
-        // artefato, e um teste que so olhasse a instancia em memoria seria um espelho.
         var read = EvalCacheStamp.Read(ws.CacheRoot);
 
         Assert.NotNull(read);
@@ -72,7 +62,6 @@ public sealed class EvalCacheStampTests
 
         Assert.Equal(EvalStampVerdict.PinMismatch, check.Verdict);
         Assert.Contains("eval-cache-stale-pin", check.Reason, StringComparison.Ordinal);
-        // Dizer so uma das versoes obriga o leitor a ir buscar a outra.
         Assert.Contains("gravada 10.9.0", check.Reason, StringComparison.Ordinal);
         Assert.Contains("pin 10.11.0", check.Reason, StringComparison.Ordinal);
     }
@@ -89,9 +78,6 @@ public sealed class EvalCacheStampTests
         Assert.Equal(EvalStampVerdict.Missing, missing.Verdict);
         Assert.Contains("eval-cache-unstamped", missing.Reason, StringComparison.Ordinal);
 
-        // As duas situacoes pedem acoes diferentes: "regrave" versus "regrave PORQUE o
-        // pacote mudou". Um veredito unico devolveria ao leitor a pergunta que o carimbo
-        // existia para responder.
         Assert.NotEqual(missing.Verdict, divergent.Verdict);
         Assert.DoesNotContain("eval-cache-stale-pin", missing.Reason, StringComparison.Ordinal);
     }
@@ -116,8 +102,6 @@ public sealed class EvalCacheStampTests
 
         var check = EvalCacheStamp.Check(ws.CacheRoot, Pin(pinnedAt: "2027-01-01"), Today);
 
-        // O carimbo CASA com o pin — e mesmo assim reprova, porque a regua esta adulterada.
-        // Uma data no futuro renovaria sozinha qualquer janela medida contra ela.
         Assert.Equal(EvalStampVerdict.FuturePin, check.Verdict);
         Assert.Contains("eval-pin-future", check.Reason, StringComparison.Ordinal);
     }
@@ -135,8 +119,6 @@ public sealed class EvalCacheStampTests
             ["Microsoft.Extensions.AI.Evaluation"] = "10.11.0",
         });
 
-        // A recusa acontece na CONSTRUCAO — antes de qualquer cenario. Nao faz sentido pagar
-        // o relogio de uma suite para descobrir no fim que a cache nao servia.
         var error = Assert.Throws<InvalidOperationException>(
             () => EvalFixture.Create(ws.Options(EvalMode.Offline, pin), timeProvider: Today));
 
@@ -148,7 +130,7 @@ public sealed class EvalCacheStampTests
     {
         using var ws = new EvalWorkspace();
 
-        // Cobrar carimbo em modo de escrita tornaria impossivel criar a PRIMEIRA cache.
+        // Cobrar carimbo na escrita impediria criar a primeira cache.
         var fixture = EvalFixture.Create(ws.Options(EvalMode.Refresh), new FakeChatClient());
 
         Assert.True(fixture.StampCheck.IsOk);

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/Evals/EvalFailuresTests.cs

@@ -4,37 +4,8 @@ using Xunit;
 
 namespace Morph.AiKit.Tests.Evals;
 
-/// <summary>
-/// A camada que NOMEIA a falha, testada pelo conteudo do que ela produz.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Este arquivo fecha a setima ocorrencia da mesma classe nesta epic, e a mais ironica: o
-/// mecanismo de <c>Failures</c> nasceu para consertar um eval que mordia ANONIMAMENTE, e
-/// nasceu ele proprio sem par. As tres partes podiam ser desligadas sem matar um teste —
-/// <c>CollectFailures</c> devolvendo lista vazia, o ramo da vacuidade nunca disparando, e o
-/// nome da assercao trocado por um literal — e a suite seguia "165 total, 0 falhou".
-/// </para>
-/// <para>
-/// A causa foi uma unica testemunha automatizada: <c>Assert.Empty(summary.Failures)</c> num
-/// run VERDE. Essa asserção é verdadeira exatamente quando o mecanismo esta morto — ela nao
-/// distingue "nao houve falha" de "falha nenhuma e registrada". Uma lista vazia prova a
-/// ausencia de conteudo, jamais a presenca de capacidade.
-/// </para>
-/// <para>
-/// Por isso aqui nao se assere sobre <c>Failures</c> VAZIA: assere-se sobre o CONTEUDO de
-/// <c>Failures</c> num run que falha de verdade — o par, a mesma forma que fechou o motor de
-/// assercao um andar abaixo.
-/// </para>
-/// </remarks>
 public sealed class EvalFailuresTests
 {
-    /// <summary>Grava a cache do cenario com o texto dado, e devolve o fixture offline pronto.</summary>
-    /// <remarks>
-    /// A cache e semeada pelo <see cref="FakeChatClient"/>, NUNCA por chamada paga: o caminho
-    /// de escrita exercitado e o da biblioteca, e a leitura offline le exatamente o que aquela
-    /// escrita produziu.
-    /// </remarks>
     private static async Task<EvalRunSummary> RunOfflineAsync(EvalWorkspace ws, params string[] responses)
     {
         using var fake = new FakeChatClient
@@ -60,9 +31,6 @@ public sealed class EvalFailuresTests
     [Fact]
     public async Task AFailedScenarioIsRegisteredWithScenarioAssertionKindAndReason()
     {
-        // O caso central: uma assercao reprova, e a falha chega ao sumario COM NOME. Sem isso
-        // o veredito viaja como contador — "Expected 0, Actual 1" — e quem le tem de abrir o
-        // dataset para descobrir o que quebrou.
         using var ws = new EvalWorkspace();
         ws.WriteScenario(
             "triagem", "acme", "saudacao", "bom dia",
@@ -79,7 +47,6 @@ public sealed class EvalFailuresTests
         Assert.Contains("FALHOU", failure.Reason, StringComparison.Ordinal);
         Assert.Contains("bom dia", failure.Reason, StringComparison.Ordinal);
 
-        // A linha legivel, no formato que a rubrica eval-de-modelo.md cita como exemplo.
         Assert.Contains(
             "eval-fail: triagem.acme.saudacao",
             summary.DescribeFailures(),
@@ -89,9 +56,6 @@ public sealed class EvalFailuresTests
     [Fact]
     public async Task TwoReprovedAssertionsInOneScenarioProduceTWOLinesEachNamingItsOwnRule()
     {
-        // `Failures` e LISTA, e nao contador, porque as duas linhas dizem coisas diferentes:
-        // uma resposta pode quebrar em mais de uma regua, e isso separa "o prompt mudou" de
-        // "o modelo parou de responder". Se o tipo fosse um booleano, esta distincao morreria.
         using var ws = new EvalWorkspace();
         ws.WriteScenario(
             "triagem", "acme", "saudacao", "bom dia",
@@ -110,18 +74,12 @@ public sealed class EvalFailuresTests
         Assert.Contains(summary.Failures, f => f.Assertion == "cumprimenta" && f.Kind == "Contains");
         Assert.Contains(summary.Failures, f => f.Assertion == "sem-dado-pessoal" && f.Kind == "NoPii");
 
-        // Toda linha nomeia o cenario: uma falha sem cenario obriga a mesma busca que ela
-        // deveria dispensar.
         Assert.All(summary.Failures, f => Assert.Equal("triagem.acme.saudacao", f.Scenario));
     }
 
     [Fact]
     public async Task AScenarioWithNOAssertionsIsCountedANDNamed()
     {
-        // O cenario sem assercao nenhuma reprova por VACUIDADE: ele nao cobra nada. Nesse caso
-        // nao existe outcome reprovado para nomear, e sem um ramo proprio ele seria contado em
-        // `Failed` e invisivel em `Failures` — um numero sem frase, que e metade exata do
-        // defeito que este tipo existe para fechar.
         using var ws = new EvalWorkspace();
         ws.WriteScenario("triagem", "acme", "vazio", "bom dia", "[]");
 
@@ -133,16 +91,12 @@ public sealed class EvalFailuresTests
         Assert.Equal("triagem.acme.vazio", failure.Scenario);
         Assert.Contains("sem assercao deterministica", failure.Reason, StringComparison.Ordinal);
 
-        // Contado E nomeado: o numero e a frase tem de concordar sempre.
         Assert.Equal(summary.Failed, summary.Failures.Count);
     }
 
     [Fact]
     public async Task AGreenRunRegistersNoFailureAndSaysSoInWords()
     {
-        // A reciproca vive AO LADO dos casos que falham de verdade, nunca sozinha: uma suite
-        // cuja unica testemunha e `Assert.Empty` num run verde e verdadeira precisamente
-        // quando o mecanismo esta morto.
         using var ws = new EvalWorkspace();
         ws.WriteScenario(
             "triagem", "acme", "saudacao", "bom dia",
@@ -158,8 +112,6 @@ public sealed class EvalFailuresTests
     [Fact]
     public async Task TheNamedFailuresSurviveTheROUNDTRIPThroughTheSummaryFileTheCLIReads()
     {
-        // O sumario e um ARQUIVO: quem consome as falhas e o CLI, do outro lado do disco. Uma
-        // lista que existisse so em memoria seria invisivel exatamente onde precisa ser lida.
         using var ws = new EvalWorkspace();
         ws.WriteScenario(
             "triagem", "acme", "saudacao", "bom dia",