@polymorphism-tech/morph-spec 8.37.1 → 8.40.0

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/IMediaProvider.cs

@@ -1,77 +1,21 @@
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// O que PRODUZ BYTES. <b><c>internal</c> ao assembly, e e isso que prende a regra dura.</b>
-/// </summary>
-/// <remarks>
-/// <para>
-/// <c>ai-agents/media-pipeline.md</c> diz: <i>nunca gere midia dentro de um turno de
-/// conversa</i>. Uma frase num standard nao prende nada — o que prende e este modificador.
-/// </para>
-/// <para>
-/// Este tipo e os tres adaptadores de provider sao <c>internal</c>, com
-/// <c>InternalsVisibleTo</c> liberando apenas <c>Morph.AiKit.Tests</c>. Um handler de
-/// mensagem no projeto consumidor <b>nao consegue nomear</b> o tipo que produz bytes: o
-/// codigo nao compila. A unica superficie publica e
-/// <see cref="IMediaGenerator.EnqueueAsync"/>, que devolve um <see cref="MediaJobId"/>.
-/// </para>
-/// <para>
-/// Um teste de acessibilidade por reflexao (<c>MediaAccessibilityTests</c>) mantem esta
-/// afirmacao verdadeira: tornar o tipo publico derruba a suite. Um canario que ninguem viu
-/// morder pode ser o canario errado, entao a mutacao foi rodada.
-/// </para>
-/// </remarks>
+// internal e o que impede um handler de gerar midia dentro do turno de conversa; MediaAccessibilityTests cobra.
 internal interface IMediaProvider
 {
-    /// <summary>Familia do SDK: <c>openai</c>, <c>google</c>.</summary>
     string Provider { get; }
 
-    /// <summary>Se este adaptador atende esse tipo de midia.</summary>
     bool Supports(MediaKind kind);
 
-    /// <summary>
-    /// Produz os bytes. Bloqueio de moderacao volta como
-    /// <see cref="MediaErrorCode.PolicyBlocked"/> — terminal, nunca retryable; falha
-    /// tecnica volta como <see cref="MediaErrorCode.ProviderFailure"/>.
-    /// </summary>
-    /// <param name="request">O pedido, ja validado.</param>
-    /// <param name="binding">
-    /// O alias resolvido. Viaja como parametro, e nao no construtor, porque um adaptador
-    /// atende N aliases do mesmo provider e uma instancia por alias multiplicaria clientes
-    /// sem nenhum ganho.
-    /// </param>
-    /// <param name="cancellationToken">—</param>
     Task<MediaResult<MediaArtifact>> ProduceAsync(
         MediaRequest request,
         MediaAliasBinding binding,
         CancellationToken cancellationToken);
 }
 
-/// <summary>
-/// Constroi os clientes de SDK dos providers de midia. <b>A costura do subsistema</b>: o
-/// unico ponto em que o kit toca um provider de verdade.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Publica de proposito, e pela mesma razao de <c>IProviderClientFactory</c>: e assim que a
-/// suite do kit roda <b>sem rede e sem chave de API</b> — em teste ninguem implementa esta
-/// interface, porque os testes usam um <c>IMediaProvider</c> fake e nunca chegam aqui.
-/// </para>
-/// <para>
-/// Devolver <c>null</c> significa "este provider nao e meu": o catalogo entao procura outro
-/// adaptador, e se nenhum atender, o job falha com motivo nomeado em vez de silenciosamente
-/// nao acontecer.
-/// </para>
-/// <para>
-/// <b>Quem descarta o cliente e o projeto</b>, que o construiu. O kit nao guarda cache
-/// propria de cliente — duas caches da mesma coisa e como um cliente vaza de um teste.
-/// </para>
-/// </remarks>
 public interface IMediaClientFactory
 {
-    /// <summary>O <c>ImageClient</c> do alias, ou nulo quando o provider nao e a OpenAI.</summary>
     OpenAI.Images.ImageClient? CreateOpenAiImageClient(MediaAliasBinding binding);
 
-    /// <summary>O cliente do Google GenAI, ou nulo quando o provider nao e o Google.</summary>
     Google.GenAI.Client? CreateGoogleClient(MediaAliasBinding binding);
 }

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaArtifact.cs

