@polymorphism-tech/morph-spec 8.34.2 → 8.35.1

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

@@ -0,0 +1,98 @@
+using System.Text;
+using Morph.AiKit.Media;
+using Morph.AiKit.Tests.Fakes;
+using Xunit;
+
+namespace Morph.AiKit.Tests;
+
+/// <summary>
+/// Canarios do <see cref="MediaStore"/>: endereco por conteudo, e gravacao unica.
+/// </summary>
+/// <remarks>
+/// A armadilha deste arquivo, e a razao de <see cref="InMemoryMediaBlobs.Writes"/> existir:
+/// um teste que so conferisse "o hash e o mesmo" <b>nao distingue dedupe de regravacao</b>,
+/// porque os dois produzem o mesmo hash. A afirmacao "grava uma vez" so e verificavel
+/// contando gravacoes no blob.
+/// </remarks>
+public sealed class MediaStoreTests
+{
+    private static CancellationToken Ct => TestContext.Current.CancellationToken;
+
+    private static ReadOnlyMemory<byte> Bytes(string s) => Encoding.UTF8.GetBytes(s);
+
+    /// <summary>Mesmo conteudo, mesmo hash, mesmo caminho — e UMA gravacao.</summary>
+    [Fact]
+    public async Task TheSameContentIsStoredOnce()
+    {
+        var blobs = new InMemoryMediaBlobs();
+        var store = new MediaStore(blobs);
+
+        var first = await store.PutAsync(Bytes("os bytes"), "image/png", Ct);
+        var second = await store.PutAsync(Bytes("os bytes"), "image/png", Ct);
+
+        Assert.Equal(first.Hash, second.Hash);
+        Assert.Equal(first.RelativePath, second.RelativePath);
+        Assert.False(first.AlreadyExisted);
+        Assert.True(second.AlreadyExisted);
+        Assert.Equal(1, blobs.Writes);
+    }
+
+    /// <summary>Conteudo diferente, endereco diferente, duas gravacoes.</summary>
+    [Fact]
+    public async Task DifferentContentGetsADifferentAddress()
+    {
+        var blobs = new InMemoryMediaBlobs();
+        var store = new MediaStore(blobs);
+
+        var a = await store.PutAsync(Bytes("um"), "image/png", Ct);
+        var b = await store.PutAsync(Bytes("outro"), "image/png", Ct);
+
+        Assert.NotEqual(a.Hash, b.Hash);
+        Assert.NotEqual(a.RelativePath, b.RelativePath);
+        Assert.Equal(2, blobs.Writes);
+    }
+
+    /// <summary>
+    /// O hash e o do CONTEUDO, e nao do conteudo mais o MIME: o mesmo PNG servido como
+    /// <c>image/png</c> e como <c>application/octet-stream</c> e o mesmo arquivo.
+    /// </summary>
+    [Fact]
+    public void TheHashIsOfTheContentAlone()
+        => Assert.Equal(MediaHash.Of(Bytes("x").Span), MediaHash.Of(Bytes("x").Span));
+
+    /// <summary>
+    /// O caminho tem dois niveis de prefixo. Um diretorio unico com centenas de milhares de
+    /// arquivos degrada listagem em praticamente todo sistema de arquivos.
+    /// </summary>
+    [Fact]
+    public void ThePathIsShardedByTheFirstFourHexDigits()
+    {
+        var hash = MediaHash.Of(Bytes("qualquer").Span);
+        var path = MediaStore.RelativePathFor(hash, "image/png");
+
+        Assert.Equal($"{hash.Value[..2]}/{hash.Value[2..4]}/{hash.Value}.png", path);
+    }
+
+    /// <summary>
+    /// MIME desconhecido vira <c>.bin</c> e NAO recusa: perder a extensao e cosmetico,
+    /// perder os bytes pelos quais se pagou nao e.
+    /// </summary>
+    [Theory]
+    [InlineData("image/png", ".png")]
+    [InlineData("image/jpeg", ".jpg")]
+    [InlineData("image/webp", ".webp")]
+    [InlineData("video/mp4", ".mp4")]
+    [InlineData("application/x-inventado", ".bin")]
+    public void UnknownMediaTypesStillGetAPath(string mediaType, string expected)
+        => Assert.Equal(expected, MediaStore.ExtensionFor(mediaType));
+
+    /// <summary>MIME em branco e defeito de chamada, e grita no lugar em que aconteceu.</summary>
+    [Fact]
+    public async Task ABlankMediaTypeIsRefused()
+    {
+        var store = new MediaStore(new InMemoryMediaBlobs());
+
+        await Assert.ThrowsAsync<ArgumentException>(
+            async () => await store.PutAsync(Bytes("x"), "  ", Ct));
+    }
+}

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

