@polymorphism-tech/morph-spec 8.38.0 → 8.40.0

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

@@ -6,14 +6,8 @@ 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
@@ -33,10 +27,6 @@ public sealed class ModelRegistryTests
         }
         """;
 
-    // ---------------------------------------------------------------------------------
-    // O exemplar publicado carrega — e expoe api e pricing por alias
-    // ---------------------------------------------------------------------------------
-
     [Fact]
     public void ThePublishedExampleLoadsAndExposesApiAndPricingPerAlias()
     {
@@ -48,11 +38,9 @@ public sealed class ModelRegistryTests
 
         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);
@@ -62,7 +50,6 @@ public sealed class ModelRegistryTests
         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);
@@ -80,10 +67,6 @@ public sealed class ModelRegistryTests
         Assert.Contains("reasoning_effort", constraints.Provenance!, StringComparison.Ordinal);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Tarifa ausente e ALTO, nunca nulo silencioso
-    // ---------------------------------------------------------------------------------
-
     [Fact]
     public void AnAliasWithNeitherPricingNorWaiverIsRefusedAtLoadNamingTheAlias()
     {
@@ -151,7 +134,7 @@ public sealed class ModelRegistryTests
     [Fact]
     public void ATypoInAFieldNameIsRefusedInsteadOfSilentlyIgnored()
     {
-        // "priceing" seria lido como "sem pricing" — e a ausencia silenciosa e o defeito.
+        // "priceing" e erro de grafia proposital: nao pode ser lido como "sem pricing".
         var document = Document("""
             "digitado-errado": {
               "provider": "openai", "model": "gpt-5.4",
@@ -165,10 +148,6 @@ public sealed class ModelRegistryTests
         Assert.Contains("priceing", error.Message, StringComparison.Ordinal);
     }
 
-    // ---------------------------------------------------------------------------------
-    // api: por alias
-    // ---------------------------------------------------------------------------------
-
     [Fact]
     public void AnUnknownApiValueIsRefusedListingTheValidOnes()
     {
@@ -219,10 +198,6 @@ public sealed class ModelRegistryTests
         Assert.Contains("'1.0'", error.Message, StringComparison.Ordinal);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Resolucao e memoizacao
-    // ---------------------------------------------------------------------------------
-
     [Fact]
     public void ResolvingAnUnknownAliasFailsExplicitlyAndListsWhatExists()
     {
@@ -281,7 +256,7 @@ public sealed class ModelRegistryTests
         Assert.True(client.IsDisposed);
         Assert.Throws<ObjectDisposedException>(() => registry.GetChatClient("text-default"));
 
-        registry.Dispose(); // idempotente
+        registry.Dispose();
     }
 
     [Fact]
@@ -312,16 +287,12 @@ public sealed class ModelRegistryTests
         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
+        // 1M de entrada * 1.25 + 100k de saida * 10.0 = 1.25 + 1.00 USD.
         Assert.Equal(2.25m, pricing.ComputeCostUsd(inputTokens: 1_000_000, outputTokens: 100_000));
         Assert.Equal(0m, pricing.ComputeCostUsd(0, 0));
     }
@@ -332,13 +303,12 @@ public sealed class ModelRegistryTests
         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
+        // 800k dos 1M vieram do 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.
+        // Sem tarifa de cache, a entrada inteira e cobrada cheia.
         Assert.Equal(
             1.25m,
             semCache.ComputeCostUsd(inputTokens: 1_000_000, outputTokens: 0, cachedInputTokens: 800_000));
@@ -355,36 +325,28 @@ public sealed class ModelRegistryTests
             () => 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
+        // 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);
     }