@@ -1,24 +1,5 @@
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// O que um provider produz: bytes, mais o que so o provider sabe sobre a geracao.
-/// </summary>
-/// <remarks>
-/// <b>Este tipo nunca sai pela superficie publica do subsistema.</b> Ele existe entre o
-/// <c>IMediaProvider</c> (internal) e o worker (internal); o que chega ao projeto e um
-/// <see cref="MediaJob"/> com caminho e hash. Se um handler consegue segurar um
-/// <see cref="MediaArtifact"/>, a regra dura de ai-agents/media-pipeline.md foi furada.
-/// </remarks>
-/// <param name="Kind">Imagem ou video.</param>
-/// <param name="MediaType">MIME dos bytes devolvidos pelo provider.</param>
-/// <param name="Bytes">O conteudo. Baixado JA, nunca uma URL guardada para depois.</param>
-/// <param name="RevisedPrompt">O prompt que o provider reescreveu, quando ele devolve um.</param>
-/// <param name="ResponseId">O id do lado do provider, para abrir chamado.</param>
-/// <param name="C2paPreserved">
-/// Se os metadados de proveniencia do provider sobreviveram ao caminho ate aqui. Falso
-/// quando o adaptador re-encodou os bytes — e um re-encode destrutivo apaga a credencial
-/// C2PA, que e a unica prova tecnica de origem que a imagem carregava.
-/// </param>
 internal sealed record MediaArtifact(
     MediaKind Kind,
     string MediaType,

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaDisclosure.cs

@@ -1,44 +1,8 @@
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// A marcação "gerado/editado por IA" que acompanha a publicação.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Este tipo existe porque a afirmação estava só na prosa.</b> Antes dele,
-/// <see cref="MediaJobState.Published"/> dizia "publicado, com a marcacao aplicada" e
-/// <see cref="MediaPurpose.Marketing"/> dizia "marcacao visivel obrigatoria" — e um
-/// <c>grep</c> por label, watermark ou disclosure no kit inteiro voltava <b>vazio</b>. Três
-/// das quatro afirmações que a rubrica <c>media-claims</c> cobra de terceiros estavam presas
-/// por tipo ou por estado; a quarta, que é a obrigação legal, estava presa por nada.
-/// </para>
-/// <para>
-/// <b>O construtor é PRIVADO, e isso não é estilo.</b> A primeira versão deste tipo era um
-/// record POSICIONAL — e um record posicional gera um construtor <b>público</b>. A validação
-/// morava só em <see cref="Create"/>, então <c>new MediaDisclosure("", "", at)</c> compilava,
-/// era aceito, e publicava com rótulo vazio. Medido de um consumidor externo:
-/// <c>IsSuccess=True State=Published</c>, <c>Text='' Surface=''</c>. A prosa dizia "recusado na
-/// construção" em quatro superfícies; a construção não recusava nada. Uma marcação vazia é
-/// exatamente o campo preenchido "para passar" que este tipo existe para impedir, e agora é o
-/// <b>compilador</b> que fecha a porta — não a documentação. Mesma forma de
-/// <see cref="MediaReview"/>, três arquivos ao lado.
-/// </para>
-/// <para>
-/// <b>O que este tipo prova, exatamente:</b> que um job <b>não alcança</b>
-/// <see cref="MediaJobState.Published"/> sem uma marcação registrada e não-vazia, quando a
-/// finalidade a exige. É o mesmo mecanismo de <see cref="MediaJob.Approve"/> — uma transição
-/// que o código não tem, em vez de uma frase que alguém tem de lembrar.
-/// </para>
-/// <para>
-/// <b>O que ele NÃO prova, e é honesto dizer:</b> 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 o kit
-/// garante é que a decisão foi tomada, com texto e superfície nomeados, e ficou gravada com o
-/// artefato — de modo que "esquecemos de marcar" deixa de ser um caminho silencioso e passa a
-/// ser uma recusa na publicação.
-/// </para>
-/// </remarks>
 public sealed record MediaDisclosure
 {
+    // Privado de proposito: um record posicional geraria construtor publico que pula a validacao de Create.
     private MediaDisclosure(string text, string surface, DateTimeOffset appliedAt)
     {
         Text = text;
@@ -46,25 +10,12 @@ public sealed record MediaDisclosure
         AppliedAt = appliedAt;
     }
 
-    /// <summary>
-    /// O texto visível, por extenso. Em branco é recusado — e a recusa é presa pelo construtor
-    /// privado, não por convenção de chamada.
-    /// </summary>
     public string Text { get; }
 
-    /// <summary>
-    /// ONDE o rótulo aparece — legenda, sobreposição, texto alternativo, ficha do produto. Sem
-    /// isto, "marcado" não diz se alguém consegue ver.
-    /// </summary>
     public string Surface { get; }
 
-    /// <summary>Quando a marcação foi decidida.</summary>
     public DateTimeOffset AppliedAt { get; }
 
-    /// <summary>
-    /// A ÚNICA forma de obter uma marcação. Recusa texto ou superfície em branco.
-    /// </summary>
-    /// <exception cref="ArgumentException">Texto ou superfície vazios.</exception>
     public static MediaDisclosure Create(string text, string surface, DateTimeOffset appliedAt)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(text);
@@ -74,34 +25,11 @@ public sealed record MediaDisclosure
     }
 }
 
