@polymorphism-tech/morph-spec 8.34.2 → 8.35.0

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

@@ -0,0 +1,379 @@
+using Morph.AiKit.Rag;
+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)
+        {
+            var plan = DeltaIngest.Plan(incoming, Key, Hash, _index);
+
+            foreach (var doc in plan.Added)
+            {
+                _rows.Add(doc);                 // INSERT
+                _index[doc.Slug] = Hash(doc);
+                EmbeddingCalls++;
+            }
+
+            foreach (var doc in plan.Updated)
+            {
+                _rows[_rows.FindIndex(r => r.Slug == doc.Slug)] = doc;   // UPDATE
+                _index[doc.Slug] = Hash(doc);
+                EmbeddingCalls++;
+            }
+
+            foreach (var slug in plan.Removed)
+            {
+                _rows.RemoveAll(r => r.Slug == slug);                    // DELETE
+                _index.Remove(slug);
+            }
+
+            return plan;
+        }
+    }
+
+    private static Doc[] ThreeDocs() =>
+    [
+        new("politica-troca", "Trocas em ate 7 dias."),
+        new("prazo-entrega", "Entrega em 3 dias uteis."),
+        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()
+    {
+        var existing = new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["prazo-entrega"] = Hash(new Doc("prazo-entrega", "Entrega em 5 dias uteis.")),   // vai mudar
+            ["garantia"] = Hash(new Doc("garantia", "Garantia de 12 meses.")),                // igual
+            ["pagina-morta"] = "h:qualquer",                                                  // sumiu
+        };
+
+        var plan = DeltaIngest.Plan(ThreeDocs(), Key, Hash, existing);
+
+        Assert.Equal(["politica-troca"], plan.Added.Select(d => d.Slug));
+        Assert.Equal(["prazo-entrega"], plan.Updated.Select(d => d.Slug));
+        Assert.Equal(["garantia"], plan.Unchanged.Select(d => d.Slug));
+        Assert.Equal(["pagina-morta"], plan.Removed);
+        Assert.False(plan.IsNoOp);
+        Assert.Equal(3, plan.WriteCount);
+    }
+
+    /// <summary>Acervo vazio: tudo e novo, nada e removido.</summary>
+    [Fact]
+    public void AnEmptyCorpusMakesEverythingNew()
+    {
+        var plan = DeltaIngest.Plan(ThreeDocs(), Key, Hash, new Dictionary<string, string>());
+
+        Assert.Equal(3, plan.Added.Count);
+        Assert.Empty(plan.Updated);
+        Assert.Empty(plan.Unchanged);
+        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()
+    {
+        var corpus = new Corpus();
+        corpus.Ingest(ThreeDocs());
+
+        var plan = DeltaIngest.Plan(Array.Empty<Doc>(), Key, Hash, corpus.Hashes);
+
+        Assert.Equal(3, plan.Removed.Count);
+        Assert.Empty(plan.Added);
+        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()
+    {
+        var corpus = new Corpus();
+        var shipment = ThreeDocs();
+
+        var first = corpus.Ingest(shipment);
+
+        Assert.Equal(3, first.Added.Count);
+        Assert.Equal(3, corpus.EmbeddingCalls);
+
+        var before = corpus.Rows.OrderBy(d => d.Slug, StringComparer.Ordinal).ToArray();
+
+        var second = corpus.Ingest(shipment);
+
+        Assert.True(second.IsNoOp);
+        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(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()
+    {
+        var corpus = new Corpus();
+        corpus.Ingest(ThreeDocs());
+
+        Doc[] revised =
+        [
+            new("politica-troca", "Trocas em ate 7 dias."),
+            new("prazo-entrega", "Entrega em 1 dia util."),   // <- unico campo alterado
+            new("garantia", "Garantia de 12 meses."),
+        ];
+
+        var plan = corpus.Ingest(revised);
+
+        Assert.Equal(["prazo-entrega"], plan.Updated.Select(d => d.Slug));
+        Assert.Empty(plan.Added);
+        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("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()
+    {
+        var corpus = new Corpus();
+        var shipment = ThreeDocs();
+
+        corpus.Ingest(shipment);
+        corpus.Ingest(shipment);
+
+        Assert.Equal(3, corpus.Rows.Count);
+        Assert.Equal(3, corpus.Rows.Select(d => d.Slug).Distinct(StringComparer.Ordinal).Count());
+        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()
+    {
+        var corpus = new Corpus();
+        corpus.Ingest(ThreeDocs());
+
+        var shuffled = ThreeDocs().Reverse().ToArray();
+
+        Assert.True(corpus.Ingest(shuffled).IsNoOp);
+        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()
+    {
+        Doc[] shipment =
+        [
+            new("politica-troca", "primeira versao"),
+            new("prazo-entrega", "irrelevante"),
+            new("politica-troca", "segunda versao"),
+        ];
+
+        var failure = Assert.Throws<DuplicateLookupKeyException>(
+            () => DeltaIngest.Plan(shipment, Key, Hash, new Dictionary<string, string>()));
+
+        Assert.Equal("politica-troca", failure.LookupKey);
+        Assert.Equal(0, failure.FirstIndex);
+        Assert.Equal(2, failure.DuplicateIndex);
+        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("   ")]
+    public void ABlankLookupKeyIsRefused(string blank)
+    {
+        var failure = Assert.Throws<ArgumentException>(
+            () => DeltaIngest.Plan([new Doc(blank, "corpo")], Key, Hash, new Dictionary<string, string>()));
+
+        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()
+    {
+        var failure = Assert.Throws<ArgumentException>(
+            () => DeltaIngest.Plan(ThreeDocs(), Key, _ => string.Empty, new Dictionary<string, string>()));
+
+        Assert.Contains("politica-troca", failure.Message, StringComparison.Ordinal);
+    }
+
+    /// <summary>Argumento nulo e defeito de chamada, e falha na chamada.</summary>
+    [Fact]
+    public void TheRequiredArgumentsAreNotOptional()
+    {
+        var empty = new Dictionary<string, string>();
+
+        Assert.Throws<ArgumentNullException>(() => DeltaIngest.Plan<Doc>(null!, Key, Hash, empty));
+        Assert.Throws<ArgumentNullException>(() => DeltaIngest.Plan(ThreeDocs(), null!, Hash, empty));
+        Assert.Throws<ArgumentNullException>(() => DeltaIngest.Plan(ThreeDocs(), Key, null!, empty));
+        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()
+    {
+        var existing = new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["politica-troca"] = Hash(new Doc("politica-troca", "Trocas em ate 7 dias.")),
+        };
+
+        var plan = DeltaIngest.Plan(
+            [new Doc("Politica-Troca", "Trocas em ate 7 dias.")],
+            Key,
+            Hash,
+            existing);
+
+        Assert.Equal(["Politica-Troca"], plan.Added.Select(d => d.Slug));
+        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()
+    {
+        var corpus = new Corpus();
+        corpus.Ingest(ThreeDocs());
+
+        var reconstructed = ThreeDocs().Select(d => new Doc(d.Slug, d.Body)).ToArray();
+
+        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()
+    {
+        var passes = 0;
+
+        IEnumerable<Doc> Once()
+        {
+            passes++;
+            foreach (var doc in ThreeDocs())
+            {
+                yield return doc;
+            }
+        }
+
+        DeltaIngest.Plan(Once(), Key, Hash, new Dictionary<string, string>());
+
+        Assert.Equal(1, passes);
+    }
+}

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

@@ -0,0 +1,197 @@
+using Microsoft.Extensions.AI;
+using Morph.AiKit.Evals;
+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);
+        foreach (var (key, value) in args)
+        {
+            arguments[key] = value;
+        }
+
+        var message = new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("call-1", name, arguments)]);
+        return new ChatResponse(message);
+    }
+
+    // ---------------------------------------------------------------- Contains
+
+    [Fact]
+    public void ContainsSeparatesTheAnswerThatCarriesTheTextFromTheOneThatDoesNot()
+    {
+        var assertion = new EvalAssertion { Name = "saudacao", Kind = EvalAssertionKind.Contains, Value = "Bom dia" };
+
+        Assert.True(assertion.Evaluate(Text("Bom dia! Como posso ajudar?")).Passed);
+
+        var reproved = assertion.Evaluate(Text("Boa noite! Como posso ajudar?"));
+        Assert.False(reproved.Passed, "Contains aceitou uma resposta que NAO contem o texto");
+        Assert.Contains("Bom dia", reproved.Reason, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ContainsIgnoresCaseButNotAbsence()
+    {
+        var assertion = new EvalAssertion { Name = "saudacao", Kind = EvalAssertionKind.Contains, Value = "bom dia" };
+
+        Assert.True(assertion.Evaluate(Text("BOM DIA")).Passed);
+        Assert.False(assertion.Evaluate(Text("ola")).Passed);
+    }
+
+    // ------------------------------------------------------------- NotContains
+
+    [Fact]
+    public void NotContainsSeparatesTheCleanAnswerFromTheOneThatLeaksTheForbiddenText()
+    {
+        var assertion = new EvalAssertion { Name = "sem-preco", Kind = EvalAssertionKind.NotContains, Value = "desconto" };
+
+        Assert.True(assertion.Evaluate(Text("Segue o orcamento solicitado.")).Passed);
+
+        var reproved = assertion.Evaluate(Text("Segue o orcamento com desconto de 20%."));
+        Assert.False(reproved.Passed, "NotContains aceitou uma resposta que CONTEM o texto proibido");
+        Assert.Contains("desconto", reproved.Reason, StringComparison.Ordinal);
+    }
+
+    // -------------------------------------------------------------- JsonHasKey
+
+    [Fact]
+    public void JsonHasKeySeparatesTheObjectThatCarriesTheKeyFromTheOneThatDoesNot()
+    {
+        var assertion = new EvalAssertion { Name = "tem-total", Kind = EvalAssertionKind.JsonHasKey, Target = "total" };
+
+        Assert.True(assertion.Evaluate(Text("""{"total": 1200, "moeda": "BRL"}""")).Passed);
+
+        var reproved = assertion.Evaluate(Text("""{"moeda": "BRL"}"""));
+        Assert.False(reproved.Passed, "JsonHasKey aceitou um objeto SEM a chave exigida");
+        Assert.Contains("total", reproved.Reason, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void JsonHasKeyReprovesWhatIsNotJsonAtAll()
+    {
+        var assertion = new EvalAssertion { Name = "tem-total", Kind = EvalAssertionKind.JsonHasKey, Target = "total" };
+
+        var reproved = assertion.Evaluate(Text("O total e mil e duzentos reais."));
+        Assert.False(reproved.Passed, "JsonHasKey aceitou uma resposta que nem JSON e");
+        Assert.Contains("JSON", reproved.Reason, StringComparison.Ordinal);
+    }
+
+    [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.
+        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")]
+    [InlineData("Ligue para (11) 98765-4321.", "telefone")]
+    public void NoPiiReprovesEachFormOfPersonalDataItClaimsToRecognize(string leaky, string label)
+    {
+        var assertion = new EvalAssertion { Name = "sem-pii", Kind = EvalAssertionKind.NoPii };
+
+        var reproved = assertion.Evaluate(Text(leaky));
+        Assert.False(reproved.Passed, $"NoPii aceitou uma resposta que carrega {label}");
+        Assert.Contains(label, reproved.Reason, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void NoPiiApprovesTheAnswerWithoutPersonalData()
+    {
+        var assertion = new EvalAssertion { Name = "sem-pii", Kind = EvalAssertionKind.NoPii };
+
+        Assert.True(assertion.Evaluate(Text("Bom dia! Como posso ajudar voce hoje?")).Passed);
+    }
+
+    // -------------------------------------------------------------- ToolCalled
+
+    [Fact]
+    public void ToolCalledSeparatesTheRightToolFromAnotherToolAndFromNoToolAtAll()
+    {
+        var assertion = new EvalAssertion { Name = "escalou", Kind = EvalAssertionKind.ToolCalled, Target = "escalar_humano" };
+
+        Assert.True(assertion.Evaluate(Tool("escalar_humano")).Passed);
+
+        var outraFerramenta = assertion.Evaluate(Tool("consultar_estoque"));
+        Assert.False(outraFerramenta.Passed, "ToolCalled aceitou a escolha de OUTRA ferramenta");
+        Assert.Contains("escalar_humano", outraFerramenta.Reason, StringComparison.Ordinal);
+
+        Assert.False(assertion.Evaluate(Text("vou escalar para um humano")).Passed);
+    }
+
+    // ------------------------------------------------------------ ToolArgument
+
+    [Fact]
+    public void ToolArgumentSeparatesTheRightArgumentFromTheWrongValueAndTheMissingKey()
+    {
+        var assertion = new EvalAssertion
+        {
+            Name = "prioridade-alta",
+            Kind = EvalAssertionKind.ToolArgument,
+            Target = "escalar_humano",
+            Value = "prioridade=alta",
+        };
+
+        Assert.True(assertion.Evaluate(Tool("escalar_humano", ("prioridade", "alta"))).Passed);
+
+        var valorErrado = assertion.Evaluate(Tool("escalar_humano", ("prioridade", "baixa")));
+        Assert.False(valorErrado.Passed, "ToolArgument aceitou o argumento com o VALOR errado");
+        Assert.Contains("prioridade=alta", valorErrado.Reason, StringComparison.Ordinal);
+
+        Assert.False(
+            assertion.Evaluate(Tool("escalar_humano", ("motivo", "alta"))).Passed,
+            "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")) })
+        {
+            Assert.Equal("saudacao", outcome.Assertion);
+            Assert.Equal(EvalAssertionKind.Contains, outcome.Kind);
+        }
+    }
+}