@polymorphism-tech/morph-spec 8.37.1 → 8.40.0

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

@@ -7,21 +7,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios do <see cref="ConversationStore"/> (T13). A afirmacao central: <b>uma unica
-/// instancia de provider atende todas as sessoes, e o historico de uma conversa nunca
-/// aparece em outra</b> — porque o estado por sessao vive na
-/// <see cref="AgentSession"/> (via <see cref="ProviderSessionState{TState}"/>), jamais num
-/// campo do provider.
-/// </summary>
-/// <remarks>
-/// Os testes rodam pelo caminho <b>real</b> do MAF: um <see cref="ChatClientAgent"/> de
-/// verdade, com <c>ChatClientAgentOptions.ChatHistoryProvider</c> apontando para o
-/// <see cref="ConversationStore"/>, sessoes criadas por <c>CreateSessionAsync</c> e voltas
-/// disparadas por <c>RunAsync</c>. O unico fake e o <see cref="FakeChatClient"/> no lugar do
-/// provider de modelo — e por isso "o provider e chamado" e um fato observado, e nao uma
-/// chamada manual ao metodo protegido fingindo ser o framework.
-/// </remarks>
 public sealed class ConversationStoreTests
 {
     private static ChatClientAgent Agent(FakeChatClient client, ConversationStore history)
@@ -37,15 +22,6 @@ public sealed class ConversationStoreTests
     private static string[] TextsOf(IEnumerable<ChatMessage> messages)
         => [.. messages.Select(m => m.Text)];
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria 2: AppendAsync recebe a volta; LoadAsync alimenta a volta seguinte
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Uma volta e gravada com pedido e resposta, nessa ordem — e a volta seguinte chega ao
-    /// modelo ja com essa historia na frente. As duas metades do contrato, medidas nos dois
-    /// lados: no acervo e no que o cliente de modelo recebeu.
-    /// </summary>
     [Fact]
     public async Task TheRoundIsAppendedAndFeedsTheHistoryOfTheNextRound()
     {
@@ -61,7 +37,6 @@ public sealed class ConversationStoreTests
 
         await agent.RunAsync("Meu pedido 1234 esta atrasado.", session, cancellationToken: Ct);
 
-        // Depois da 1a volta o acervo tem exatamente o pedido e a resposta daquela volta.
         var afterFirst = await store.LoadAsync("conversa-A", Ct);
         Assert.Equal(
             ["Meu pedido 1234 esta atrasado.", "Vou verificar o pedido 1234."],
@@ -69,8 +44,6 @@ public sealed class ConversationStoreTests
 
         await agent.RunAsync("E quando foi despachado?", session, cancellationToken: Ct);
 
-        // A 2a ida ao modelo levou o historico carregado do acervo, e so uma vez cada
-        // mensagem — o turno corrente nao vem duplicado.
         var secondCall = TextsOf(client.ReceivedMessages[1]);
         Assert.Equal(
             [
@@ -84,10 +57,6 @@ public sealed class ConversationStoreTests
         Assert.Equal(4, afterSecond.Count);
     }
 
-    /// <summary>
-    /// A primeira volta nao carrega historico nenhum: conversa inexistente e lista vazia, nao
-    /// erro. E o caso mais comum de todos.
-    /// </summary>
     [Fact]
     public async Task AConversationThatDoesNotExistYetLoadsEmptyInsteadOfFailing()
     {
@@ -106,19 +75,6 @@ public sealed class ConversationStoreTests
         Assert.Equal(["oi", "ola"], TextsOf(await store.LoadAsync("conversa-nova", Ct)));
     }
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria 1: DUAS sessoes concorrentes na MESMA instancia, sem vazamento
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// <b>O canario da invariante.</b> Uma instancia de <see cref="ConversationStore"/>, duas
-    /// sessoes, muitas voltas intercaladas em paralelo: nenhuma mensagem de uma conversa
-    /// aparece na outra, e cada uma tem exatamente as suas.
-    /// </summary>
-    /// <remarks>
-    /// Este e o teste que morre se alguem guardar "a conversa atual" num campo do provider —
-    /// o defeito que em producao aparece como historico de um usuario na tela de outro.
-    /// </remarks>
     [Fact]
     public async Task TwoConcurrentSessionsOnTheSameProviderNeverSeeEachOthersMessages()
     {
@@ -136,7 +92,6 @@ public sealed class ConversationStoreTests
             clientB.EnqueueText($"resposta-B-{i}");
         }
 
-        // Duas conversas distintas, o MESMO provider de historico nos dois agentes.
         var agentA = Agent(clientA, history);
         var agentB = Agent(clientB, history);
 
@@ -145,7 +100,7 @@ public sealed class ConversationStoreTests
         history.BindConversation(sessionA, "conversa-A");
         history.BindConversation(sessionB, "conversa-B");
 
-        // Sequencial DENTRO de cada sessao (uma conversa e uma fila), concorrente ENTRE elas.
+        // Sequencial dentro de cada sessao (uma conversa e uma fila), concorrente entre elas.
         var driveA = Task.Run(async () =>
         {
             for (var i = 0; i < Rounds; i++)
@@ -170,26 +125,18 @@ public sealed class ConversationStoreTests
         Assert.Equal(Rounds * 2, conversationA.Length);
         Assert.Equal(Rounds * 2, conversationB.Length);
 
-        // Nenhum texto do outro lado atravessou.
         Assert.DoesNotContain(conversationA, t => t.Contains("-B-", StringComparison.Ordinal));
         Assert.DoesNotContain(conversationB, t => t.Contains("-A-", StringComparison.Ordinal));
 
-        // E cada conversa tem as suas, na ordem.
         Assert.Equal(
             [.. Enumerable.Range(0, Rounds).SelectMany(i => new[] { $"pergunta-A-{i}", $"resposta-A-{i}" })],
             conversationA);
 
-        // O que o modelo VIU tambem nao se misturou: a ultima ida de A nao carrega nada de B.
         Assert.DoesNotContain(
             TextsOf(clientA.ReceivedMessages[^1]),
             t => t.Contains("-B-", StringComparison.Ordinal));
     }
 
-    /// <summary>
-    /// A prova direta de que o estado por sessao <b>mora na sessao</b>: o mesmo provider
-    /// devolve ids diferentes para sessoes diferentes, e o id de cada sessao esta gravado
-    /// no <c>StateBag</c> dela — que e onde o MAF o serializa e o retoma.
-    /// </summary>
     [Fact]
     public async Task TheConversationIdLivesInTheSessionStateNotInAProviderField()
     {
@@ -204,19 +151,13 @@ public sealed class ConversationStoreTests
         var secondId = history.GetConversationId(second);
 
         Assert.NotEqual(firstId, secondId);
-        Assert.Equal(firstId, history.GetConversationId(first));   // estavel na mesma sessao
+        Assert.Equal(firstId, history.GetConversationId(first));
 
-        // Esta gravado na sessao, sob a chave que o provider declara em StateKeys.
         Assert.True(first.StateBag.TryGetValue<string>(ConversationStore.ConversationIdStateKey, out var stored));
         Assert.Equal(firstId, stored);
         Assert.Contains(ConversationStore.ConversationIdStateKey, history.StateKeys);
     }
 
-    /// <summary>
-    /// Sem amarracao explicita o id e um <see cref="Guid.CreateVersion7"/> — ordenavel no
-    /// tempo, ao contrario de <c>Guid.NewGuid</c>. A versao 7 e legivel no proprio valor
-    /// (o nibble de versao), entao a regra da casa e verificavel e nao so declarada.
-    /// </summary>
     [Fact]
     public async Task AnUnboundSessionGetsATimeOrderedIdentifier()
     {
@@ -231,11 +172,6 @@ public sealed class ConversationStoreTests
         Assert.Equal(7, parsed.ToByteArray(bigEndian: true)[6] >> 4);
     }
 
-    /// <summary>
-    /// O caminho do CRM: a conversa ja existe como registro, e a sessao entra nela — o
-    /// historico anterior aparece na primeira volta desta sessao. E o que torna a decisao
-    /// "conversa no acervo do projeto" util em vez de teorica.
-    /// </summary>
     [Fact]
     public async Task ASessionCanJoinAConversationThatAlreadyExistsInTheProjectStore()
     {
@@ -258,21 +194,10 @@ public sealed class ConversationStoreTests
         await agent.RunAsync("Nao chegou.", session, cancellationToken: Ct);
 
         Assert.Contains("Ontem eu pedi um orcamento.", TextsOf(client.ReceivedMessages[0]));
-        // 2 do acervo anterior + o pedido e a resposta desta volta. A volta grava SO a si
-        // mesma: regravar o historico inteiro faria a conversa crescer em progressao
-        // geometrica a cada turno.
+        // 2 do acervo + pedido e resposta desta volta: a volta grava so a si mesma.
         Assert.Equal(4, (await store.LoadAsync("crm-conversa-42", Ct)).Count);
     }
 
-    // ---------------------------------------------------------------------------------
-    // O acervo e plugavel: o kit nao conhece banco
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// A costura e substituivel: um acervo de teste que apenas anota as chamadas prova que o
-    /// provider fala com <see cref="IConversationStore"/> e com mais nada — e um projeto que
-    /// troque memoria por <c>jsonb</c> so implementa esta interface.
-    /// </summary>
     [Fact]
     public async Task TheProviderTalksOnlyToTheSeamSoPersistenceIsReplaceable()
     {
@@ -289,11 +214,6 @@ public sealed class ConversationStoreTests
         Assert.Equal(["load:c-1", "append:c-1"], spy.Calls);
     }
 
-    /// <summary>
-    /// Volta que falhou nao vira historico. Persistir o pedido sem resposta deixaria a
-    /// conversa terminando numa pergunta nunca respondida — e a volta seguinte a repetiria,
-    /// com o usuario se vendo duplicado.
-    /// </summary>
     [Fact]
     public async Task AFailedRoundIsNotPersisted()
     {
@@ -311,22 +231,7 @@ public sealed class ConversationStoreTests
         Assert.Empty(await store.LoadAsync("conversa-falha", Ct));
     }
 
-    /// <summary>
-    /// <b>Uma volta sem sessao.</b> O MAF declara <c>InvokingContext.Session</c> como
-    /// anulavel, e o provider recusa esse caso: inventar um id gravaria conversa orfa e usar
-    /// uma chave fixa juntaria tenants no mesmo balde — as duas saidas silenciosas sao
-    /// piores que a recusa. Este teste mede o que o framework realmente faz por esse
-    /// caminho, em vez de supor: e o comportamento observado que fica pinado aqui.
-    /// </summary>
-    /// <remarks>
-    /// O caminho de construir <c>InvokingContext</c> a mao — que seria a forma direta de
-    /// exercitar a guarda — <b>nao esta disponivel</b>: no MAF 1.20.0 os construtores de
-    /// <c>InvokingContext</c> e <c>InvokedContext</c> sao os unicos membros da area de
-    /// <c>ChatHistoryProvider</c> marcados <c>[Experimental("MAAI001")]</c>, e com
-    /// <c>TreatWarningsAsErrors</c> isso e erro de compilacao. Consequencia registrada: um
-    /// provider de historico so pode ser testado <b>atraves de um agente real</b>, que e
-    /// como esta classe inteira o testa.
-    /// </remarks>
+    // No MAF 1.20.0 o construtor de InvokingContext e [Experimental("MAAI001")]: o provider so se exercita via agente real.
     [Fact]
     public async Task ARoundWithoutAnExplicitSessionStillHasAConversationOfItsOwn()
     {
@@ -337,14 +242,10 @@ public sealed class ConversationStoreTests
 
         await agent.RunAsync("sem sessao", cancellationToken: Ct);
 
-        // O agente cria uma sessao efemera para a volta: a guarda de sessao ausente nao e
-        // alcancada por este caminho, e a conversa nasce com id proprio em vez de cair num
-        // balde compartilhado.
+        // Sem sessao, o agente cria uma efemera para a volta: a conversa nasce com id proprio.
         var conversation = Assert.Single(store.ConversationIds);
         Assert.Equal(["sem sessao", "respondido"], TextsOf(await store.LoadAsync(conversation, Ct)));
 
-        // E a volta seguinte, tambem sem sessao, NAO herda a conversa anterior — sem sessao
-        // nao ha continuidade, que e a semantica correta de uma chamada avulsa.
         client.EnqueueText("de novo");
         await agent.RunAsync("outra avulsa", cancellationToken: Ct);
 
@@ -352,15 +253,10 @@ public sealed class ConversationStoreTests
         Assert.DoesNotContain("sem sessao", TextsOf(client.ReceivedMessages[^1]));
     }
 
-    /// <summary>Provider sem acervo e defeito de composicao, e falha na construcao.</summary>
     [Fact]
     public void TheProviderRefusesToBeBuiltWithoutAStore()
         => Assert.Throws<ArgumentNullException>(() => new ConversationStore(null!));
 
-    /// <summary>
-    /// O acervo em memoria e ele proprio seguro sob concorrencia — senao o canario das duas
-    /// sessoes mediria a falta de trava aqui, e nao o isolamento do provider.
-    /// </summary>
     [Fact]
     public async Task TheInMemoryStoreDoesNotLoseWritesUnderConcurrency()
     {
@@ -378,7 +274,6 @@ public sealed class ConversationStoreTests
         Assert.Empty(await store.LoadAsync("inexistente", Ct));
     }
 
-    /// <summary>Acervo de teste que so anota o que lhe pediram, na ordem.</summary>
     private sealed class RecordingConversationStore : IConversationStore
     {
         private readonly ConcurrentQueue<string> _calls = new();

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")) })