-/// <summary>Política de marcação por finalidade. Escrita uma vez, aqui.</summary>
 public static class MediaPurposeExtensions
 {
-    /// <summary>
-    /// Se a finalidade exige marcação visível para publicar.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// <b>Catálogo e marketing exigem; rascunho não publica.</b> A regra do art. 50 do AI Act
-    /// mira conteúdo que <i>possa parecer autêntico</i> sobre produto, pessoa ou lugar — e é
-    /// exatamente o que catálogo e peça de campanha são. A leitura conservadora é do standard
-    /// <c>ai-agents/media-pipeline.md</c>, seção Marcação, com a ressalva de fonte que ele
-    /// carrega: este predicado é uma decisão de desenho, não parecer jurídico.
-    /// </para>
-    /// <para>
-    /// Não confunda com <see cref="IsPublishable"/>: um rascunho não chega a publicar, então
-    /// a pergunta "precisa de marcação" nem se coloca para ele.
-    /// </para>
-    /// </remarks>
+    // AI Act art. 50, na leitura conservadora de ai-agents/media-pipeline.md (decisao de desenho, nao parecer juridico).
     public static bool RequiresDisclosure(this MediaPurpose purpose)
         => purpose is MediaPurpose.CatalogPhoto or MediaPurpose.Marketing;
 
-    /// <summary>
-    /// Se a finalidade pode chegar a <see cref="MediaJobState.Published"/>.
-    /// </summary>
-    /// <remarks>
-    /// <see cref="MediaPurpose.Draft"/> se declara "nunca publicável" desde o primeiro dia — e
-    /// até este tipo existir, isso era só um comentário XML. Agora é uma recusa.
-    /// </remarks>
     public static bool IsPublishable(this MediaPurpose purpose) => purpose != MediaPurpose.Draft;
 }

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaGenerator.cs

@@ -2,17 +2,6 @@ using Morph.AiKit.Media.Providers;
 
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// A implementacao de <see cref="IMediaGenerator"/>. <b><c>internal</c></b>: o projeto
-/// enxerga a interface, nunca o tipo.
-/// </summary>
-/// <remarks>
-/// A ORDEM do <see cref="EnqueueAsync"/> e o contrato, e ela e economia, nao estilo:
-/// validar, resolver alias, derivar a chave de PEDIDO, <b>consultar a chave antes de
-/// qualquer coisa paga</b>, so entao estimar custo e reservar teto, e por ultimo gravar o
-/// job. Um retry que chega aqui reencontra o job e nao paga de novo; um estouro de teto
-/// recusa antes de o dinheiro sair.
-/// </remarks>
 internal sealed class MediaGenerator : IMediaGenerator
 {
     private readonly IMediaAliasResolver _aliases;
@@ -36,7 +25,6 @@ internal sealed class MediaGenerator : IMediaGenerator
         _clock = clock;
     }
 
