@polymorphism-tech/morph-spec 8.37.1 → 8.40.0

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

@@ -5,21 +5,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// A companheira obrigatoria de <c>AgentApi.Images</c>/<c>AgentApi.Videos</c> existirem:
-/// <b>um alias de midia nao vira agente</b>.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Um registry so e um vocabulario so de alias e a decisao (<c>decisions.md</c> D3) — e
-/// justamente por isso a recusa precisa existir. Sem ela, um alias de imagem passado por
-/// engano viraria um agente de chat apontando para um modelo que nao fala chat: a falha
-/// apareceria no primeiro turno, com uma mensagem do provider que nao diz o que aconteceu.
-/// </para>
-/// <para>
-/// Enum novo sem recusa e uma armadilha nova. Este arquivo e o que impede que ela volte.
-/// </para>
-/// </remarks>
 public sealed class MediaAliasIsNotAnAgentTests
 {
     private const string MediaAliasDocument = """
@@ -52,7 +37,6 @@ public sealed class MediaAliasIsNotAnAgentTests
     private static AgentSpec Spec(string alias, AgentApi? api = null)
         => new() { Alias = alias, Instructions = "voce e um agente de teste", Api = api };
 
-    /// <summary>O registry ACEITA <c>images</c> e <c>videos</c> — um vocabulario so de alias.</summary>
     [Theory]
     [InlineData("imagem", AgentApi.Images)]
     [InlineData("video", AgentApi.Videos)]
@@ -63,7 +47,6 @@ public sealed class MediaAliasIsNotAnAgentTests
         Assert.Equal(expected, registry.Resolve(alias).Api);
     }
 
-    /// <summary>E a fabrica RECUSA, na construcao, com erro nomeado.</summary>
     [Theory]
     [InlineData("imagem")]
     [InlineData("video")]
@@ -78,10 +61,6 @@ public sealed class MediaAliasIsNotAnAgentTests
         Assert.Contains("EnqueueAsync", ex.Message, StringComparison.Ordinal);
     }
 
-    /// <summary>
-    /// A recusa tambem cobre o caminho pela SPEC: um alias de conversa com
-    /// <c>Api = Images</c> na spec e a mesma confusao, pela outra porta.
-    /// </summary>
     [Fact]
     public void TheFactoryRefusesAMediaProtocolDeclaredOnTheSpec()
     {
@@ -93,7 +72,6 @@ public sealed class MediaAliasIsNotAnAgentTests
         Assert.Equal(AgentFactoryError.MediaAliasIsNotAnAgent, ex.Reason);
     }
 
-    /// <summary>Alias de conversa continua passando — a recusa nova nao pode ser um bloqueio geral.</summary>
     [Fact]
     public void AChatAliasStillBuildsAnAgent()
     {
@@ -103,7 +81,6 @@ public sealed class MediaAliasIsNotAnAgentTests
         Assert.NotNull(factory.Create(Spec("texto")));
     }
 
-    /// <summary>O predicado mora num lugar so — duas copias e como as duas discordam.</summary>
     [Theory]
     [InlineData(AgentApi.Responses, false)]
     [InlineData(AgentApi.Chat, false)]
@@ -112,7 +89,6 @@ public sealed class MediaAliasIsNotAnAgentTests
     public void IsMediaAnswersForEveryProtocol(AgentApi api, bool expected)
         => Assert.Equal(expected, api.IsMedia());
 
-    /// <summary>Um <c>api</c> inventado continua sendo recusado na carga do documento.</summary>
     [Fact]
     public void AnUnknownApiIsStillRefusedWithTheFullListOfValidValues()
     {

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

@@ -4,37 +4,12 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canários da MARCAÇÃO — a quarta afirmação da rubrica `media-claims`, e a última que este
-/// kit ainda prendia só por prosa.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>A assimetria que estes testes fecham, medida:</b> a regra do turno de conversa estava
-/// presa por TIPO (`internal` + id de job em vez de bytes) e provada por mutação; custo e
-/// revisão humana, por ESTADO. A marcação — que é a obrigação legal, o art. 50 do AI Act que
-/// motivou a issue — estava escrita em `MediaJobState.cs` ("publicado, com a marcacao
-/// aplicada") e em `MediaRequest.cs` ("marcacao visivel obrigatoria"), e um `grep` por label,
-/// watermark ou disclosure no kit inteiro voltava <b>vazio</b>. Zero mecanismo.
-/// </para>
-/// <para>
-/// Uma rubrica que cobra de terceiros uma prova que o próprio exemplar não dá é o defeito que
-/// esta epic catalogou. Estes testes são o inverso literal dele.
-/// </para>
-/// <para>
-/// <b>Fronteira honesta:</b> nada aqui prova que o rótulo chegou aos olhos de alguém — a
-/// renderização é do aplicativo consumidor, e nenhum tipo em C# alcança um pixel. O que se
-/// prova é que a publicação <b>não acontece</b> sem a decisão registrada, com texto e
-/// superfície nomeados.
-/// </para>
-/// </remarks>
 public sealed class MediaDisclosureTests
 {
     private static readonly DateTimeOffset T0 = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);
 
     private static MediaDisclosure Label => MediaDisclosure.Create("Imagem gerada por IA", "legenda", T0);
 
-    /// <summary>Um job aprovado, na finalidade pedida.</summary>
     private static MediaJob Approved(MediaPurpose purpose)
     {
         var job = MediaJob.Create(
@@ -50,11 +25,6 @@ public sealed class MediaDisclosureTests
         return job.Approve(MediaReview.ApprovedBy("lucas", T0)).Value;
     }
 
-    // ---------------------------------------------------------------------------------
-    // A política, por finalidade — dado, não comentário
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>Catálogo e marketing exigem marcação; rascunho não chega a publicar.</summary>
     [Theory]
     [InlineData(MediaPurpose.CatalogPhoto, true)]
     [InlineData(MediaPurpose.Marketing, true)]
@@ -62,7 +32,6 @@ public sealed class MediaDisclosureTests
     public void RequiresDisclosureIsDeclaredPerPurpose(MediaPurpose purpose, bool expected)
         => Assert.Equal(expected, purpose.RequiresDisclosure());
 
-    /// <summary>Rascunho é a única finalidade não publicável.</summary>
     [Theory]
     [InlineData(MediaPurpose.CatalogPhoto, true)]
     [InlineData(MediaPurpose.Marketing, true)]
@@ -70,14 +39,6 @@ public sealed class MediaDisclosureTests
     public void OnlyDraftIsUnpublishable(MediaPurpose purpose, bool expected)
         => Assert.Equal(expected, purpose.IsPublishable());
 
-    // ---------------------------------------------------------------------------------
-    // A porta: publicar sem marcação NÃO é um caminho
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// O caso central. Um job aprovado, de catálogo, sem marcação: <b>não publica</b>, e a
-    /// razão nomeia o que falta.
-    /// </summary>
     [Theory]
     [InlineData(MediaPurpose.CatalogPhoto)]
     [InlineData(MediaPurpose.Marketing)]
@@ -93,7 +54,6 @@ public sealed class MediaDisclosureTests
         Assert.Contains("marcacao", result.Error.Message, StringComparison.OrdinalIgnoreCase);
     }
 
-    /// <summary>Com a marcação, publica — e ela fica GRAVADA no job, não descartada.</summary>
     [Fact]
     public void PublishSucceedsWithADisclosureAndRecordsIt()
     {
@@ -106,10 +66,6 @@ public sealed class MediaDisclosureTests
         Assert.Equal(T0, published.Value.Disclosure.AppliedAt);
     }
 
-    /// <summary>
-    /// Rascunho não publica, <b>nem com marcação e nem estando aprovado</b>. Era uma frase
-    /// num comentário XML; agora é uma recusa.
-    /// </summary>
     [Fact]
     public void ADraftNeverPublishesEvenApprovedAndLabelled()
     {
@@ -119,11 +75,6 @@ public sealed class MediaDisclosureTests
         Assert.Contains("nao publica", result.Error!.Message, StringComparison.OrdinalIgnoreCase);
     }
 
-    /// <summary>
-    /// A ordem das portas importa: o estado vem antes da marcação. Um job NÃO aprovado, sem
-    /// marcação, tem de reclamar da revisão humana — mandar consertar a marcação de algo que
-    /// nem foi revisado manda consertar a coisa errada.
-    /// </summary>
     [Fact]
     public void TheStateGateIsReportedBeforeTheDisclosureGate()
     {
@@ -142,29 +93,6 @@ public sealed class MediaDisclosureTests
         Assert.DoesNotContain("marcacao", result.Error.Message, StringComparison.OrdinalIgnoreCase);
     }
 
-    // ---------------------------------------------------------------------------------
-    // A marcação vazia é o campo preenchido "para passar"
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// <b>A construção não tem outra porta.</b> Este é o teste que o nome do anterior prometia
-    /// e não entregava.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// A primeira versão de <see cref="MediaDisclosure"/> era um record POSICIONAL, e record
-    /// posicional gera construtor <b>público</b>. A validação vivia só em
-    /// <see cref="MediaDisclosure.Create"/>, então um consumidor externo fazia
-    /// <c>new MediaDisclosure("", "", at)</c> e publicava com rótulo vazio — medido:
-    /// <c>IsSuccess=True State=Published</c>. O canário de então exercitava a FÁBRICA e passava
-    /// verde o tempo todo: media a copia, nao o objeto.
-    /// </para>
-    /// <para>
-    /// Por isso a asserção é por REFLEXÃO sobre o tipo. Ela não pode ser escrita como
-    /// <c>new MediaDisclosure(...)</c> — hoje isso nem compila, e é esse o ponto: uma asserção
-    /// que só existe enquanto o defeito existe não é canário.
-    /// </para>
-    /// </remarks>
     [Fact]
     public void TheTypeExposesNoPublicConstructor()
     {
@@ -179,7 +107,6 @@ public sealed class MediaDisclosureTests
             "MediaReview. Encontrados: " + string.Join(" | ", publicCtors.Select(c => c.ToString())));
     }
 
-    /// <summary>Texto ou superfície em branco é recusado pela única porta que existe.</summary>
     [Theory]
     [InlineData("", "legenda")]
     [InlineData("   ", "legenda")]
@@ -188,10 +115,6 @@ public sealed class MediaDisclosureTests
     public void ABlankDisclosureIsRefusedByTheOnlyFactory(string text, string surface)
         => Assert.Throws<ArgumentException>(() => MediaDisclosure.Create(text, surface, T0));
 
-    /// <summary>
-    /// A superfície é obrigatória junto do texto: "marcado" sem dizer ONDE não responde se
-    /// alguém consegue ver.
-    /// </summary>
     [Fact]
     public void TheDisclosureCarriesBothTheTextAndWhereItAppears()
     {
@@ -201,7 +124,6 @@ public sealed class MediaDisclosureTests
         Assert.Equal("sobreposicao", disclosure.Surface);
     }
 
-    /// <summary>Uma publicação recusada não muda o job — o registro continua imutável.</summary>
     [Fact]
     public void ARefusedPublishLeavesTheJobUntouched()
     {

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

@@ -5,15 +5,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios do enqueue e do worker. <b>Nenhum deles toca API paga</b> — o unico ponto que
-/// gastaria dinheiro e o <see cref="FakeMediaProvider"/>, e a suite conta as chamadas dele.
-/// </summary>
-/// <remarks>
-/// As afirmacoes aqui sao as tres que o dinheiro cobra: um retry nao paga de novo, um
-/// estouro de teto recusa <b>antes</b> da chamada, e um bloqueio de moderacao vai para
-/// <c>RejectedByPolicy</c> em vez de virar retry.
-/// </remarks>
 public sealed class MediaGeneratorTests
 {
     private static readonly DateTimeOffset T0 = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);
@@ -42,11 +33,6 @@ public sealed class MediaGeneratorTests
             jobs, store, provider);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Enqueue: id de job, nunca bytes
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>Um pedido valido vira job em <c>Pending</c>, e o retorno e um id.</summary>
     [Fact]
     public async Task EnqueueReturnsAJobIdAndTheJobStartsPending()
     {
@@ -58,11 +44,9 @@ public sealed class MediaGeneratorTests
         var job = await generator.GetAsync(enqueued.Value, Ct);
         Assert.Equal(MediaJobState.Pending, job.Value.State);
 
-        // Nada foi gasto: o enqueue NAO chama provider.
         Assert.Equal(0, provider.Calls);
     }
 
-    /// <summary>Pedido sem prompt e recusa nomeada, nao excecao.</summary>
     [Fact]
     public async Task AnInvalidRequestIsRefusedByName()
     {
@@ -75,7 +59,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal(MediaErrorCode.InvalidRequest, result.Error!.Code);
     }
 
-    /// <summary>Alias desconhecido: recusa, e nenhum job criado.</summary>
     [Fact]
     public async Task AnUnknownAliasIsRefused()
     {
@@ -88,14 +71,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal(0, jobs.Saves);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Idempotencia: o retry nao paga de novo
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// O MESMO pedido, enfileirado duas vezes, devolve o MESMO job. E o que faz um retry de
-    /// fila, de worker reiniciado ou de webhook duplicado custar zero.
-    /// </summary>
     [Fact]
     public async Task TheSameRequestEnqueuedTwiceReusesTheSameJob()
     {
@@ -108,7 +83,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal(1, jobs.Saves);
     }
 
-    /// <summary>Pedido diferente, job diferente — a dedupe nao pode engolir trabalho novo.</summary>
     [Fact]
     public async Task ADifferentRequestGetsItsOwnJob()
     {
@@ -121,14 +95,6 @@ public sealed class MediaGeneratorTests
         Assert.NotEqual(first.Value, second.Value);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Teto de custo: recusa ANTES da chamada
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// O teto e confrontado com o custo estimado, e a recusa acontece no enqueue — antes de
-    /// existir qualquer chamada. Depois dela, o dinheiro ja saiu.
-    /// </summary>
     [Fact]
     public async Task ABudgetOverrunIsRefusedAtEnqueueBeforeAnyCall()
     {
@@ -145,7 +111,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal([0.211m], budget.Seen);
     }
 
-    /// <summary>O custo estimado que chega ao teto e o da tarifa, na quantidade pedida.</summary>
     [Fact]
     public async Task TheEstimateSentToTheBudgetIsTariffTimesCount()
     {
@@ -157,11 +122,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal([0.024m], budget.Seen);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Worker: estados, storage e a distincao que vale dinheiro
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>Caminho feliz: os bytes vao para o storage ANTES de o job virar Generated.</summary>
     [Fact]
     public async Task TheWorkerStoresTheBytesAndThenMarksGenerated()
     {
@@ -178,7 +138,6 @@ public sealed class MediaGeneratorTests
         Assert.EndsWith(".png", ran.Value.RelativePath, StringComparison.Ordinal);
     }
 
-    /// <summary>A proveniencia e gravada com o modelo, o prompt reescrito e o custo estimado.</summary>
     [Fact]
     public async Task TheWorkerRecordsProvenanceWithTheEstimatedCost()
     {
@@ -197,10 +156,6 @@ public sealed class MediaGeneratorTests
         Assert.True(provenance.C2paPreserved);
     }
 
-    /// <summary>
-    /// Bloqueio de moderacao vira <c>RejectedByPolicy</c>, terminal. Um erro tecnico vira
-    /// <c>Failed</c>, retryable. Colapsar os dois e como um laco de retry vira fatura.
-    /// </summary>
     [Theory]
     [InlineData(MediaErrorCode.PolicyBlocked, MediaJobState.RejectedByPolicy, false)]
     [InlineData(MediaErrorCode.ProviderFailure, MediaJobState.Failed, true)]
@@ -218,7 +173,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal(0, store.Blobs.Writes);
     }
 
-    /// <summary>Job inexistente e recusa nomeada, nunca uma excecao de referencia nula.</summary>
     [Fact]
     public async Task RunningAnUnknownJobIsRefusedByName()
     {
@@ -230,10 +184,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal(MediaErrorCode.NotFound, ran.Error!.Code);
     }
 
-    /// <summary>
-    /// Um alias de VIDEO pedido como imagem nao vira job: as unidades de cobranca sao
-    /// diferentes, e um pedido com a tarifa errada estima o custo errado em silencio.
-    /// </summary>
     [Fact]
     public async Task AVideoAliasCannotServeAnImageRequest()
     {
@@ -246,9 +196,6 @@ public sealed class MediaGeneratorTests
         Assert.Equal(MediaErrorCode.InvalidRequest, result.Error!.Code);
     }
 
-    /// <summary>
-    /// Video sem duracao nao tem custo estimavel — e arbitrar segundos e arbitrar dinheiro.
-    /// </summary>
     [Fact]
     public async Task AVideoRequestWithoutDurationCannotBePriced()
     {

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

@@ -4,15 +4,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios de <see cref="MediaIdempotencyKey"/>: a chave que dedupe a CHAMADA PAGA.
-/// </summary>
-/// <remarks>
-/// Duas propriedades, e as duas custam dinheiro quando falham. <b>Estabilidade</b>: o mesmo
-/// pedido tem de dar a mesma chave, senao todo retry paga de novo. <b>Sensibilidade</b>:
-/// qualquer campo participante que mude tem de mudar a chave, senao um pedido reusa o
-/// artefato pago de OUTRO — pior que pagar duas vezes.
-/// </remarks>
 public sealed class MediaIdempotencyKeyTests
 {
     private static MediaRequest Request(
@@ -29,32 +20,18 @@ public sealed class MediaIdempotencyKeyTests
     private static string KeyOf(MediaRequest request)
         => MediaIdempotencyKey.From(request, "openai", "gpt-image-2").Value;
 
-    // ---------------------------------------------------------------------------------
-    // Estabilidade
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>Duas construcoes do mesmo pedido dao a mesma chave.</summary>
     [Fact]
     public void TheSameRequestAlwaysGivesTheSameKey()
         => Assert.Equal(KeyOf(Request()), KeyOf(Request()));
 
-    /// <summary>
-    /// Espaco em branco a mais nao muda o pedido, entao nao muda a chave. E o que impede um
-    /// prompt re-serializado com quebra de linha diferente de virar outra fatura.
-    /// </summary>
     [Fact]
     public void WhitespaceIsNormalisedAway()
         => Assert.Equal(KeyOf(Request("um sofa verde")), KeyOf(Request("  um   sofa\n verde  ")));
 
-    /// <summary>
-    /// A caixa NAO e normalizada, e e deliberado: num prompt ela muda o resultado (nome de
-    /// marca, texto literal que vai aparecer na imagem).
-    /// </summary>
     [Fact]
     public void CaseIsPreservedBecauseItChangesThePicture()
         => Assert.NotEqual(KeyOf(Request("um sofa VERDE")), KeyOf(Request("um sofa verde")));
 
-    /// <summary>A chave e um sha256 em hex minusculo: 64 digitos.</summary>
     [Fact]
     public void TheKeyIsASha256InLowercaseHex()
     {
@@ -64,58 +41,43 @@ public sealed class MediaIdempotencyKeyTests
         Assert.Matches("^[0-9a-f]{64}$", key);
     }
 
-    // ---------------------------------------------------------------------------------
-    // Sensibilidade — uma rodada POR CAMPO participante
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>Prompt diferente, chave diferente.</summary>
     [Fact]
     public void ADifferentPromptChangesTheKey()
         => Assert.NotEqual(KeyOf(Request("um sofa azul")), KeyOf(Request()));
 
-    /// <summary>Modelo diferente, chave diferente — o alias pode ser repontado.</summary>
     [Fact]
     public void ADifferentModelChangesTheKey()
         => Assert.NotEqual(
             MediaIdempotencyKey.From(Request(), "openai", "gpt-image-2").Value,
             MediaIdempotencyKey.From(Request(), "openai", "outro-modelo").Value);
 
-    /// <summary>Provider diferente, chave diferente.</summary>
     [Fact]
     public void ADifferentProviderChangesTheKey()
         => Assert.NotEqual(
             MediaIdempotencyKey.From(Request(), "openai", "m").Value,
             MediaIdempotencyKey.From(Request(), "google", "m").Value);
 
-    /// <summary>
-    /// <b>Trocar a foto de referencia E outro pedido</b>, mesmo com o prompt identico. Por
-    /// isso o sha256 de CADA referencia participa, e nao a contagem delas.
-    /// </summary>
     [Fact]
     public void ADifferentReferenceChangesTheKey()
         => Assert.NotEqual(
             KeyOf(Request(references: ["foto-a"])),
             KeyOf(Request(references: ["foto-b"])));
 
-    /// <summary>Mesma quantidade de referencias, conteudo trocado de ordem: outro pedido.</summary>
     [Fact]
     public void TheOrderOfReferencesIsPartOfTheRequest()
         => Assert.NotEqual(
             KeyOf(Request(references: ["a", "b"])),
             KeyOf(Request(references: ["b", "a"])));
 
-    /// <summary>Sem referencia e com referencia sao pedidos diferentes.</summary>
     [Fact]
     public void AddingAReferenceChangesTheKey()
         => Assert.NotEqual(KeyOf(Request()), KeyOf(Request(references: ["foto-a"])));
 
-    /// <summary>Cada opcao participante, uma rodada.</summary>
     [Theory]
     [MemberData(nameof(OptionVariations))]
     public void EveryParticipatingOptionChangesTheKey(MediaOptions variation)
         => Assert.NotEqual(KeyOf(Request()), KeyOf(Request(options: variation)));
 
-    /// <summary>As variacoes de opcao exercitadas, uma por campo canonico.</summary>
     public static TheoryData<MediaOptions> OptionVariations() =>
     [
         new MediaOptions { Quality = MediaQuality.High },
@@ -126,18 +88,12 @@ public sealed class MediaIdempotencyKeyTests
         new MediaOptions { AspectRatio = "9:16" },
     ];
 
-    /// <summary>
-    /// O separador e um caractere de CONTROLE, e nao <c>|</c>. Um prompt que contivesse o
-    /// separador visivel emendaria campos e faria dois pedidos diferentes colidirem — que
-    /// e o defeito que faz um pedido reusar o artefato pago do outro.
-    /// </summary>
     [Fact]
     public void APromptFullOfPipesDoesNotCollideWithAnotherRequest()
         => Assert.NotEqual(
             KeyOf(Request("gpt-image-2|Image|um sofa")),
             KeyOf(Request("um sofa")));
 
-    /// <summary>Normalizacao de prompt e pura e conferivel sozinha.</summary>
     [Theory]
     [InlineData("  a  b  ", "a b")]
     [InlineData("a\n\nb", "a b")]

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

@@ -3,23 +3,10 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios da maquina de estados de <see cref="MediaJob"/>.
-/// </summary>
-/// <remarks>
-/// Tres afirmacoes carregam o standard <c>ai-agents/media-pipeline.md</c> inteiro, e cada
-/// uma e o inverso literal de um defeito caro:
-/// <list type="number">
-///   <item><c>Publish</c> falha fora de <c>Approved</c> — publicar sem revisao humana.</item>
-///   <item><c>Approved</c> so existe por <c>Approve(revisor)</c> — "aprovado" sem quem.</item>
-///   <item><c>RejectedByPolicy</c> nao e retryable — retry que vira fatura.</item>
-/// </list>
-/// </remarks>
 public sealed class MediaJobStateTests
 {
     private static readonly DateTimeOffset T0 = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);
 
-    /// <summary>Uma marcacao valida, para os casos que nao estao medindo a marcacao.</summary>
     private static MediaDisclosure Label => MediaDisclosure.Create("Imagem gerada por IA", "legenda", T0);
 
     private static MediaJob Pending() => MediaJob.Create(
@@ -37,14 +24,6 @@ public sealed class MediaJobStateTests
             .Value;
     }
 
-    // ---------------------------------------------------------------------------------
-    // 1. Publish so a partir de Approved
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// O atalho que alguem sempre quer: publicar direto de <c>Generated</c>. Ele nao
-    /// existe, e a mensagem diz por que.
-    /// </summary>
     [Fact]
     public void PublishFailsFromGeneratedBecauseNobodyReviewedIt()
     {
@@ -55,7 +34,6 @@ public sealed class MediaJobStateTests
         Assert.Contains("Approved", result.Error.Message, StringComparison.Ordinal);
     }
 
-    /// <summary>Publish falha a partir de TODO estado que nao seja Approved — nao so de Generated.</summary>
     [Theory]
     [InlineData(MediaJobState.Pending)]
     [InlineData(MediaJobState.Generating)]
@@ -71,7 +49,6 @@ public sealed class MediaJobStateTests
         Assert.False(job.Publish(Label, T0).IsSuccess);
     }
 
-    /// <summary>E, com a revisao humana no lugar, publica.</summary>
     [Fact]
     public void PublishSucceedsFromApproved()
     {
@@ -84,11 +61,6 @@ public sealed class MediaJobStateTests
         Assert.Equal(T0, published.Value.PublishedAt);
     }
 
-    // ---------------------------------------------------------------------------------
-    // 2. Approved so por Approve(revisor)
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>A aprovacao carrega quem e quando — sem isso e um campo booleano.</summary>
     [Fact]
     public void ApproveStampsTheReviewerAndTheTime()
     {
@@ -100,15 +72,10 @@ public sealed class MediaJobStateTests
         Assert.Equal("cor confere", approved.Review.Note);
     }
 
-    /// <summary>Revisor em branco nao carimba nada, e a recusa e na construcao da revisao.</summary>
     [Fact]
     public void AnAnonymousReviewIsRefusedAtConstruction()
         => Assert.Throws<ArgumentException>(() => MediaReview.ApprovedBy("   ", T0));
 
-    /// <summary>
-    /// Aprovar com um veredito de REJEICAO seria registrar o oposto do que o humano
-    /// decidiu. O tipo recusa.
-    /// </summary>
     [Fact]
     public void ApproveRefusesAReviewThatSaysRejected()
     {
@@ -118,19 +85,10 @@ public sealed class MediaJobStateTests
         Assert.Equal(MediaErrorCode.InvalidTransition, result.Error!.Code);
     }
 
-    /// <summary>Aprovar antes de existirem bytes nao e transicao.</summary>
     [Fact]
     public void ApproveFailsBeforeTheBytesExist()
         => Assert.False(Pending().Approve(MediaReview.ApprovedBy("lucas", T0)).IsSuccess);
 
-    // ---------------------------------------------------------------------------------
-    // 3. RejectedByPolicy nao e retryable; Failed e
-    // ---------------------------------------------------------------------------------
-
-    /// <summary>
-    /// A distincao que vale dinheiro. Bloqueio de moderacao e resposta definitiva; erro
-    /// tecnico e tentativa perdida.
-    /// </summary>
     [Fact]
     public void PolicyBlockIsTerminalAndTechnicalFailureIsNot()
     {
@@ -146,7 +104,6 @@ public sealed class MediaJobStateTests
         Assert.True(failed.StartGenerating().IsSuccess);
     }
 
-    /// <summary>Um job em <c>Generated</c> carrega hash, caminho e proveniencia — os tres juntos.</summary>
     [Fact]
     public void GeneratedCarriesHashPathAndProvenanceTogether()
     {
@@ -158,7 +115,6 @@ public sealed class MediaJobStateTests
         Assert.Equal("gpt-image-2", job.Provenance!.ModelId);
     }
 
-    /// <summary>Uma transicao recusada NAO muda o job: o registro e imutavel.</summary>
     [Fact]
     public void ARefusedTransitionLeavesTheJobUntouched()
     {