@polymorphism-tech/morph-spec 8.38.0 → 8.41.0

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()
     {

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

@@ -3,15 +3,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// Canarios de <see cref="MediaReview"/>.
-/// </summary>
-/// <remarks>
-/// A afirmacao que este arquivo protege nao e "aprovar funciona" — e que
-/// <see cref="MediaReview"/> <b>delega</b> ao <see cref="MediaJob"/> em vez de reimplementar
-/// a regra. Uma segunda copia de "so Approved publica" e exatamente como as duas divergem, e
-/// e o padrao de falha que esta epic catalogou sete vezes: o teste mede uma COPIA do objeto.
-/// </remarks>
 public sealed class MediaReviewTests
 {
     private static readonly DateTimeOffset T0 = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);
@@ -31,7 +22,6 @@ public sealed class MediaReviewTests
             new MediaProvenance("openai", "gpt-image-2", "p", null, [], "-", null, 0m, T0, true)).Value;
     }
 
-    /// <summary>O atalho aprova e carimba.</summary>
     [Fact]
     public void ApproveDelegatesAndStamps()
     {
@@ -42,7 +32,6 @@ public sealed class MediaReviewTests
         Assert.Equal("lucas", result.Value.Review!.Reviewer);
     }
 
-    /// <summary>Rejeitar e terminal e tambem carimba.</summary>
     [Fact]
     public void RejectDelegatesAndStamps()
     {
@@ -53,12 +42,6 @@ public sealed class MediaReviewTests
         Assert.Equal(MediaReviewDecision.Rejected, result.Value.Review!.Decision);
     }
 
-    /// <summary>
-    /// O atalho de publicar NAO tem uma regra propria: ele recusa exatamente onde
-    /// <see cref="MediaJob.Publish"/> recusa. Confere-se comparando as DUAS chamadas sobre o
-    /// MESMO job — se <c>MediaReview</c> tivesse copiado a regra, aqui e onde a copia
-    /// divergiria.
-    /// </summary>
     [Fact]
     public void PublishThroughTheReviewFacadeAgreesWithTheJobItself()
     {
@@ -72,12 +55,10 @@ public sealed class MediaReviewTests
         Assert.True(MediaReview.Publish(approved, Label, T0).IsSuccess);
     }
 
-    /// <summary>Job nulo e falha de composicao, nao Result: quem chama errou o codigo.</summary>
     [Fact]
     public void ANullJobIsAProgrammingError()
         => Assert.Throws<ArgumentNullException>(() => MediaReview.Approve(null!, "lucas", T0));
 
-    /// <summary>Um juiz LLM cabe na nota, nunca no campo do revisor de uma foto de catalogo.</summary>
     [Fact]
     public void TheNoteCarriesThePreFilterVerdict()
     {

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

@@ -5,22 +5,12 @@ 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()
     {
@@ -37,7 +27,6 @@ public sealed class MediaStoreTests
         Assert.Equal(1, blobs.Writes);
     }
 
-    /// <summary>Conteudo diferente, endereco diferente, duas gravacoes.</summary>
     [Fact]
     public async Task DifferentContentGetsADifferentAddress()
     {
@@ -52,18 +41,10 @@ public sealed class MediaStoreTests
         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()
     {
@@ -73,10 +54,6 @@ public sealed class MediaStoreTests
         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")]
@@ -86,7 +63,6 @@ public sealed class MediaStoreTests
     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()
     {