-    /// <inheritdoc />
     public async Task<MediaResult<MediaJobId>> EnqueueAsync(
         MediaRequest request,
         CancellationToken cancellationToken = default)
@@ -64,8 +52,7 @@ internal sealed class MediaGenerator : IMediaGenerator
 
         var key = MediaIdempotencyKey.From(request, binding.Value.Provider, binding.Value.Model);
 
-        // ANTES de qualquer coisa paga. Um pedido identico a outro ja atendido reusa o job
-        // existente; so um job em Failed vale outra tentativa.
+        // ANTES de qualquer coisa paga; so um job em Failed vale outra tentativa.
         var existing = await _jobs.FindByIdempotencyKeyAsync(key, cancellationToken).ConfigureAwait(false);
         if (existing is not null && existing.State != MediaJobState.Failed)
         {
@@ -99,7 +86,6 @@ internal sealed class MediaGenerator : IMediaGenerator
         return MediaResult<MediaJobId>.Ok(job.Id);
     }
 
-    /// <inheritdoc />
     public async Task<MediaResult<MediaJob>> GetAsync(MediaJobId id, CancellationToken cancellationToken = default)
     {
         var job = await _jobs.FindAsync(id, cancellationToken).ConfigureAwait(false);
@@ -110,16 +96,7 @@ internal sealed class MediaGenerator : IMediaGenerator
     }
 }
 
-/// <summary>
-/// Executa um job: chama o provider, guarda os bytes, move o estado. <b><c>internal</c></b>
-/// — e este e o unico tipo do subsistema que segura um <see cref="IMediaProvider"/>.
-/// </summary>
-/// <remarks>
-/// A ordem tambem e o contrato: <c>Generating</c> antes da chamada (para que um worker
-/// morto no meio deixe rastro), os bytes GRAVADOS antes de <c>Generated</c> (um job em
-/// <c>Generated</c> sem bytes no storage mente sobre o proprio estado), e o bloqueio de
-/// moderacao indo para <c>RejectedByPolicy</c> e nao para <c>Failed</c>.
-/// </remarks>
+// Generating antes da chamada (worker morto deixa rastro) e bytes gravados antes de Generated.
 internal sealed class MediaWorker : IMediaJobRunner
 {
     private readonly IMediaAliasResolver _aliases;
@@ -148,7 +125,6 @@ internal sealed class MediaWorker : IMediaJobRunner
         _clock = clock;
     }
 
-    /// <inheritdoc />
     public async Task<MediaResult<MediaJob>> RunAsync(MediaJobId id, CancellationToken cancellationToken = default)
     {
         var job = await _jobs.FindAsync(id, cancellationToken).ConfigureAwait(false);
@@ -186,8 +162,6 @@ internal sealed class MediaWorker : IMediaJobRunner
 
         if (!produced.IsSuccess)
         {
-            // A distincao que vale dinheiro: bloqueio de politica e terminal, falha tecnica
-            // e retryable. Colapsar as duas em "erro" e como um laco de retry vira fatura.
             var transition = produced.Error!.Code == MediaErrorCode.PolicyBlocked
                 ? job.RejectByPolicy(produced.Error.Message)
                 : job.Fail(produced.Error.Message);
@@ -232,13 +206,8 @@ internal sealed class MediaWorker : IMediaJobRunner
     }
 }
 
