@polymorphism-tech/morph-spec 8.33.0 → 8.35.0

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

@@ -0,0 +1,194 @@
+using System.Security.Cryptography;
+using Microsoft.Extensions.AI.Evaluation.Quality;
+using Morph.AiKit.Evals;
+using Morph.AiKit.Tests.Fakes;
+using Xunit;
+
+namespace Morph.AiKit.Tests.Evals;
+
+/// <summary>
+/// Regravacao, e o invariante barato que protege a premissa de commitabilidade:
+/// <b>uma leitura nao escreve um byte na arvore de cache</b>.
+/// </summary>
+public sealed class EvalRefreshTests
+{
+    /// <summary>
+    /// Impressao digital da arvore: caminho relativo mais SHA-256 de cada arquivo.
+    /// </summary>
+    /// <remarks>
+    /// Comparar CONTEUDO, e nao data de modificacao: o que importa e se o proximo
+    /// <c>git status</c> mostra diff, e o git tambem olha conteudo. Um teste sobre mtime
+    /// falharia por gravacao identica e passaria por gravacao diferente no mesmo tick.
+    /// </remarks>
+    private static IReadOnlyList<string> Fingerprint(string root)
+    {
+        if (!Directory.Exists(root))
+        {
+            return [];
+        }
+
+        return [.. Directory
+            .EnumerateFiles(root, "*", SearchOption.AllDirectories)
+            .OrderBy(p => p.Replace('\\', '/'), StringComparer.Ordinal)
+            .Select(p => $"{Path.GetRelativePath(root, p).Replace('\\', '/')} {Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(p)))}")];
+    }
+
+    private static void WriteThreeScenarios(EvalWorkspace ws, FakeChatClient fake)
+    {
+        foreach (var name in new[] { "a-primeiro", "b-segundo", "c-terceiro" })
+        {
+            ws.WriteScenario("triagem", "acme", name, $"pergunta {name}", """[ { "kind": "contains", "value": "resposta" } ]""");
+            fake.EnqueueText($"resposta {name}");
+        }
+    }
+
+    [Fact]
+    public async Task AReadWithAWarmCacheLeavesTheTreeBYTEForBYTEIdentical()
+    {
+        using var ws = new EvalWorkspace();
+        using var fake = new FakeChatClient { MetadataProviderName = "morph-fake", MetadataDefaultModelId = "modelo-exemplar" };
+        WriteThreeScenarios(ws, fake);
+
+        await using (var refresh = EvalFixture.Create(ws.Options(EvalMode.Refresh), fake))
+        {
+            await refresh.RunAllAsync(TestContext.Current.CancellationToken);
+        }
+
+        var before = Fingerprint(ws.CacheRoot);
+        Assert.NotEmpty(before);
+
+        await using (var offline = EvalFixture.Create(ws.Options(EvalMode.Offline)))
+        {
+            var summary = await offline.RunAllAsync(TestContext.Current.CancellationToken);
+            Assert.Equal(3, summary.Passed);
+        }
+
+        // Se algum dia a biblioteca passar a tocar disco no caminho de HIT, este canario morde
+        // no dia em que isso acontecer — e nao meses depois, quando alguem estranhar um diff
+        // que aparece sozinho em toda rodada.
+        Assert.Equal(before, Fingerprint(ws.CacheRoot));
+    }
+
+    [Fact]
+    public async Task ExecutionResultsLandOUTSIDETheCommittedCacheTree()
+    {
+        using var ws = new EvalWorkspace();
+        using var fake = new FakeChatClient { MetadataProviderName = "morph-fake", MetadataDefaultModelId = "modelo-exemplar" };
+        WriteThreeScenarios(ws, fake);
+
+        await using var refresh = EvalFixture.Create(ws.Options(EvalMode.Refresh), fake);
+        await refresh.RunAllAsync(TestContext.Current.CancellationToken);
+
+        // Os resultados carregam latencia de cronometro, uso de tokens e o flag de cache hit:
+        // commita-los seria diff garantido em toda rodada, sem sinal nenhum. Por CONSTRUCAO
+        // (outra raiz), nunca por um .gitignore dentro de um diretorio commitado.
+        Assert.True(Directory.Exists(ws.ResultsRoot), "o store de resultados tem de existir depois de um run");
+        Assert.NotEmpty(Directory.EnumerateFiles(ws.ResultsRoot, "*", SearchOption.AllDirectories));
+
+        var full = Path.GetFullPath(ws.CacheRoot).Replace('\\', '/');
+        foreach (var file in Directory.EnumerateFiles(ws.ResultsRoot, "*", SearchOption.AllDirectories))
+        {
+            Assert.DoesNotContain(full, Path.GetFullPath(file).Replace('\\', '/'), StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    [Fact]
+    public async Task RefreshRewritesTheTreeAndCountsEveryScenarioAsAProviderCall()
+    {
+        using var ws = new EvalWorkspace();
+        using var fake = new FakeChatClient { MetadataProviderName = "morph-fake", MetadataDefaultModelId = "modelo-exemplar" };
+        WriteThreeScenarios(ws, fake);
+
+        await using var refresh = EvalFixture.Create(ws.Options(EvalMode.Refresh), fake);
+        var summary = await refresh.RunAllAsync(TestContext.Current.CancellationToken);
+
+        // O contador do cliente real e o que torna "a cache esta fria" uma MEDICAO: a arvore
+        // mudou e precisa ser commitada, e isso e afirmacao com consequencia.
+        Assert.Equal(3, summary.Misses);
+        Assert.Equal(EvalCacheState.Cold, summary.Cache);
+        Assert.Equal(3, fake.CallCount);
+    }
+
+    [Fact]
+    public async Task ASecondRefreshZeroesTheTreeInsteadOfLayeringOverIt()
+    {
+        using var ws = new EvalWorkspace();
+
+        using (var fake = new FakeChatClient { MetadataProviderName = "morph-fake", MetadataDefaultModelId = "modelo-exemplar" })
+        {
+            WriteThreeScenarios(ws, fake);
+            await using var first = EvalFixture.Create(ws.Options(EvalMode.Refresh), fake);
+            await first.RunAllAsync(TestContext.Current.CancellationToken);
+        }
+
+        // O cenario do meio some do dataset. Uma regravacao PARCIAL deixaria a entrada antiga
+        // dele viva na arvore, e a proxima leitura offline nao teria como saber que ela nao
+        // corresponde mais a nenhum cenario declarado.
+        File.Delete(Path.Combine(ws.DatasetRoot, "triagem", "acme", "b-segundo.json"));
+
+        using (var fake = new FakeChatClient { MetadataProviderName = "morph-fake", MetadataDefaultModelId = "modelo-exemplar" })
+        {
+            fake.EnqueueText("resposta a-primeiro").EnqueueText("resposta c-terceiro");
+            await using var second = EvalFixture.Create(ws.Options(EvalMode.Refresh), fake);
+            await second.RunAllAsync(TestContext.Current.CancellationToken);
+        }
+
+        var survivors = Fingerprint(ws.CacheRoot);
+        Assert.DoesNotContain(survivors, entry => entry.Contains("b-segundo", StringComparison.Ordinal));
+        Assert.Contains(survivors, entry => entry.Contains("a-primeiro", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public async Task QualityEvaluatorsAreWiredAsREPORTEDMetrics_NeverAsTheGate()
+    {
+        using var ws = new EvalWorkspace();
+        using var fake = new FakeChatClient { MetadataProviderName = "morph-fake", MetadataDefaultModelId = "modelo-exemplar" };
+
+        // A lista vem do KIT, e nao do teste: e ela que da ao pacote .Quality cobertura de
+        // COMPILACAO em src/ (sem um using real la, o pin daquele pacote teria so contrato de
+        // versao, e um rename de API nao reprovaria PR nenhuma).
+        var quality = EvalQualityEvaluators.Stable();
+
+        await using var fixture = EvalFixture.Create(ws.Options(EvalMode.Refresh), fake, quality);
+
+        // A superficie existe e COMPILA contra as versoes do pin — que e o que um kit de
+        // template tem de garantir. O que ela NAO faz e decidir: o veredito de um cenario sai
+        // das assercoes deterministicas, e uma metrica de juizo entra no sumario como numero.
+        // Sem isso, a variancia de LLM reprovaria PRs e o no de eval nasceria destinado a ser
+        // desligado do CI.
+        Assert.Equal(2, quality.Count);
+        Assert.All(quality, evaluator => Assert.NotEmpty(evaluator.EvaluationMetricNames));
+        Assert.Empty(fixture.Summary.Quality);
+
+        // Uma lista NOVA a cada chamada: um array compartilhado seria estado global
+        // disfarcado de conveniencia, e a ReportingConfiguration guarda o que recebe.
+        Assert.NotSame(quality, EvalQualityEvaluators.Stable());
+    }
+
+    [Theory]
+    [InlineData("Microsoft.Extensions.AI.Evaluation.Quality.RelevanceEvaluator", false)]
+    [InlineData("Microsoft.Extensions.AI.Evaluation.Quality.CompletenessEvaluator", false)]
+    [InlineData("Microsoft.Extensions.AI.Evaluation.Quality.TaskAdherenceEvaluator", true)]
+    [InlineData("Microsoft.Extensions.AI.Evaluation.Quality.ToolCallAccuracyEvaluator", true)]
+    public void WhichQualityEvaluatorsAreExperimentalIsMEASURED_NotRemembered(string typeName, bool experimental)
+    {
+        // O plano descrevia os QUATRO como estaveis. Dois nao sao: eles carregam
+        // [Experimental("AIEVAL001")] na 10.9.0, e usa-los sob TreatWarningsAsErrors exigiria
+        // suprimir um diagnostico — uma decisao consciente, nunca um efeito colateral. Se um
+        // dia a Microsoft estabilizar (ou marcar) algum deles, este teste morre e a escolha e
+        // rediscutida com o fato na mao, em vez de envelhecer em silencio num comentario.
+        var type = typeof(RelevanceEvaluator).Assembly.GetType(typeName);
+        Assert.NotNull(type);
+
+        var attribute = type!
+            .GetCustomAttributes(typeof(System.Diagnostics.CodeAnalysis.ExperimentalAttribute), inherit: false)
+            .Cast<System.Diagnostics.CodeAnalysis.ExperimentalAttribute>()
+            .SingleOrDefault();
+
+        Assert.Equal(experimental, attribute is not null);
+        if (experimental)
+        {
+            Assert.Equal("AIEVAL001", attribute!.DiagnosticId);
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+using Morph.AiKit.Evals;
+
+namespace Morph.AiKit.Tests.Evals;
+
+/// <summary>
+/// Um diretorio temporario com dataset, cache e resultados — a montagem que todo teste de
+/// eval precisa, escrita uma vez.
+/// </summary>
+/// <remarks>
+/// Ele existe para que os testes falem de COMPORTAMENTO e nao de caminhos. E cada instancia
+/// tem raiz propria (GUID v7): dois testes rodando lado a lado nao podem disputar a mesma
+/// arvore de cache, senao a falha aparece como flake e nao como defeito.
+/// </remarks>
+internal sealed class EvalWorkspace : IDisposable
+{
+    public EvalWorkspace()
+    {
+        Root = Path.Combine(Path.GetTempPath(), $"morph-eval-{Guid.CreateVersion7():N}");
+        Directory.CreateDirectory(CacheRoot);
+        Directory.CreateDirectory(DatasetRoot);
+    }
+
+    public string Root { get; }
+
+    public string CacheRoot => Path.Combine(Root, "eval-cache");
+
+    public string DatasetRoot => Path.Combine(Root, "eval-datasets");
+
+    public string ResultsRoot => Path.Combine(Root, "eval-results");
+
+    public string SummaryPath => Path.Combine(Root, "summary.json");
+
+    /// <summary>O pin exemplar: a data e as versoes sob as quais a arvore diz ter sido gravada.</summary>
+    public static EvalPin Pin { get; } = new(
+        "2026-09-08",
+        new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["Microsoft.Extensions.AI"] = "10.9.0",
+            ["Microsoft.Extensions.AI.Evaluation"] = "10.9.0",
+        });
+
+    /// <summary>Escreve um cenario no dataset e devolve o caminho do arquivo.</summary>
+    public string WriteScenario(string agent, string tenant, string name, string userText, string assertions)
+    {
+        var dir = Path.Combine(DatasetRoot, agent, tenant);
+        Directory.CreateDirectory(dir);
+        var file = Path.Combine(dir, $"{name}.json");
+        File.WriteAllText(file, $$"""
+        {
+          "messages": [ { "role": "user", "text": {{System.Text.Json.JsonSerializer.Serialize(userText)}} } ],
+          "assertions": {{assertions}}
+        }
+        """);
+        return file;
+    }
+
+    /// <summary>Opcoes prontas para um modo, com TTL longo e o pin exemplar.</summary>
+    public EvalCacheOptions Options(EvalMode mode, EvalPin? pin = null) => new()
+    {
+        CacheRoot = CacheRoot,
+        DatasetRoot = DatasetRoot,
+        ResultsRoot = ResultsRoot,
+        TimeToLive = TimeSpan.FromDays(3650),
+        ProviderName = "morph-fake",
+        DefaultModelId = "modelo-exemplar",
+        Mode = mode,
+        SummaryPath = SummaryPath,
+        Pin = pin ?? Pin,
+    };
+
+    public void Dispose()
+    {
+        try
+        {
+            if (Directory.Exists(Root))
+            {
+                Directory.Delete(Root, recursive: true);
+            }
+        }
+        catch (IOException)
+        {
+            // Um temporario que resiste a remocao nao pode derrubar um teste que ja provou o
+            // que veio provar.
+        }
+    }
+}

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

@@ -0,0 +1,213 @@
+using Morph.AiKit.Evals;
+using Morph.AiKit.Tests.Fakes;
+using Xunit;
+
+namespace Morph.AiKit.Tests.Evals;
+
+/// <summary>
+/// Os evals DO PROPRIO KIT, contra a arvore de cache COMMITADA — sem credencial, sem rede.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Esta classe e o exemplar que um projeto copia. Ela roda com a categoria <c>Eval</c>, le a
+/// cache commitada em <c>eval-cache/</c> e o dataset versionado em <c>eval-datasets/</c>, e
+/// termina verde com TODAS as variaveis de credencial ausentes. Se algum cenario nao estiver
+/// na cache, ela fica VERMELHA nomeando o cenario — nunca <c>skip</c>.
+/// </para>
+/// <para>
+/// <b>A cache foi semeada por FAKE, jamais por chamada paga</b> (ver <see cref="SeedTheCommittedCacheTree"/>).
+/// O caminho de ESCRITA exercitado e o da biblioteca e a chave e computada pela mesma funcao
+/// que a leitura usa — entao a leitura offline le exatamente o que aquela escrita produziu.
+/// A lacuna residual, declarada em voz alta: isto NAO prova que uma cache gravada contra um
+/// provider real e legivel offline. O que a mitiga e um fato medido — a chave depende de
+/// <c>ProviderName</c> e <c>DefaultModelId</c>, e nao do endpoint, e os dois estao sob nosso
+/// controle no cliente offline.
+/// </para>
+/// </remarks>
+public sealed class KitEvals
+{
+    /// <summary>Identidade sob a qual a arvore commitada foi gravada. Ela ENTRA NA CHAVE.</summary>
+    private const string Provider = "morph-fake";
+
+    /// <summary>Idem. Trocar qualquer um dos dois invalida a arvore inteira.</summary>
+    private const string Model = "morph-kit-exemplar";
+
+    /// <summary>
+    /// O diretorio do PROJETO de teste, achado subindo a partir do assembly.
+    /// </summary>
+    /// <remarks>
+    /// De proposito: a alternativa seria copiar a cache para <c>bin/</c> e ler a copia — e ai
+    /// o canario de "um run offline nao suja a arvore commitada" seria verdadeiro por
+    /// vacuidade, porque a arvore commitada nem teria sido tocada.
+    /// </remarks>
+    private static string ProjectDirectory
+    {
+        get
+        {
+            var dir = new DirectoryInfo(AppContext.BaseDirectory);
+            while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "Morph.AiKit.Tests.csproj")))
+            {
+                dir = dir.Parent;
+            }
+
+            return dir?.FullName ?? throw new DirectoryNotFoundException(
+                "nao foi possivel localizar Morph.AiKit.Tests.csproj subindo a partir de " + AppContext.BaseDirectory);
+        }
+    }
+
+    private static string CacheRoot => Path.Combine(ProjectDirectory, "eval-cache");
+
+    private static string DatasetRoot => Path.Combine(ProjectDirectory, "eval-datasets");
+
+    /// <summary>O pin sob o qual a arvore commitada foi gravada — o mesmo que o carimbo carrega.</summary>
+    private static EvalPin Pin => new(
+        "2026-09-08",
+        new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["Microsoft.Extensions.AI"] = "10.9.0",
+            ["Microsoft.Extensions.AI.Evaluation"] = "10.9.0",
+            ["Microsoft.Extensions.AI.Evaluation.Quality"] = "10.9.0",
+            ["Microsoft.Extensions.AI.Evaluation.Reporting"] = "10.9.0",
+        });
+
+    private static EvalCacheOptions Options(EvalMode mode, string? summaryPath) => new()
+    {
+        CacheRoot = CacheRoot,
+        DatasetRoot = DatasetRoot,
+        // FORA da arvore commitada: os resultados carregam latencia, uso de tokens e o flag
+        // de cache hit, e commita-los seria diff garantido em toda rodada.
+        ResultsRoot = Path.Combine(Path.GetTempPath(), "morph-kit-eval-results"),
+        TimeToLive = TimeSpan.FromDays(3650),
+        ProviderName = Provider,
+        DefaultModelId = Model,
+        Mode = mode,
+        SummaryPath = summaryPath,
+        Pin = Pin,
+    };
+
+    [Fact]
+    [Trait("Category", "Eval")]
+    public async Task TheKitEvalsRunGreenFromTheCommittedCacheWithNoCredentialAtAll()
+    {
+        // Nenhuma variavel de credencial e lida por nada nesta montagem — o cliente interno
+        // e o OfflineChatClient, que nao abre socket e nao le ambiente. Se a cache nao
+        // respondesse, este teste morreria com EvalCacheMissException nomeando o cenario.
+        var summaryPath = Path.Combine(Path.GetTempPath(), $"morph-kit-eval-{Guid.CreateVersion7():N}.json");
+
+        try
+        {
+            await using var fixture = EvalFixture.Create(Options(EvalMode.Offline, summaryPath));
+            var summary = await fixture.RunAllAsync(TestContext.Current.CancellationToken);
+
+            Assert.Equal(EvalCacheState.Warm, summary.Cache);
+            Assert.Equal("ok", summary.Stamp);
+
+            // NOMEANDO. `Assert.Equal(0, summary.Failed)` produzia "Expected 0, Actual 1" —
+            // verdadeiro e inutil: nao dizia qual cenario nem qual regua. A rubrica
+            // eval-de-modelo.md exige, na banda 9-10, derrubar o cenario NOMEANDO-O.
+            Assert.True(summary.Failed == 0, summary.DescribeFailures());
+            Assert.Empty(summary.Failures);
+            Assert.Equal(summary.Scenarios, summary.Passed);
+
+            // A prova central, e ela e um CONTADOR: o cliente interno e o unico caminho para
+            // a rede, e ele nao foi invocado nenhuma vez.
+            Assert.Equal(0, summary.Misses);
+            Assert.Equal(0, fixture.Offline!.Invocations);
+
+            // O dataset nao pode encolher em silencio: uma suite de eval que passa a avaliar
+            // menos cenarios e a mesma classe de defeito que uma baseline de teste caindo.
+            Assert.Equal(4, summary.Scenarios);
+        }
+        finally
+        {
+            if (File.Exists(summaryPath))
+            {
+                File.Delete(summaryPath);
+            }
+        }
+    }
+
+    [Fact]
+    [Trait("Category", "Eval")]
+    public void TheCommittedCacheCarriesTheStampOfThePinItWasWrittenUnder()
+    {
+        var stamp = EvalCacheStamp.Read(CacheRoot);
+
+        Assert.NotNull(stamp);
+        Assert.Equal("2026-09-08", stamp!.PinnedAt);
+        Assert.Equal(Provider, stamp.Provider);
+        Assert.Equal(Model, stamp.Model);
+        Assert.Equal("10.9.0", stamp.Packages["Microsoft.Extensions.AI.Evaluation"]);
+    }
+
+    [Fact]
+    [Trait("Category", "Eval")]
+    public void TheCommittedCacheCarriesNoABSOLUTEPathOfTheMachineThatWroteIt()
+    {
+        // A premissa que torna a arvore commitavel: nada dentro dela aponta para o disco de
+        // quem gravou. Medido, e nao suposto — se um dia a biblioteca passar a gravar o
+        // storageRootPath dentro das entradas, este canario morde.
+        var root = ProjectDirectory.Replace('\\', '/');
+        var drive = Path.GetPathRoot(ProjectDirectory)?.Replace('\\', '/');
+
+        // A raiz so' identifica uma MAQUINA quando e' uma unidade nomeada ("R:/"). Em POSIX
+        // `GetPathRoot` devolve "/", que nao identifica nada — e exigir que a cache nao
+        // contenha "/" reprova qualquer arquivo com um path ou uma URL dentro. O canario
+        // passava no Windows e era ABSURDO no Linux: media "nenhuma barra em lugar nenhum".
+        // Medido no CI (job ai-kit, ubuntu): 1 falha, `Assert.DoesNotContain() Sub-string found`.
+        var namedDrive = drive is { Length: > 1 } && drive.Contains(':');
+
+        foreach (var file in Directory.EnumerateFiles(CacheRoot, "*", SearchOption.AllDirectories))
+        {
+            var text = File.ReadAllText(file).Replace("\\\\", "/").Replace('\\', '/');
+            Assert.DoesNotContain(root, text, StringComparison.OrdinalIgnoreCase);
+            if (namedDrive)
+            {
+                Assert.DoesNotContain(drive!, text, StringComparison.OrdinalIgnoreCase);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Regrava a arvore commitada a partir do fake. NAO roda em CI.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Ele existe committed, e nao como um script que alguem rodou uma vez e jogou fora,
+    /// porque a proxima pessoa que subir o pin precisa saber COMO regravar — e uma instrucao
+    /// em prosa envelhece; um teste executavel nao.
+    /// </para>
+    /// <para>
+    /// A porta e uma variavel de ambiente, e nao um <c>[Fact(Skip=...)]</c> fixo, porque um
+    /// skip fixo nunca poderia ser exercitado: seria um seeder que ninguem consegue rodar.
+    /// Rode com <c>MORPH_EVAL_SEED=1 dotnet test</c> e commite a arvore que sair.
+    /// </para>
+    /// </remarks>
+    [Fact]
+    public async Task SeedTheCommittedCacheTree()
+    {
+        Assert.SkipUnless(
+            Environment.GetEnvironmentVariable("MORPH_EVAL_SEED") == "1",
+            "semeadura da cache exemplar: rode com MORPH_EVAL_SEED=1 e commite a arvore resultante");
+
+        using var fake = new FakeChatClient
+        {
+            MetadataProviderName = Provider,
+            MetadataDefaultModelId = Model,
+        };
+
+        // Uma resposta por cenario, na ORDEM do dataset (ordinal por caminho relativo):
+        // orcamento/acme/a-resposta-estruturada, triagem/acme/a-saudacao,
+        // triagem/acme/b-escalonamento, triagem/globex/a-saudacao.
+        fake.EnqueueText("""{"valor":"R$ 1.200,00","prazo":"5 dias uteis"}""")
+            .EnqueueText("Bom dia! Como posso ajudar voce hoje?")
+            .EnqueueText("Encaminhando voce para um atendente humano agora.")
+            .EnqueueText("Bom dia! Aqui e o atendimento da Globex.");
+
+        await using var fixture = EvalFixture.Create(Options(EvalMode.Refresh, summaryPath: null), fake);
+        var summary = await fixture.RunAllAsync(TestContext.Current.CancellationToken);
+
+        Assert.Equal(summary.Scenarios, summary.Passed);
+        Assert.Equal(EvalCacheState.Cold, summary.Cache);
+    }
+}

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

@@ -0,0 +1,95 @@
+using Microsoft.Extensions.AI;
+using Morph.AiKit.Evals;
+using Xunit;
+
+namespace Morph.AiKit.Tests.Evals;
+
+/// <summary>
+/// O cliente que RECUSA: a peca de que depende "o eval roda no CI sem credencial".
+/// </summary>
+public sealed class OfflineChatClientTests
+{
+    private static OfflineChatClient Build(Func<string>? scenario = null)
+        => new("morph-fake", "modelo-exemplar", "/tmp/eval-cache", ".env.evals", scenario ?? (() => "triagem.acme.saudacao"));
+
+    [Fact]
+    public void ItReplicatesTheProviderAndModelOfTheRunThatWroteTheCache()
+    {
+        using var client = Build();
+
+        var metadata = Assert.IsType<ChatClientMetadata>(client.GetService(typeof(ChatClientMetadata)));
+
+        // Estes DOIS campos entram na chave de cache. Se divergissem do run que gravou, todo
+        // cenario daria miss e a cache quente seria indistinguivel de uma cache vazia.
+        Assert.Equal("morph-fake", metadata.ProviderName);
+        Assert.Equal("modelo-exemplar", metadata.DefaultModelId);
+
+        // E o endpoint e NULO de proposito: ele nao entra na chave (medido na v10.9.0), e um
+        // cliente que nunca liga para lugar nenhum nao deve anunciar um destino.
+        Assert.Null(metadata.ProviderUri);
+    }
+
+    [Fact]
+    public async Task ARequestRefusesInsteadOfReachingTheNetwork()
+    {
+        using var client = Build();
+
+        var error = await Assert.ThrowsAsync<EvalCacheMissException>(
+            () => client.GetResponseAsync([new ChatMessage(ChatRole.User, "oi")], cancellationToken: TestContext.Current.CancellationToken));
+
+        Assert.Equal("triagem.acme.saudacao", error.ScenarioName);
+        Assert.Equal("/tmp/eval-cache", error.CachePath);
+        Assert.Equal(".env.evals", error.EnvFile);
+    }
+
+    [Fact]
+    public void TheCounterRisesOnEveryAttempt_ItIsTheProofOfZeroPaidCalls()
+    {
+        using var client = Build();
+        Assert.Equal(0, client.Invocations);
+
+        for (var i = 1; i <= 3; i++)
+        {
+            Assert.Throws<EvalCacheMissException>(
+                () => client.GetStreamingResponseAsync([new ChatMessage(ChatRole.User, "oi")], cancellationToken: TestContext.Current.CancellationToken));
+            Assert.Equal(i, client.Invocations);
+        }
+    }
+
+    [Fact]
+    public void TheScenarioNameIsReadAtCALLTIME_NotCaptured()
+    {
+        // Um fixture roda N cenarios com o MESMO cliente. Se o nome fosse capturado na
+        // construcao, toda mensagem de miss nomearia o primeiro cenario e mandaria o leitor
+        // investigar o arquivo errado.
+        var current = "primeiro";
+        using var client = Build(() => current);
+
+        var first = Assert.Throws<EvalCacheMissException>(
+            () => client.GetStreamingResponseAsync([new ChatMessage(ChatRole.User, "oi")], cancellationToken: TestContext.Current.CancellationToken));
+        Assert.Equal("primeiro", first.ScenarioName);
+
+        current = "segundo";
+        var second = Assert.Throws<EvalCacheMissException>(
+            () => client.GetStreamingResponseAsync([new ChatMessage(ChatRole.User, "oi")], cancellationToken: TestContext.Current.CancellationToken));
+        Assert.Equal("segundo", second.ScenarioName);
+    }
+
+    [Fact]
+    public void ItRefusesToBeBuiltWithoutTheIdentityThatEntersTheCacheKey()
+    {
+        Assert.Throws<ArgumentException>(() => new OfflineChatClient(" ", "m", "/tmp", ".env", () => "s"));
+        Assert.Throws<ArgumentException>(() => new OfflineChatClient("p", "m", " ", ".env", () => "s"));
+        Assert.Throws<ArgumentNullException>(() => new OfflineChatClient("p", "m", "/tmp", ".env", null!));
+    }
+
+    [Fact]
+    public void GetServiceAnswersLikeARealClientAndNeverInventsAKeyedService()
+    {
+        using var client = Build();
+
+        Assert.Same(client, client.GetService(typeof(IChatClient)));
+        Assert.Null(client.GetService(typeof(ChatClientMetadata), serviceKey: "qualquer"));
+        Assert.Null(client.GetService(typeof(string)));
+    }
+}