@@ -0,0 +1,451 @@
+using Microsoft.Extensions.AI;
+using Morph.AiKit.Agents;
+using Morph.AiKit.Providers;
+using Morph.AiKit.Tests.Fakes;
+using Xunit;
+
+namespace Morph.AiKit.Tests;
+
+/// <summary>
+/// Canarios do <see cref="ModelRegistry"/> (T8). Tres coisas sao cobradas aqui, e as tres
+/// sao as que o registry v1 nao tinha: <b>protocolo por alias</b>, <b>tarifa por alias</b>
+/// e <b>falha explicita</b> onde antes havia nulo silencioso.
+/// </summary>
+public sealed class ModelRegistryTests
+{
+    /// <summary>O exemplar de verdade, embutido do proprio arquivo que o kit publica.</summary>
+    private static string ExampleDocument()
+    {
+        using var stream = typeof(ModelRegistryTests).Assembly
+            .GetManifestResourceStream("model-registry.v2.json")
+            ?? throw new InvalidOperationException(
+                "model-registry.v2.json nao foi embutido no assembly de teste.");
+
+        using var reader = new StreamReader(stream);
+        return reader.ReadToEnd();
+    }
+
+    private static string Document(string aliasesBody, string extraRoot = "")
+        => $$"""
+        {
+          "version": "2.0"{{extraRoot}},
+          "aliases": { {{aliasesBody}} }
+        }
+        """;
+
+    // ---------------------------------------------------------------------------------
+    // O exemplar publicado carrega — e expoe api e pricing por alias
+    // ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void ThePublishedExampleLoadsAndExposesApiAndPricingPerAlias()
+    {
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), new FakeProviderClientFactory());
+
+        Assert.Equal(
+            ["local-dev", "text-default", "text-heavy", "text-heavy-chat", "vision"],
+            registry.Aliases.Order(StringComparer.Ordinal));
+
+        Assert.Equal("text-default", registry.DefaultAlias);
+
+        // 'api' omitido cai em Responses — a decisao da casa, verificada e nao suposta.
+        Assert.Equal(AgentApi.Responses, registry.Resolve("text-default").Api);
+        Assert.Equal(AgentApi.Responses, registry.Resolve("text-heavy").Api);
+
+        // ... e o MESMO modelo, sob outro alias, pode falar Chat Completions.
+        var chat = registry.Resolve("text-heavy-chat");
+        Assert.Equal(AgentApi.Chat, chat.Api);
+        Assert.Equal(registry.Resolve("text-heavy").Model, chat.Model);
+
+        var pricing = registry.Resolve("text-heavy").RequirePricing();
+        Assert.Equal(1.25m, pricing.InputPerMTok);
+        Assert.Equal(10.0m, pricing.OutputPerMTok);
+        Assert.Equal(0.125m, pricing.CachedInputPerMTok);
+
+        // cachedInputPerMTok explicitamente nulo = sem desconto declarado (nao "de graca").
+        Assert.Null(registry.Resolve("vision").RequirePricing().CachedInputPerMTok);
+
+        Assert.Equal("http://localhost:11434/v1", registry.Resolve("local-dev").Endpoint);
+    }
+
+    [Fact]
+    public void TheExampleCarriesTheChatCompletionsLimitWithItsProvenance()
+    {
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), new FakeProviderClientFactory());
+
+        var constraints = registry.Resolve("text-heavy-chat").Constraints;
+
+        Assert.True(constraints.ToolCallingRequiresReasoningEffortNone);
+        Assert.False(constraints.TemperatureUnsupported);
+        Assert.Contains("reasoning_effort", constraints.Provenance!, StringComparison.Ordinal);
+    }
+
+    // ---------------------------------------------------------------------------------
+    // Tarifa ausente e ALTO, nunca nulo silencioso
+    // ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void AnAliasWithNeitherPricingNorWaiverIsRefusedAtLoadNamingTheAlias()
+    {
+        var document = Document("""
+            "orfao": { "provider": "openai", "model": "gpt-5.4" }
+            """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Equal(ModelRegistryError.InvalidDocument, error.Reason);
+        Assert.Contains("alias 'orfao'", error.Message, StringComparison.Ordinal);
+        Assert.Contains("pricingWaiver", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AnAliasWithBothPricingAndWaiverIsRefusedBecauseNeitherWins()
+    {
+        var document = Document("""
+            "ambiguo": {
+              "provider": "openai", "model": "gpt-5.4",
+              "pricing": { "inputPerMTok": 1, "outputPerMTok": 2 },
+              "pricingWaiver": "nao tem preco"
+            }
+            """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("alias 'ambiguo'", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AWaivedAliasLoadsAndSaysWhyItHasNoTariff()
+    {
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), new FakeProviderClientFactory());
+
+        var local = registry.Resolve("local-dev");
+
+        Assert.False(local.HasPricing);
+        Assert.Contains("modelo local", local.PricingWaiver!, StringComparison.Ordinal);
+
+        var error = Assert.Throws<ModelRegistryException>(() => { _ = local.RequirePricing(); });
+        Assert.Equal(ModelRegistryError.MissingPricing, error.Reason);
+        Assert.Contains("local-dev", error.Message, StringComparison.Ordinal);
+        Assert.Contains("modelo local", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ANegativeTariffIsRefused()
+    {
+        var document = Document("""
+            "barato-demais": {
+              "provider": "openai", "model": "gpt-5.4",
+              "pricing": { "inputPerMTok": -1, "outputPerMTok": 2 }
+            }
+            """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("inputPerMTok", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ATypoInAFieldNameIsRefusedInsteadOfSilentlyIgnored()
+    {
+        // "priceing" seria lido como "sem pricing" — e a ausencia silenciosa e o defeito.
+        var document = Document("""
+            "digitado-errado": {
+              "provider": "openai", "model": "gpt-5.4",
+              "priceing": { "inputPerMTok": 1, "outputPerMTok": 2 }
+            }
+            """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("priceing", error.Message, StringComparison.Ordinal);
+    }
+
+    // ---------------------------------------------------------------------------------
+    // api: por alias
+    // ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void AnUnknownApiValueIsRefusedListingTheValidOnes()
+    {
+        var document = Document("""
+            "inventado": {
+              "provider": "openai", "model": "gpt-5.4", "api": "assistants",
+              "pricing": { "inputPerMTok": 1, "outputPerMTok": 2 }
+            }
+            """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("'assistants'", error.Message, StringComparison.Ordinal);
+        Assert.Contains("responses", error.Message, StringComparison.Ordinal);
+        Assert.Contains("chat", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ApiIsCaseInsensitiveOnTheWayIn()
+    {
+        var document = Document("""
+            "gritado": {
+              "provider": "openai", "model": "gpt-5.4", "api": "CHAT",
+              "pricing": { "inputPerMTok": 1, "outputPerMTok": 2 }
+            }
+            """);
+
+        using var registry = ModelRegistry.FromJson(document, new FakeProviderClientFactory());
+
+        Assert.Equal(AgentApi.Chat, registry.Resolve("gritado").Api);
+    }
+
+    [Fact]
+    public void AV1DocumentIsRefusedWithAVersionMessageInsteadOfAConfusingFieldError()
+    {
+        var document = """
+            {
+              "version": "1.0",
+              "defaultAlias": "text-default",
+              "aliases": { "text-default": { "provider": "openai", "model": "gpt-4o-mini" } }
+            }
+            """;
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("'1.0'", error.Message, StringComparison.Ordinal);
+    }
+
+    // ---------------------------------------------------------------------------------
+    // Resolucao e memoizacao
+    // ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void ResolvingAnUnknownAliasFailsExplicitlyAndListsWhatExists()
+    {
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), new FakeProviderClientFactory());
+
+        var error = Assert.Throws<ModelRegistryException>(() => registry.Resolve("nao-existe"));
+
+        Assert.Equal(ModelRegistryError.UnknownAlias, error.Reason);
+        Assert.Contains("nao-existe", error.Message, StringComparison.Ordinal);
+        Assert.Contains("text-default", error.Message, StringComparison.Ordinal);
+
+        Assert.False(registry.TryResolve("nao-existe", out var silent));
+        Assert.Null(silent);
+    }
+
+    [Fact]
+    public void TheChatClientIsMemoizedPerAliasAndTheFactoryRunsOnce()
+    {
+        var factory = new FakeProviderClientFactory();
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), factory);
+
+        var first = registry.GetChatClient("text-default");
+        var second = registry.GetChatClient("text-default");
+
+        Assert.Same(first, second);
+        Assert.Equal(1, factory.CreateCount);
+
+        var other = registry.GetChatClient("text-heavy");
+
+        Assert.NotSame(first, other);
+        Assert.Equal(2, factory.CreateCount);
+    }
+
+    [Fact]
+    public void AFactoryThatReturnsNullIsRefusedInsteadOfCachingNothing()
+    {
+        var factory = new FakeProviderClientFactory(_ => null);
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), factory);
+
+        var error = Assert.Throws<ModelRegistryException>(() => registry.GetChatClient("text-default"));
+
+        Assert.Contains("devolveu nulo", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TheRegistryOwnsAndDisposesTheClientsItMemoized()
+    {
+        var factory = new FakeProviderClientFactory();
+        var registry = ModelRegistry.FromJson(ExampleDocument(), factory);
+
+        var client = (FakeChatClient)registry.GetChatClient("text-default");
+        Assert.False(client.IsDisposed);
+
+        registry.Dispose();
+
+        Assert.True(client.IsDisposed);
+        Assert.Throws<ObjectDisposedException>(() => registry.GetChatClient("text-default"));
+
+        registry.Dispose(); // idempotente
+    }
+
+    [Fact]
+    public void ADefaultAliasPointingNowhereIsRefused()
+    {
+        var document = Document(
+            """
+            "existe": {
+              "provider": "openai", "model": "gpt-5.4",
+              "pricing": { "inputPerMTok": 1, "outputPerMTok": 2 }
+            }
+            """,
+            extraRoot: ""","defaultAlias": "fantasma" """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("fantasma", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void BrokenJsonFailsNamingTheDocumentInsteadOfLeakingAJsonException()
+    {
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson("{ isto nao e json", new FakeProviderClientFactory()));
+
+        Assert.Contains("JSON invalido", error.Message, StringComparison.Ordinal);
+        Assert.IsAssignableFrom<System.Text.Json.JsonException>(error.InnerException);
+    }
+
+    // ---------------------------------------------------------------------------------
+    // Tarifa: a conta
+    // ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void CostIsTheTariffTimesTheTokensDividedByAMillion()
+    {
+        var pricing = new ModelPricing(InputPerMTok: 1.25m, OutputPerMTok: 10m, CachedInputPerMTok: null);
+
+        // 1.000.000 de entrada = 1.25 USD; 100.000 de saida = 1.00 USD
+        Assert.Equal(2.25m, pricing.ComputeCostUsd(inputTokens: 1_000_000, outputTokens: 100_000));
+        Assert.Equal(0m, pricing.ComputeCostUsd(0, 0));
+    }
+
+    [Fact]
+    public void CachedInputIsChargedApartOnlyWhenItsTariffExists()
+    {
+        var comCache = new ModelPricing(1.25m, 10m, CachedInputPerMTok: 0.125m);
+        var semCache = comCache with { CachedInputPerMTok = null };
+
+        // 1M de entrada, dos quais 800k vieram do cache:
+        //   com tarifa de cache: 200k * 1.25 + 800k * 0.125 = 0.25 + 0.10 = 0.35
+        Assert.Equal(
+            0.35m,
+            comCache.ComputeCostUsd(inputTokens: 1_000_000, outputTokens: 0, cachedInputTokens: 800_000));
+
+        // sem tarifa de cache, a entrada inteira e cobrada como entrada — nunca de graca.
+        Assert.Equal(
+            1.25m,
+            semCache.ComputeCostUsd(inputTokens: 1_000_000, outputTokens: 0, cachedInputTokens: 800_000));
+    }
+
+    [Fact]
+    public void CachedTokensCannotExceedInputTokens()
+    {
+        var pricing = new ModelPricing(1m, 1m, 0.1m);
+
+        Assert.Throws<ArgumentException>(
+            () => pricing.ComputeCostUsd(inputTokens: 10, outputTokens: 0, cachedInputTokens: 11));
+        Assert.Throws<ArgumentOutOfRangeException>(
+            () => pricing.ComputeCostUsd(inputTokens: -1, outputTokens: 0));
+    }
+
+    // ---------------------------------------------------------------------------------
+    // Limites por alias — o limite REAL, nao o folclore
+    // ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void TheChatToolLimitFiresOnlyWithAllFourFactsTogether()
+    {
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), new FakeProviderClientFactory());
+        var alias = registry.Resolve("text-heavy-chat");
+
+        // os quatro fatos juntos: Chat + tools + effort enviado + effort != none
+        var violado = alias.CheckRequest(
+            AgentApi.Chat, hasTools: true, reasoningEffort: ReasoningEffort.High, temperatureIsSet: false);
+
+        Assert.False(violado.IsSatisfied);
+        Assert.Contains("reasoning effort", Assert.Single(violado.Violations), StringComparison.Ordinal);
+
+        // mesmo pedido, na Responses API: sem violacao
+        Assert.True(alias.CheckRequest(
+            AgentApi.Responses, hasTools: true, ReasoningEffort.High, temperatureIsSet: false).IsSatisfied);
+
+        // sem tools: sem violacao
+        Assert.True(alias.CheckRequest(
+            AgentApi.Chat, hasTools: false, ReasoningEffort.High, temperatureIsSet: false).IsSatisfied);
+
+        // effort 'none': e exatamente o que a documentacao permite
+        Assert.True(alias.CheckRequest(
+            AgentApi.Chat, hasTools: true, ReasoningEffort.None, temperatureIsSet: false).IsSatisfied);
+
+        // effort nao enviado: o default do provider vale, e o kit NAO afirma saber qual e
+        Assert.True(alias.CheckRequest(
+            AgentApi.Chat, hasTools: true, reasoningEffort: null, temperatureIsSet: false).IsSatisfied);
+    }
+
+    [Fact]
+    public void AnAliasWithoutConstraintsNeverViolatesAnything()
+    {
+        using var registry = ModelRegistry.FromJson(ExampleDocument(), new FakeProviderClientFactory());
+
+        var check = registry.Resolve("text-default").CheckRequest(
+            AgentApi.Chat, hasTools: true, ReasoningEffort.High, temperatureIsSet: true);
+
+        Assert.True(check.IsSatisfied);
+        Assert.Empty(check.Violations);
+    }
+
+    [Fact]
+    public void TheTemperatureLimitIsPerAliasAndOnlyBitesWhenTemperatureIsSent()
+    {
+        // A afirmacao "temperatura e obsoleta para modelo de raciocinio" NAO foi confirmada
+        // em fonte primaria (issue #93). Por isso ela e uma flag por alias com procedencia
+        // escrita — nunca uma regra universal no codigo. Aqui a procedencia diz, por extenso,
+        // que o exemplo e sintetico.
+        var document = Document("""
+            "sem-temperatura": {
+              "provider": "openai", "model": "modelo-hipotetico",
+              "pricing": { "inputPerMTok": 1, "outputPerMTok": 2 },
+              "constraints": {
+                "temperatureUnsupported": true,
+                "provenance": "EXEMPLO SINTETICO deste teste. Nenhuma fonte primaria foi encontrada para a afirmacao generica sobre temperatura em modelos de raciocinio."
+              }
+            }
+            """);
+
+        using var registry = ModelRegistry.FromJson(document, new FakeProviderClientFactory());
+        var alias = registry.Resolve("sem-temperatura");
+
+        var violado = alias.CheckRequest(
+            AgentApi.Responses, hasTools: false, reasoningEffort: null, temperatureIsSet: true);
+
+        Assert.False(violado.IsSatisfied);
+        Assert.Contains("EXEMPLO SINTETICO", Assert.Single(violado.Violations), StringComparison.Ordinal);
+
+        Assert.True(alias.CheckRequest(
+            AgentApi.Responses, hasTools: false, reasoningEffort: null, temperatureIsSet: false).IsSatisfied);
+    }
+
+    [Fact]
+    public void AConstraintWithoutProvenanceIsRefusedAtLoad()
+    {
+        var document = Document("""
+            "folclore": {
+              "provider": "openai", "model": "gpt-5.4",
+              "pricing": { "inputPerMTok": 1, "outputPerMTok": 2 },
+              "constraints": { "temperatureUnsupported": true }
+            }
+            """);
+
+        var error = Assert.Throws<ModelRegistryException>(
+            () => ModelRegistry.FromJson(document, new FakeProviderClientFactory()));
+
+        Assert.Contains("provenance", error.Message, StringComparison.Ordinal);
+    }
+}

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

@@ -0,0 +1,76 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>Morph.AiKit.Tests</RootNamespace>
+    <AssemblyName>Morph.AiKit.Tests</AssemblyName>
+    <IsTestProject>true</IsTestProject>
+    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
+
+    <!--
+      PISO DE DESCOBERTA. Este kit existe porque "markdown envelhece em silencio;
+      codigo compilado grita" — e um runner que descobre ZERO teste nao grita: ele
+      imprime uma linha curta e some. Foi exatamente o que aconteceu na primeira
+      invocacao real (a flag `nologo`, que so existe no modo VSTest, matou a
+      sessao: "Zero testes executados" com 115 testes passando por baixo).
+
+      A opcao `minimum-expected-tests N` (dois hifens a frente, como toda opcao da
+      plataforma) faz o runner sair com o codigo 9
+      (MinimumExpectedTestsPolicyViolation) sempre que MENOS de N casos rodarem,
+      inclusive quando rodaram zero — esse piso explicito SUPERA o veredito 8
+      (ZeroTests). Medido em 2026‑09‑08 contra o SDK .NET 10:
+        piso 221  → 221 aprovados, exit 0
+        piso 9999 → 115 aprovados, exit 9
+
+      Mora AQUI, e nao no passo do workflow, de proposito: assim o piso viaja com
+      o kit e vale para TODA invocacao de `dotnet test` — CI, maquina do dev e o
+      no `tests` do `morph-spec verify` — em vez de proteger so os dois arquivos
+      de workflow. Uma unica verdade: nenhum chamador repassa a flag na linha de
+      comando, porque repassa-la duplicaria a opcao.
+
+      O numero e o total de CASOS EXECUTADOS (275), nao de atributos nem de casos
+      DESCOBERTOS (276): os [Theory] expandem, e um caso IGNORADO nao conta para o piso — a
+      suite descobre 276 e executa 275, porque o semeador da cache exemplar de eval
+      (KitEvals.SeedTheCommittedCacheTree) so roda sob MORPH_EVAL_SEED=1. Medido: com piso
+      276 a sessao sai 9 mesmo com zero falhas. Adicionou teste? Suba o piso — o canario de
+      test/framework/ai-kit-ci-packaging.test.js cobra isso e falha se o piso
+      ficar para tras da contagem de `[Fact]`/`[Theory]` do diretorio.
+
+      E A SAIDA TAMBEM MUDA, nao so a invocacao. Sob MTP o sumario final e um
+      BLOCO DE 6 LINHAS, o veredito NAO comeca a linha ("Resumo da execucao de
+      teste: Aprovado!" / "Test run summary: Passed!") e a contagem vem em linha
+      propria, indentada, como `total:` MINUSCULO — nada disso e o sumario do
+      VSTest. Medido nos dois locales em 2026-09-08. Um parser do framework
+      escrito para VSTest (que procure uma linha COMECANDO em
+      "Aprovado!"/"Passed!" e contendo "Total de testes:"/"Total:") nao consegue
+      contar os testes deste projeto. O conserto do parser e da feature
+      `verify-por-stack`; aqui isto e registro da fronteira, nao conserto — o
+      piso acima ja garante que uma descoberta parcial saia com codigo 9, que e
+      o eixo que ESTE arquivo controla.
+    -->
+    <TestingPlatformCommandLineArguments>--minimum-expected-tests 275</TestingPlatformCommandLineArguments>
+  </PropertyGroup>
+
+  <!-- Sem atributo Version: as versoes vem de Directory.Packages.props (gerado do pin). -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit.v3" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../src/Morph.AiKit/Morph.AiKit.csproj" />
+  </ItemGroup>
+
+  <!--
+    O exemplar model-registry.v2.json entra no assembly de TESTE por link, e nao no da
+    biblioteca: ele e artefato de template (o projeto que copia o kit o poe em
+    config/model-registry.json), nao payload de runtime. Embutido aqui, o teste carrega o
+    MESMO arquivo que o usuario vai copiar — um exemplar que nao carrega deixa de passar
+    despercebido.
+  -->
+  <ItemGroup>
+    <EmbeddedResource Include="../../src/Morph.AiKit/Providers/model-registry.v2.json"
+                      LogicalName="model-registry.v2.json" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.Versioning;
+using Xunit;
+
+namespace Morph.AiKit.Tests;
+
+/// <summary>
+/// Canario do esqueleto: prova que o harness de teste EXECUTA de verdade e que o
+/// assembly do kit foi compilado no TFM do pin. Nao testa comportamento — os testes
+/// de AgentFactory, ModelRegistry, middlewares, ConversationStore e DeltaIngest sao
+/// das tasks T7-T14.
+///
+/// Por que ele existe em vez de um projeto de teste literalmente vazio: um projeto
+/// sem nenhum teste NAO sai 0. Microsoft.Testing.Platform devolve exit code 8
+/// ("zero tests ran") e o VSTest antigo devolvia 1 com "no test is available".
+/// Um esqueleto que so "compila" e um CI verde que nunca executou nada — e um verde
+/// desses e indistinguivel de um verde real, que e exatamente o silencio que esta
+/// feature existe para quebrar.
+/// </summary>
+public sealed class SkeletonSmokeTests
+{
+    [Fact]
+    public void KitAssemblyIsLoadableAndTargetsThePinnedFramework()
+    {
+        var kit = typeof(AiKitAssemblyMarker).Assembly;
+
+        Assert.Equal("Morph.AiKit", kit.GetName().Name);
+
+        var tfm = kit.GetCustomAttribute<TargetFrameworkAttribute>();
+        Assert.NotNull(tfm);
+        Assert.Equal(".NETCoreApp,Version=v10.0", tfm.FrameworkName);
+    }
+}