-/// <summary>
-/// Monta os adaptadores de provider. <b><c>internal</c></b>, e e por isso que nao existe
-/// caminho publico ate um <see cref="IMediaProvider"/>.
-/// </summary>
 internal static class MediaProviderCatalog
 {
-    /// <summary>Os tres adaptadores que o kit traz.</summary>
     public static IReadOnlyList<IMediaProvider> Build(IMediaClientFactory clients)
     {
         ArgumentNullException.ThrowIfNull(clients);

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaIdempotencyKey.cs

@@ -3,53 +3,13 @@ using System.Text;
 
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// A chave de idempotencia do <b>PEDIDO</b> — a que dedupe a CHAMADA PAGA.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Ela nao e o <see cref="MediaHash"/>, e a diferenca e o defeito caro deste
-/// subsistema.</b> Esta chave e o sha256 do PEDIDO (provider + modelo + prompt normalizado
-/// + sha256 de cada referencia + opcoes) e responde "ja pagamos por isto?". O
-/// <see cref="MediaHash"/> e o sha256 dos BYTES e responde "ja guardamos isto?". Duas
-/// perguntas diferentes: dois pedidos distintos podem produzir bytes identicos, e o mesmo
-/// pedido sempre produz o mesmo pedido.
-/// </para>
-/// <para>
-/// Ela e consultada <b>antes</b> de chamar o provider. E o que faz um retry — de fila, de
-/// worker reiniciado, de webhook duplicado — custar zero.
-/// </para>
-/// <para>
-/// <b>O prompt e normalizado, nao minusculado.</b> Espacos em branco colapsam e as pontas
-/// sao aparadas, porque um espaco a mais nao muda o pedido; a caixa e preservada, porque
-/// num prompt ela muda (nomes de marca, texto literal entre aspas que vai aparecer na
-/// imagem).
-/// </para>
-/// </remarks>
-/// <param name="Value">sha256 em hex minusculo.</param>
 public readonly record struct MediaIdempotencyKey(string Value)
 {
-    /// <summary>Separador de CAMPO na forma canonica: UNIT SEPARATOR (U+001F).</summary>
-    /// <remarks>
-    /// Um caractere de controle, e nao <c>|</c> ou <c>:</c>, porque o separador nao pode
-    /// aparecer dentro de um campo. Um prompt que contivesse o separador emendaria dois
-    /// campos numa chave so, e duas requisicoes diferentes passariam a compartilhar a
-    /// chave — o que faz uma reusar o artefato PAGO da outra. Pior que pagar duas vezes.
-    /// Escrito como <c>(char)0x1F</c> e nao como o caractere cru: um byte de controle
-    /// invisivel no fonte e uma armadilha para o proximo editor.
-    /// </remarks>
+    // Caractere de controle: um separador que aparecesse no prompt emendaria campos e duas requisicoes dividiriam a chave.
     private const char FieldSeparator = (char)0x1F;
 
-    /// <summary>Separador de ITEM dentro de um campo: RECORD SEPARATOR (U+001E).</summary>
     private const char ItemSeparator = (char)0x1E;
 
-    /// <summary>
-    /// Deriva a chave do pedido resolvido.
-    /// </summary>
-    /// <param name="request">O pedido.</param>
-    /// <param name="provider">A familia do SDK que vai atender (<c>openai</c>, <c>google</c>).</param>
-    /// <param name="model">O modelo resolvido pelo alias — nunca o alias, que pode ser repontado.</param>
-    /// <exception cref="ArgumentNullException">Pedido nulo.</exception>
     public static MediaIdempotencyKey From(MediaRequest request, string provider, string model)
     {
         ArgumentNullException.ThrowIfNull(request);
@@ -70,7 +30,6 @@ public readonly record struct MediaIdempotencyKey(string Value)
             Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(canonical))));
     }
 
-    /// <summary>Apara as pontas e colapsa espacos em branco. NAO minuscula.</summary>
     public static string NormalizePrompt(string prompt)
     {
         ArgumentNullException.ThrowIfNull(prompt);
@@ -98,6 +57,5 @@ public readonly record struct MediaIdempotencyKey(string Value)
         return builder.ToString();
     }
 
-    /// <summary>A chave, para log.</summary>
     public override string ToString() => Value;
 }

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaJob.cs