@@ -404,10 +366,6 @@ public sealed class ModelRegistryTests
     [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",

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

@@ -4,19 +4,7 @@ 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>
+// Um projeto sem teste nenhum nao sai 0 (o Microsoft.Testing.Platform sai 8): este caso prova que o harness executa.
 public sealed class SkeletonSmokeTests
 {
     [Fact]

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

@@ -9,14 +9,7 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios da telemetria (T12). O arquivo inteiro mede <b>spans</b>, com
-/// <see cref="ActivityListener"/> — nao propriedades de configuracao. Um guard contra span
-/// duplicado so pode ser provado contando spans.
-/// </summary>
-/// <remarks>
-/// Cada caso usa um <c>SourceName</c> unico, para que um teste nunca conte o span do outro.
-/// </remarks>
+// Cada caso usa um SourceName proprio, para nunca contar o span de outro teste.
 public sealed class TelemetryTests
 {
     private const string Document = """
@@ -42,15 +35,6 @@ public sealed class TelemetryTests
             Options = options ?? new AgentSpecOptions(),
         };
 
-    // ---------------------------------------------------------------------------------
-    // O caso normal: um span de agente, um span de chat
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// A forma que as GenAI conventions descrevem: <c>invoke_agent</c> como raiz e
-    /// <c>chat</c> como filho. Este teste tambem e a prova de que a escolha da T10 de montar
-    /// o proprio pipeline nao custou o span de chat — ele so existe porque a T12 o coloca.
-    /// </summary>
     [Fact]
     public async Task AnInstrumentedAgentEmitsOneInvokeAgentSpanAndOneChatSpan()
     {
@@ -66,14 +50,6 @@ public sealed class TelemetryTests
         Assert.NotNull(Single(spans, "chat").Parent);
     }
 
-    // ---------------------------------------------------------------------------------
-    // O guard — as duas metades da mesma afirmacao
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// <b>O guard, no default.</b> Um pipeline que ja carrega instrumentacao (o caso real:
-    /// um <c>IChatClient</c> que veio do DI ja instrumentado) continua com UM span de chat.
-    /// </summary>
     [Fact]
     public async Task TheDefaultDoesNotAddASecondChatSpanOverAnAlreadyInstrumentedPipeline()
     {
@@ -87,11 +63,6 @@ public sealed class TelemetryTests
         Assert.Equal(1, CountOf(spans, "chat"));
     }
 
-    /// <summary>
-    /// <b>O guard, desligado.</b> Forcar <c>InstrumentChatClient = true</c> sobre o MESMO
-    /// pipeline ja instrumentado produz o par duplicado. E o canario que documenta o risco:
-    /// sem o ramo automatico, este e o resultado.
-    /// </summary>
     [Fact]
     public async Task ForcingInstrumentChatClientProducesTheDuplicateChatSpan()
     {
@@ -105,10 +76,6 @@ public sealed class TelemetryTests
         Assert.Equal(2, CountOf(spans, "chat"));
     }
 
-    /// <summary>
-    /// O mesmo guard no nivel do agente: aplicar a telemetria duas vezes no
-    /// <see cref="AIAgentBuilder"/> nao produz dois <c>invoke_agent</c>.
-    /// </summary>
     [Fact]
     public async Task TheAgentGuardKeepsASingleInvokeAgentSpanWhenTelemetryIsAppliedTwice()
     {
@@ -124,12 +91,6 @@ public sealed class TelemetryTests
         Assert.Equal(1, CountOf(spans, "invoke_agent"));
     }
 
-    /// <summary>
-    /// <c>false</c> nao e o mesmo que o default. Com a <c>AgentFactory</c> — que monta o
-    /// proprio pipeline — desligar a instrumentacao de chat deixa a invocacao com o span do
-    /// agente e <b>nenhum</b> span de chat. O teste existe para que essa consequencia seja
-    /// um fato escrito, e nao uma surpresa em producao.
-    /// </summary>
     [Fact]
     public async Task TurningTheChatInstrumentationOffLeavesTheAgentSpanAndNoChatSpan()
     {
@@ -143,14 +104,6 @@ public sealed class TelemetryTests
         Assert.Equal(0, CountOf(spans, "chat"));
     }
 
-    // ---------------------------------------------------------------------------------
-    // Dado sensivel
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Conteudo sensivel nasce desligado nos dois niveis — o standard exige <c>false</c>
-    /// fora de dev/staging, porque prompt e resposta sao PII do cliente.
-    /// </summary>
     [Fact]
     public void SensitiveDataIsOffByDefaultAtBothLevels()
     {
@@ -163,11 +116,6 @@ public sealed class TelemetryTests
             agent.GetService(typeof(OpenTelemetryChatClient))).EnableSensitiveData);
     }
 
-    /// <summary>
-    /// A spec pode ligar o dado sensivel para UM agente sem mexer na configuracao global —
-    /// e o destino que a T7 declarou para <c>EnableSensitiveTelemetry</c>. Nulo na spec
-    /// ("nao opinei") preserva o valor global; preenchido, vence.
-    /// </summary>
     [Fact]
     public void TheSpecCanOverrideSensitiveDataForASingleAgent()
     {
@@ -183,25 +131,12 @@ public sealed class TelemetryTests
             loud.GetService(typeof(OpenTelemetryChatClient))).EnableSensitiveData);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Configuracao invalida
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Source em branco e recusado na construcao: um <c>ActivitySource</c> sem nome nao pode
-    /// ser registrado em <c>AddSource(...)</c>, e a telemetria sumiria em silencio.
-    /// </summary>
     [Fact]
     public void ABlankSourceNameIsRefusedAtConstruction()
         => Assert.Throws<ArgumentException>(() => new MorphTelemetryOptions { SourceName = "   " });
 
-    // ---------------------------------------------------------------------------------
-    // Apoio dos testes
-    // ---------------------------------------------------------------------------------
-
     private static string NewSourceName() => "morph.aikit.test." + Guid.CreateVersion7().ToString("N");
 
-    /// <summary>Um pipeline que ja chega instrumentado — o caso real do cliente vindo do DI.</summary>
     private static IChatClient AlreadyInstrumented(string sourceName)
         => new FakeChatClient()
             .EnqueueText("pronto")
@@ -219,11 +154,7 @@ public sealed class TelemetryTests
         return factory.Create(spec ?? Spec());
     }
 
-    /// <summary>
-    /// Coleta os spans de UMA invocacao. O listener e registrado antes de o agente existir e
-    /// removido no fim — telemetria e estado global do processo, e um listener vazado
-    /// contaminaria os outros casos.
-    /// </summary>
+    // Telemetria e estado global do processo: o listener entra antes do agente e sai no fim.
     private static async Task<IReadOnlyList<Activity>> CollectAsync(string sourceName, Func<AIAgent> build)
     {
         var spans = new List<Activity>();

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

@@ -7,16 +7,10 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios do <see cref="UsageCostMiddleware"/> (T11). A afirmacao central da task e uma
-/// so: <b><c>cost_usd</c> nao sai nulo, e o zero nunca e ambiguo</b> — ou e medicao, ou e
-/// dispensa escrita, ou e lacuna declarada.
-/// </summary>
 public sealed class UsageCostMiddlewareTests
 {
     private static readonly DateTimeOffset FixedNow = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);
 
-    /// <summary>Tarifa ilustrativa com desconto de cache — a que exercita a aritmetica inteira.</summary>
     private static ModelPricing Tariff()
         => new(InputPerMTok: 1.25m, OutputPerMTok: 10.0m, CachedInputPerMTok: 0.125m);
 
@@ -42,22 +36,11 @@ public sealed class UsageCostMiddlewareTests
 
         var sink = new FakeUsageCostSink();
 
-        // A extensao publica e o caminho de registro: se ela quebrar, o teste quebra junto.
         var client = inner.AsBuilder().UseUsageCost(alias, sink, new FakeClock(FixedNow)).Build();
 
         return (client, inner, sink);
     }
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria 1: Usage conhecido + ModelPricing conhecido => CostUsd EXATO
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// O valor esperado esta escrito a mao, com a semantica correta de token cacheado:
-    /// <b>cacheado e SUBCONJUNTO da entrada</b>. 1000 de entrada com 400 servidos do cache
-    /// custam 600 na tarifa cheia mais 400 na de cache — nunca 1000 mais 400. E por isso que
-    /// este caso, e nao um sem cache, e o que denuncia uma segunda aritmetica.
-    /// </summary>
     [Fact]
     public async Task AKnownUsageAgainstAKnownTariffProducesTheExactCostInUsd()
     {
@@ -83,13 +66,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(FixedNow, record.At);
     }
 
-    /// <summary>
-    /// O canario que torna "nao existe uma segunda conta do custo" verificavel em vez de
-    /// prometido: o custo publicado tem de ser <b>identico</b> ao de
-    /// <see cref="ModelPricing.ComputeCostUsd"/> — inclusive nos casos que separam as duas
-    /// formulas plausiveis (cacheado sem tarifa de cache, cacheado igual a entrada, saida
-    /// zerada).
-    /// </summary>
     [Theory]
     [InlineData(1000, 200, 400L)]
     [InlineData(1000, 200, null)]
@@ -111,11 +87,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(pricing.ComputeCostUsd(input, output, cached), sink.Records[0].CostUsd);
     }
 
-    /// <summary>
-    /// Tarifa sem desconto de cache declarado: nulo em <c>CachedInputPerMTok</c> significa
-    /// "sem desconto", <b>nunca</b> "de graca" — a entrada inteira e cobrada cheia mesmo com
-    /// tokens vindos do cache.
-    /// </summary>
     [Fact]
     public async Task WithoutADeclaredCacheTariffTheWholeInputIsChargedAsInput()
     {
@@ -127,19 +98,10 @@ public sealed class UsageCostMiddlewareTests
             [new ChatMessage(ChatRole.User, "oi")],
             cancellationToken: TestContext.Current.CancellationToken);
 
-        // (1000 * 1.25) + (200 * 10.0) = 3250 por 1M tokens. O cacheado nao rende desconto.
+        // (1000 * 1.25) + (200 * 10.0) = 3250 por 1M tokens: o cacheado nao rende desconto.
         Assert.Equal(0.00325m, sink.Records[0].CostUsd);
     }
 
-    // ---------------------------------------------------------------------------------
-    // doneCriteria 2: alias sem Pricing => CostUsd == 0, ausencia sinalizada, SEM excecao
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Alias sem tarifa e caminho previsto, nao erro. E o zero nao e anonimo: o motivo
-    /// escrito no <c>pricingWaiver</c> do registry viaja no record. Nao ha excecao — e nao
-    /// ha nulo em <c>CostUsd</c>.
-    /// </summary>
     [Fact]
     public async Task AnAliasWithoutATariffRecordsTokensWithZeroCostAndSaysWhy()
     {
@@ -156,19 +118,14 @@ public sealed class UsageCostMiddlewareTests
 
         var record = Assert.Single(sink.Records);
 
-        Assert.Equal(0m, record.CostUsd);                       // zero, jamais nulo
+        Assert.Equal(0m, record.CostUsd);
         Assert.Equal(UsageCostStatus.Waived, record.Status);
-        Assert.False(record.IsMeasuredCost);                    // logo, nao entra na soma
+        Assert.False(record.IsMeasuredCost);
         Assert.Equal(alias.PricingWaiver, record.PricingWaiver);
-        Assert.Equal(900, record.InputTokens);                  // os tokens continuam medidos
+        Assert.Equal(900, record.InputTokens);
         Assert.Equal(100, record.OutputTokens);
     }
 
-    /// <summary>
-    /// A regra que sustenta a anterior mora no registry (T8): um alias sem tarifa <b>e</b>
-    /// sem dispensa nao carrega. Por isso um record <c>Waived</c> sempre tem motivo — a
-    /// ausencia por esquecimento morre antes de chegar ao middleware.
-    /// </summary>
     [Fact]
     public void AWaivedRecordAlwaysHasAReasonBecauseTheRegistryRefusesAnAliasWithNeither()
     {
@@ -180,13 +137,9 @@ public sealed class UsageCostMiddlewareTests
         var refusal = Assert.Throws<ModelRegistryException>(() => ModelAlias.ValidatePricingDecision(orphan));
         Assert.Contains("sem-decisao", refusal.Message, StringComparison.Ordinal);
 
-        ModelAlias.ValidatePricingDecision(WaivedAlias());   // com dispensa escrita, passa
+        ModelAlias.ValidatePricingDecision(WaivedAlias());
     }
 
-    /// <summary>
-    /// A soma so junta o que foi medido. Uma volta tarifada mais uma dispensada somam o
-    /// custo da primeira — o zero da dispensa nao "abaixa a media" nem some do relatorio.
-    /// </summary>
     [Fact]
     public async Task OnlyMeasuredCostsEnterTheSum()
     {
@@ -210,15 +163,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(0.0028m, sink.MeasuredTotalUsd);
     }
 
-    // ---------------------------------------------------------------------------------
-    // O terceiro zero: o provider nao reportou uso
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Resposta sem <c>Usage</c>: a linha sai marcada como lacuna. Nao publicar nada faria o
-    /// custo desaparecer do relatorio, que e a mesma dor por outro angulo; publicar como
-    /// <c>Computed</c> mentiria que a volta custou zero.
-    /// </summary>
     [Fact]
     public async Task AResponseWithoutUsageIsRecordedAsAGapNotAsFree()
     {
@@ -236,11 +180,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(0m, sink.MeasuredTotalUsd);
     }
 
-    /// <summary>
-    /// <c>cached &gt; input</c> e o provider se contradizendo. A conta do T8 recusa esse par
-    /// com excecao — e recusar aqui derrubaria a resposta do usuario por causa de um
-    /// contador. O middleware degrada para lacuna declarada, sem lancar.
-    /// </summary>
     [Fact]
     public async Task InconsistentTokenCountsBecomeADeclaredGapInsteadOfAThrownRequest()
     {
@@ -259,26 +198,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(UsageCostStatus.UsageMissing, Assert.Single(sink.Records).Status);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Uma linha por volta ao modelo — inclusive no streaming
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// Duas <b>chamadas</b> a <c>GetResponseAsync</c> publicam <b>duas</b> linhas: uma por
-    /// ida ao modelo, cada uma com o seu proprio numero.
-    /// </summary>
-    /// <remarks>
-    /// O que este teste prova, e so isto: <b>uma linha por chamada</b>, sem acumulo de
-    /// estado entre chamadas. Ele NAO prova nada sobre a posicao do middleware no pipeline
-    /// — sao duas chamadas separadas, nao uma chamada com volta de tool, e aqui o
-    /// middleware e montado sozinho, sem <c>FunctionInvokingChatClient</c> nenhum. A
-    /// posicao real e o oposto do que uma leitura apressada deste teste sugeriria: o
-    /// middleware fica <b>ACIMA</b> da invocacao de funcoes, e quem prova isso e
-    /// <c>AgentFactoryTests.ThePipelineOrderIsUsageCostAboveFunctionInvocationAndTelemetryBelowIt</c>
-    /// (com <c>...SeesTheUsageOfEveryToolRoundSummedOnce</c> mostrando o uso ja somado das
-    /// duas voltas). Acima do FICC, uma conversa com tool call e <b>uma</b> chamada com o
-    /// uso ja totalizado — nao duas.
-    /// </remarks>
     [Fact]
     public async Task EveryTripToTheModelPublishesItsOwnLine()
     {
@@ -301,10 +220,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(0.0035m, sink.Records[1].CostUsd);   // (2000*1.25 + 100*10) / 1M
     }
 
-    /// <summary>
-    /// No streaming o uso chega como <c>UsageContent</c> avulso. A linha sai <b>uma</b> vez,
-    /// ao fim da enumeracao, com o mesmo numero do caminho nao-streaming.
-    /// </summary>
     [Fact]
     public async Task StreamingPublishesOneLineAtTheEndWithTheSameNumber()
     {
@@ -325,11 +240,6 @@ public sealed class UsageCostMiddlewareTests
         Assert.Equal(0.0028m, Assert.Single(sink.Records).CostUsd);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Higiene de construcao
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>Alias ou sink nulos sao defeito de composicao e falham na construcao.</summary>
     [Fact]
     public void TheMiddlewareRefusesToBeBuiltWithoutAnAliasOrASink()
     {
@@ -342,11 +252,6 @@ public sealed class UsageCostMiddlewareTests
             () => new UsageCostMiddleware(inner, PricedAlias(), null!));
     }
 
-    /// <summary>
-    /// O instante do record vem do <see cref="TimeProvider"/> injetado, nao do relogio do
-    /// processo — sem isso o campo <c>At</c> seria intestavel (standard
-    /// <c>backend-dotnet-testing</c>).
-    /// </summary>
     [Fact]
     public async Task TheTimestampComesFromTheInjectedClock()
     {

package/framework/templates/frontend/nextjs/Dockerfile.nextjs.hbs

@@ -1,43 +1,39 @@
-# Multi-stage Next.js production build for Coolify
-# Stage 1: Dependencies
-FROM node:20-alpine AS deps
-RUN apk add --no-cache libc6-compat
-WORKDIR /app
-
-COPY package.json package-lock.json* ./
-RUN npm ci --only=production && npm cache clean --force
-
-# Stage 2: Build
-FROM node:20-alpine AS builder
-WORKDIR /app
-
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-
-# Build args for NEXT_PUBLIC_ variables (must be available at build time)
-ARG NEXT_PUBLIC_APP_URL
-ENV NEXT_PUBLIC_APP_URL=$NEXT_PUBLIC_APP_URL
-
-RUN npm run build
-
-# Stage 3: Production runner
-FROM node:20-alpine AS runner
-WORKDIR /app
-
-ENV NODE_ENV=production
-ENV NEXT_TELEMETRY_DISABLED=1
-
-RUN addgroup --system --gid 1001 nodejs
-RUN adduser --system --uid 1001 nextjs
-
-COPY --from=builder /app/public ./public
-COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
-COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
-
-USER nextjs
-
-EXPOSE 3000
-ENV PORT=3000
-ENV HOSTNAME="0.0.0.0"
-
-CMD ["node", "server.js"]
+FROM node:20-alpine AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+
+COPY package.json package-lock.json* ./
+RUN npm ci --only=production && npm cache clean --force
+
+FROM node:20-alpine AS builder
+WORKDIR /app
+
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# NEXT_PUBLIC_ vars are inlined by next build, so they must exist at build time
+ARG NEXT_PUBLIC_APP_URL
+ENV NEXT_PUBLIC_APP_URL=$NEXT_PUBLIC_APP_URL
+
+RUN npm run build
+
+FROM node:20-alpine AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+USER nextjs
+
+EXPOSE 3000
+ENV PORT=3000
+ENV HOSTNAME="0.0.0.0"
+
+CMD ["node", "server.js"]