@@ -1,34 +1,5 @@
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// Um pedido de midia com estado. <b>E o unico objeto de dominio que a superficie publica
-/// devolve</b> — nunca bytes.
-/// </summary>
-/// <remarks>
-/// <para>
-/// As transicoes sao metodos que devolvem <see cref="MediaResult{T}"/> e um job NOVO: o
-/// registro e imutavel, e uma transicao invalida e informacao devolvida, nunca excecao.
-/// </para>
-/// <para>
-/// <b>Duas invariantes carregam o standard inteiro:</b>
-/// </para>
-/// <list type="number">
-///   <item>
-///     <see cref="Approve"/> e a UNICA porta para <see cref="MediaJobState.Approved"/>, e
-///     ela exige um revisor com nome e carimbo de tempo. E assim que "ha revisao humana"
-///     deixa de ser uma frase no README e vira um caminho que o codigo nao tem.
-///   </item>
-///   <item>
-///     <see cref="Publish"/> falha a partir de qualquer estado que nao seja
-///     <c>Approved</c>. Nao ha atalho, nem flag, nem sobrecarga "force".
-///   </item>
-/// </list>
-/// <para>
-/// E ha uma terceira, que vale dinheiro: <see cref="RejectByPolicy"/> produz um estado
-/// terminal com <see cref="IsRetryable"/> falso. Bloqueio de moderacao nao e erro tecnico —
-/// retenta-lo gasta para receber o mesmo "nao".
-/// </para>
-/// </remarks>
 public sealed record MediaJob
 {
     private MediaJob(MediaJobId id, MediaRequest request, MediaIdempotencyKey key, DateTimeOffset createdAt)
@@ -40,70 +11,44 @@ public sealed record MediaJob
         State = MediaJobState.Pending;
     }
 
-    /// <summary>A identidade. O unico valor que sai pela superficie publica.</summary>
     public MediaJobId Id { get; private init; }
 
-    /// <summary>O pedido, congelado.</summary>
     public MediaRequest Request { get; private init; }
 
-    /// <summary>A chave que dedupe a chamada paga.</summary>
     public MediaIdempotencyKey IdempotencyKey { get; private init; }
 
-    /// <summary>Onde o job esta.</summary>
     public MediaJobState State { get; private init; }
 
-    /// <summary>Quando o pedido foi aceito.</summary>
     public DateTimeOffset CreatedAt { get; private init; }
 
-    /// <summary>sha256 dos bytes, a partir de <see cref="MediaJobState.Generated"/>.</summary>
     public MediaHash? Hash { get; private init; }
 
-    /// <summary>Caminho RELATIVO no blob do projeto. Nunca URL de provider.</summary>
     public string? RelativePath { get; private init; }
 
-    /// <summary>A proveniencia, gravada na geracao.</summary>
     public MediaProvenance? Provenance { get; private init; }
 
-    /// <summary>Quem decidiu, quando, e o que escreveu. Nulo enquanto ninguem revisou.</summary>
     public MediaReview? Review { get; private init; }
 
-    /// <summary>Por que falhou ou foi bloqueado. Nulo nos estados saudaveis.</summary>
     public string? FailureReason { get; private init; }
 
-    /// <summary>Quando foi publicado.</summary>
     public DateTimeOffset? PublishedAt { get; private init; }
 
-    /// <summary>
-    /// A marcação "gerado por IA" registrada na publicação, ou nulo quando a finalidade não
-    /// a exige. Ver <see cref="MediaDisclosure"/> e <see cref="Publish"/>.
-    /// </summary>
     public MediaDisclosure? Disclosure { get; private init; }
 
-    /// <summary>
-    /// Se vale tentar de novo. <b>So <see cref="MediaJobState.Failed"/> e retryable.</b>
-    /// <see cref="MediaJobState.RejectedByPolicy"/> nao e, e essa e a diferenca que impede
-    /// um laco de retry de virar uma fatura.
-    /// </summary>
+    // RejectedByPolicy nao e retryable: retentar um bloqueio de moderacao paga pelo mesmo "nao".
     public bool IsRetryable => State == MediaJobState.Failed;
 
-    /// <summary>Nasce em <see cref="MediaJobState.Pending"/>. Nada foi gasto ainda.</summary>
-    /// <exception cref="ArgumentNullException">Pedido nulo.</exception>
     public static MediaJob Create(MediaRequest request, MediaIdempotencyKey key, DateTimeOffset createdAt)
     {
         ArgumentNullException.ThrowIfNull(request);
         return new MediaJob(MediaJobId.New(), request, key, createdAt);
     }
 
-    /// <summary>Pending para Generating: a chamada paga esta em voo.</summary>
     public MediaResult<MediaJob> StartGenerating()
         => State == MediaJobState.Pending || State == MediaJobState.Failed
             ? MediaResult<MediaJob>.Ok(this with { State = MediaJobState.Generating, FailureReason = null })
             : Invalid(nameof(StartGenerating), MediaJobState.Generating);
 
-    /// <summary>
-    /// Generating para Generated. Exige hash, caminho e proveniencia <b>juntos</b>: um job
-    /// em <c>Generated</c> sem bytes no seu storage esta mentindo sobre o proprio estado.
-    /// </summary>
     public MediaResult<MediaJob> MarkGenerated(MediaHash hash, string relativePath, MediaProvenance provenance)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(relativePath);
@@ -120,7 +65,6 @@ public sealed record MediaJob
             : Invalid(nameof(MarkGenerated), MediaJobState.Generated);
     }
 
-    /// <summary>Falha tecnica. Retryable.</summary>
     public MediaResult<MediaJob> Fail(string reason)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(reason);
@@ -130,9 +74,6 @@ public sealed record MediaJob
             : Invalid(nameof(Fail), MediaJobState.Failed);
     }
 
-    /// <summary>
-    /// Bloqueio de moderacao. Terminal e NAO retryable — ver <see cref="IsRetryable"/>.
-    /// </summary>
     public MediaResult<MediaJob> RejectByPolicy(string reason)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(reason);
@@ -146,10 +87,6 @@ public sealed record MediaJob
             : Invalid(nameof(RejectByPolicy), MediaJobState.RejectedByPolicy);
     }
 
-    /// <summary>
-    /// A UNICA porta para <see cref="MediaJobState.Approved"/>, e ela exige um humano
-    /// nomeado com carimbo de tempo.
-    /// </summary>
     public MediaResult<MediaJob> Approve(MediaReview review)
     {
         ArgumentNullException.ThrowIfNull(review);
@@ -167,7 +104,6 @@ public sealed record MediaJob
             : Invalid(nameof(Approve), MediaJobState.Approved);
     }
 
-    /// <summary>Recusa humana. Terminal.</summary>
     public MediaResult<MediaJob> Reject(MediaReview review)
     {
         ArgumentNullException.ThrowIfNull(review);
@@ -184,37 +120,6 @@ public sealed record MediaJob
             : Invalid(nameof(Reject), MediaJobState.Rejected);
     }
 
-    /// <summary>
-    /// Publica. <b>Tres portas, e cada uma fecha um caminho que existia so na prosa:</b>
-    /// </summary>
-    /// <remarks>
-    /// <list type="number">
-    ///   <item>
-    ///     Falha a partir de qualquer estado que nao seja <see cref="MediaJobState.Approved"/>
-    ///     — inclusive de <c>Generated</c>, que e o atalho que alguem sempre quer. E o que
-    ///     torna a REVISAO HUMANA um caminho que o codigo nao tem.
-    ///   </item>
-    ///   <item>
-    ///     Falha quando a finalidade nao e publicavel. <see cref="MediaPurpose.Draft"/> se
-    ///     declarava "nunca publicavel" num comentario XML que nada cobrava.
-    ///   </item>
-    ///   <item>
-    ///     Falha quando a finalidade exige MARCACAO e ela nao foi passada. Era a unica das
-    ///     quatro afirmacoes da rubrica <c>media-claims</c> presa por prosa — e e a que
-    ///     carrega a obrigacao legal (AI Act art. 50).
-    ///   </item>
-    /// </list>
-    /// <para>
-    /// O que isto prova e o que nao prova esta escrito em <see cref="MediaDisclosure"/>: o
-    /// kit garante que a DECISAO foi tomada e gravada, nao que o rotulo chegou aos olhos de
-    /// alguem — a renderizacao e do aplicativo consumidor.
-    /// </para>
-    /// </remarks>
-    /// <param name="disclosure">
-    /// A marcacao. Pode ser nula somente quando <see cref="MediaPurpose.RequiresDisclosure"/>
-    /// e falso para a finalidade do pedido.
-    /// </param>
-    /// <param name="publishedAt">Quando.</param>
     public MediaResult<MediaJob> Publish(MediaDisclosure? disclosure, DateTimeOffset publishedAt)
     {
         if (State != MediaJobState.Approved)

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaJobId.cs

@@ -1,21 +1,8 @@
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// A identidade de um job de midia. <b>O unico valor que a superficie publica devolve</b> —
-/// nunca bytes.
-/// </summary>
-/// <remarks>
-/// <c>Guid.CreateVersion7()</c> e nao <c>Guid.NewGuid()</c>: v7 e ordenavel por tempo, o
-/// que mantem o indice do banco do projeto sequencial em vez de espalhar escrita por toda
-/// a arvore. E a regra da casa, escrita aqui porque este e o unico lugar do subsistema que
-/// gera identidade.
-/// </remarks>
-/// <param name="Value">O GUID v7.</param>
 public readonly record struct MediaJobId(Guid Value)
 {
-    /// <summary>Uma identidade nova, ordenavel por tempo.</summary>
     public static MediaJobId New() => new(Guid.CreateVersion7());
 
-    /// <summary>Forma compacta, para log e URL.</summary>
     public override string ToString() => Value.ToString("N");
 }

package/framework/templates/dotnet/ai-kit/src/Morph.AiKit/Media/MediaJobState.cs

@@ -1,47 +1,20 @@
 namespace Morph.AiKit.Media;
 
-/// <summary>
-/// Os oito estados de um job de midia.
-/// </summary>
-/// <remarks>
-/// <para>
-/// A distincao que vale dinheiro esta entre <see cref="Failed"/> e
-/// <see cref="RejectedByPolicy"/>. Um bloqueio de moderacao e uma resposta DEFINITIVA:
-/// retenta-lo gasta para receber o mesmo "nao" — e no provider que cobra o bloqueio, gasta
-/// duas vezes. Modelar bloqueio como erro tecnico e como um laco de retry vira uma fatura.
-/// </para>
-/// <para>
-/// A distincao que vale credibilidade esta entre <see cref="Generated"/> e
-/// <see cref="Approved"/>: <c>Approved</c> so existe por uma transicao que carimba um
-/// revisor humano, e <c>Published</c> so existe a partir de <c>Approved</c>.
-/// </para>
-/// </remarks>
 public enum MediaJobState
 {
-    /// <summary>Pedido aceito. Nada foi gasto ainda.</summary>
     Pending = 0,
 
-    /// <summary>Chamada paga em voo, ou tarefa remota em polling.</summary>
     Generating = 1,
 
-    /// <summary>Os bytes existem NO SEU storage. Nao basta a tarefa remota ter concluido.</summary>
     Generated = 2,
 
-    /// <summary>Um humano aprovou, com nome e carimbo de tempo. Unica porta para <see cref="Published"/>.</summary>
     Approved = 3,
 
-    /// <summary>Um humano recusou. Terminal.</summary>
     Rejected = 4,
 
-    /// <summary>Bloqueio de moderacao do provider. Terminal e <b>nao</b> retryable.</summary>
     RejectedByPolicy = 5,
 
-    /// <summary>
-    /// Publicado. So se alcanca por <see cref="MediaJob.Publish"/>, que exige finalidade
-    /// publicavel e — quando a finalidade a pede — uma <see cref="MediaDisclosure"/> registrada.
-    /// </summary>
     Published = 6,
 
-    /// <summary>Erro tecnico (429, 5xx, timeout, download quebrado). Retryable.</summary>
     Failed = 7,
 }