@polymorphism-tech/morph-spec 8.38.0 → 8.41.0

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

@@ -2,30 +2,6 @@ using Morph.AiKit.Media;
 
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// <see cref="IMediaProvider"/> roteirizado: a costura que dispensa rede, chave de API e
-/// <b>fatura</b> na suite inteira de midia.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Por que ele existe:</b> o unico ponto do subsistema que gasta dinheiro e um
-/// <c>IMediaProvider</c>. Trocando-o por uma fila de respostas escritas a mao, todo o resto
-/// — <c>MediaGenerator</c>, <c>MediaWorker</c>, <c>MediaJob</c>, <c>MediaStore</c> — passa a
-/// ser testavel sem socket, sem segredo e sem cobranca. Mesmo desenho do
-/// <see cref="FakeChatClient"/>, pela mesma razao.
-/// </para>
-/// <para>
-/// Ele so e construivel porque <c>InternalsVisibleTo("Morph.AiKit.Tests")</c> existe no
-/// <c>.csproj</c> da biblioteca. Um projeto consumidor <b>nao</b> consegue escrever esta
-/// classe — e essa impossibilidade e a regra dura de <c>ai-agents/media-pipeline.md</c>,
-/// asserida em <c>MediaAccessibilityTests</c>.
-/// </para>
-/// <para>
-/// <b>Chamada nao roteirizada e defeito de teste.</b> Esgotada a fila, o fake devolve uma
-/// falha nomeada com a contagem de chamadas, em vez de inventar bytes — um artefato
-/// fabricado pelo proprio fake faria um teste passar por engano.
-/// </para>
-/// </remarks>
 internal sealed class FakeMediaProvider : IMediaProvider
 {
     private readonly Queue<MediaResult<MediaArtifact>> _scripted = new();
@@ -37,19 +13,14 @@ internal sealed class FakeMediaProvider : IMediaProvider
         Supported = supports;
     }
 
-    /// <inheritdoc />
     public string Provider { get; }
 
-    /// <summary>Que tipo de midia este fake diz atender.</summary>
     public MediaKind Supported { get; }
 
-    /// <summary>Quantas vezes foi chamado. E como um teste prova que NAO houve segunda chamada paga.</summary>
     public int Calls { get; private set; }
 
-    /// <summary>Os pedidos vistos, na ordem.</summary>
     public List<MediaRequest> Seen { get; } = [];
 
-    /// <summary>Enfileira bytes de sucesso.</summary>
     public FakeMediaProvider Returns(byte[] bytes, string mediaType = "image/png", string? revisedPrompt = null)
     {
         _scripted.Enqueue(MediaResult<MediaArtifact>.Ok(new MediaArtifact(
@@ -57,17 +28,14 @@ internal sealed class FakeMediaProvider : IMediaProvider
         return this;
     }
 
-    /// <summary>Enfileira uma recusa com o codigo dado — inclusive <c>PolicyBlocked</c>.</summary>
     public FakeMediaProvider Fails(MediaErrorCode code, string message = "roteirizado")
     {
         _scripted.Enqueue(MediaResult<MediaArtifact>.Fail(code, message));
         return this;
     }
 
-    /// <inheritdoc />
     public bool Supports(MediaKind kind) => kind == Supported;
 
-    /// <inheritdoc />
     public Task<MediaResult<MediaArtifact>> ProduceAsync(
         MediaRequest request,
         MediaAliasBinding binding,

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

@@ -3,40 +3,26 @@ using Morph.AiKit.Providers;
 
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// <see cref="IProviderClientFactory"/> de teste: devolve <see cref="FakeChatClient"/> e
-/// <b>conta quantas vezes foi chamada</b>. E o contador que torna a memoizacao do
-/// <c>ModelRegistry</c> uma afirmacao verificavel em vez de uma promessa.
-/// </summary>
 public sealed class FakeProviderClientFactory : IProviderClientFactory
 {
     private readonly Func<ModelAlias, IChatClient?> _create;
     private readonly Dictionary<string, IChatClient> _created = new(StringComparer.Ordinal);
     private readonly List<ModelAlias> _requested = [];
 
-    /// <summary>Fabrica que devolve um <see cref="FakeChatClient"/> novo por alias.</summary>
     public FakeProviderClientFactory()
         : this(_ => new FakeChatClient())
     {
     }
 
-    /// <summary>
-    /// Fabrica com construcao sob medida — inclusive devolvendo nulo, para exercitar a
-    /// recusa do registry a um cliente inexistente.
-    /// </summary>
     public FakeProviderClientFactory(Func<ModelAlias, IChatClient?> create)
         => _create = create;
 
-    /// <summary>Quantas vezes <see cref="CreateChatClient"/> foi realmente executada.</summary>
     public int CreateCount { get; private set; }
 
-    /// <summary>Os aliases para os quais um cliente foi criado, na ordem.</summary>
     public IReadOnlyList<ModelAlias> Requested => _requested;
 
-    /// <summary>Os clientes criados, por nome de alias.</summary>
     public IReadOnlyDictionary<string, IChatClient> Created => _created;
 
-    /// <inheritdoc />
     public IChatClient CreateChatClient(ModelAlias alias)
     {
         ArgumentNullException.ThrowIfNull(alias);

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

@@ -2,55 +2,31 @@ using Morph.AiKit.Middleware;
 
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// Sink de teste: acumula os registros de custo publicados pelo
-/// <see cref="UsageCostMiddleware"/>.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Estava nos <c>outputs</c> da T9, mas depende de <see cref="IUsageCostSink"/> e
-/// <see cref="UsageCostRecord"/>, que sao <c>outputs</c> da T11. A T9 recusou-se a criar os
-/// dois tipos por fora (seriam arquivos de outra task, e duplica-los criaria a segunda
-/// verdade do registro de custo) e deixou este codigo pronto no seu relatorio; a errata E8
-/// do <c>spec.md</c> moveu formalmente o arquivo para ca. Nasce junto dos tipos que
-/// implementa.
-/// </para>
-/// <para>
-/// Seguro sob concorrencia pelo mesmo motivo do <see cref="FakeChatClient"/>: um mesmo
-/// pipeline atende varias conversas, e um sink que perdesse linha sob concorrencia faria o
-/// teste medir o sink em vez do middleware.
-/// </para>
-/// </remarks>
 public sealed class FakeUsageCostSink : IUsageCostSink
 {
     private readonly Lock _gate = new();
     private readonly List<UsageCostRecord> _records = [];
 
-    /// <summary>Tudo o que foi publicado, na ordem. Snapshot — iterar e seguro.</summary>
     public IReadOnlyList<UsageCostRecord> Records
     {
         get { lock (_gate) { return [.. _records]; } }
     }
 
-    /// <summary>O ultimo registro publicado, ou nulo se nenhum foi.</summary>
     public UsageCostRecord? Last
     {
         get { lock (_gate) { return _records.Count == 0 ? null : _records[^1]; } }
     }
 
-    /// <summary>Quantas linhas de custo foram publicadas.</summary>
     public int Count
     {
         get { lock (_gate) { return _records.Count; } }
     }
 
-    /// <summary>A soma dos custos <b>medidos</b> — os demais status nao entram na conta.</summary>
     public decimal MeasuredTotalUsd
     {
         get { lock (_gate) { return _records.Where(r => r.IsMeasuredCost).Sum(r => r.CostUsd); } }
     }
 
-    /// <inheritdoc />
     public void Record(UsageCostRecord record)
     {
         ArgumentNullException.ThrowIfNull(record);

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

@@ -3,29 +3,17 @@ using Morph.AiKit.Media;
 
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// Blob em memoria. <b>Conta as gravacoes</b> — e a contagem e o que prova que o
-/// <see cref="MediaStore"/> deduplicou em vez de regravar.
-/// </summary>
-/// <remarks>
-/// Um teste que so confira "o hash e o mesmo" nao distingue dedupe de regravacao: os dois
-/// produzem o mesmo hash. Por isso <see cref="Writes"/> existe.
-/// </remarks>
 public sealed class InMemoryMediaBlobs : IMediaBlobs
 {
     private readonly ConcurrentDictionary<string, byte[]> _files = new(StringComparer.Ordinal);
 
-    /// <summary>Quantas gravacoes de verdade aconteceram.</summary>
     public int Writes { get; private set; }
 
-    /// <summary>Os caminhos gravados.</summary>
     public IReadOnlyCollection<string> Paths => _files.Keys.ToArray();
 
-    /// <inheritdoc />
     public ValueTask<bool> ExistsAsync(string relativePath, CancellationToken cancellationToken)
         => ValueTask.FromResult(_files.ContainsKey(relativePath));
 
-    /// <inheritdoc />
     public ValueTask WriteAsync(string relativePath, ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken)
     {
         Writes++;
@@ -34,25 +22,18 @@ public sealed class InMemoryMediaBlobs : IMediaBlobs
     }
 }
 
-/// <summary>
-/// <see cref="IMediaStore"/> em memoria, para os testes que precisam de UM storage e nao
-/// estao medindo o storage.
-/// </summary>
 public sealed class InMemoryMediaStore : IMediaStore
 {
     private readonly MediaStore _inner;
 
-    /// <summary>Cria o store sobre um blob em memoria proprio.</summary>
     public InMemoryMediaStore()
     {
         Blobs = new InMemoryMediaBlobs();
         _inner = new MediaStore(Blobs);
     }
 
-    /// <summary>O blob por baixo, para conferir gravacoes.</summary>
     public InMemoryMediaBlobs Blobs { get; }
 
-    /// <inheritdoc />
     public ValueTask<MediaStoreEntry> PutAsync(
         ReadOnlyMemory<byte> bytes,
         string mediaType,
@@ -60,25 +41,20 @@ public sealed class InMemoryMediaStore : IMediaStore
         => _inner.PutAsync(bytes, mediaType, cancellationToken);
 }
 
-/// <summary>Acervo de jobs em memoria — a costura com o banco do projeto, em teste.</summary>
 public sealed class InMemoryMediaJobs : IMediaJobRepository
 {
     private readonly ConcurrentDictionary<Guid, MediaJob> _byId = new();
 
-    /// <summary>Quantas gravacoes aconteceram. Prova que o worker persistiu cada passo.</summary>
     public int Saves { get; private set; }
 
-    /// <inheritdoc />
     public ValueTask<MediaJob?> FindByIdempotencyKeyAsync(
         MediaIdempotencyKey key,
         CancellationToken cancellationToken)
         => ValueTask.FromResult(_byId.Values.FirstOrDefault(j => j.IdempotencyKey == key));
 
-    /// <inheritdoc />
     public ValueTask<MediaJob?> FindAsync(MediaJobId id, CancellationToken cancellationToken)
         => ValueTask.FromResult(_byId.TryGetValue(id.Value, out var job) ? job : null);
 
-    /// <inheritdoc />
     public ValueTask SaveAsync(MediaJob job, CancellationToken cancellationToken)
     {
         Saves++;
@@ -87,32 +63,26 @@ public sealed class InMemoryMediaJobs : IMediaJobRepository
     }
 }
 
-/// <summary>Resolvedor de alias de teste: um alias, um binding.</summary>
 public sealed class StubAliasResolver : IMediaAliasResolver
 {
     private readonly Dictionary<string, MediaAliasBinding> _bindings = new(StringComparer.Ordinal);
 
-    /// <summary>Declara um alias.</summary>
     public StubAliasResolver With(MediaAliasBinding binding)
     {
         _bindings[binding.Alias] = binding;
         return this;
     }
 
-    /// <inheritdoc />
     public MediaResult<MediaAliasBinding> Resolve(string alias)
         => _bindings.TryGetValue(alias, out var binding)
             ? MediaResult<MediaAliasBinding>.Ok(binding)
             : MediaResult<MediaAliasBinding>.Fail(MediaErrorCode.InvalidRequest, $"alias '{alias}' nao existe.");
 }
 
-/// <summary>Teto de custo de teste: aceita ate um limite, e registra o que foi pedido.</summary>
 public sealed class CappedBudget(decimal cap) : IMediaBudget
 {
-    /// <summary>Os custos estimados que chegaram, na ordem.</summary>
     public List<decimal> Seen { get; } = [];
 
-    /// <inheritdoc />
     public ValueTask<bool> TryReserveAsync(
         MediaRequest request,
         decimal estimatedCostUsd,
@@ -123,9 +93,7 @@ public sealed class CappedBudget(decimal cap) : IMediaBudget
     }
 }
 
-/// <summary>Relogio parado, para que o carimbo de tempo seja um fato do teste.</summary>
 public sealed class FixedMediaClock(DateTimeOffset now) : IMediaClock
 {
-    /// <inheritdoc />
     public DateTimeOffset UtcNow { get; } = now;
 }

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

@@ -4,33 +4,10 @@ using Xunit;
 
 namespace Morph.AiKit.Tests;
 
-/// <summary>
-/// O canario da REGRA DURA de <c>ai-agents/media-pipeline.md</c>:
-/// <b>nunca gere midia dentro de um turno de conversa</b>.
-/// </summary>
-/// <remarks>
-/// <para>
-/// A regra nao e presa por prosa — e presa por ACESSIBILIDADE. O tipo que produz bytes e
-/// <c>internal</c> ao assembly; um handler de mensagem no projeto consumidor nao consegue
-/// nomea-lo, e o codigo nao compila. Este arquivo e o que mantem essa afirmacao verdadeira
-/// depois de qualquer refatoracao.
-/// </para>
-/// <para>
-/// <b>A mutacao foi rodada</b> (T10): tornar <c>IMediaProvider</c> publico derruba
-/// <see cref="TheTypeThatProducesBytesIsNotPublic"/> nomeando o defeito. Um canario que
-/// ninguem viu morder pode ser o canario errado.
-/// </para>
-/// <para>
-/// A leitura e por <b>reflexao sobre a assembly</b>, e nao por <c>grep</c> no fonte: o
-/// modificador que importa e o que sobreviveu a compilacao. Um <c>grep</c> por
-/// <c>"internal interface"</c> mediria o texto, e o texto e uma copia do objeto.
-/// </para>
-/// </remarks>
 public sealed class MediaAccessibilityTests
 {
     private static readonly Assembly Kit = typeof(MediaJob).Assembly;
 
-    /// <summary>Os nomes que produzem, ou orquestram a producao de, bytes pagos.</summary>
     public static TheoryData<string> ByteProducingTypes() =>
     [
         "Morph.AiKit.Media.IMediaProvider",
@@ -44,10 +21,6 @@ public sealed class MediaAccessibilityTests
         "Morph.AiKit.Media.MediaArtifact",
     ];
 
-    /// <summary>
-    /// A asserção literal do plano:
-    /// <c>typeof(MediaJob).Assembly.GetType("Morph.AiKit.Media.IMediaProvider")!.IsPublic == false</c>.
-    /// </summary>
     [Fact]
     public void TheTypeThatProducesBytesIsNotPublic()
     {
@@ -61,7 +34,6 @@ public sealed class MediaAccessibilityTests
             "compilador. E prosa outra vez.");
     }
 
-    /// <summary>Uma rodada por tipo: nenhum deles pode vazar para fora do assembly.</summary>
     [Theory]
     [MemberData(nameof(ByteProducingTypes))]
     public void NoByteProducingTypeIsVisibleOutsideTheAssembly(string fullName)
@@ -73,11 +45,6 @@ public sealed class MediaAccessibilityTests
         Assert.False(type.IsNestedPublic, $"{fullName} nao pode ser aninhado publico.");
     }
 
-    /// <summary>
-    /// O outro lado da mesma afirmacao: a superficie publica EXISTE, e ela nunca devolve
-    /// bytes. Sem esta metade, tornar tudo internal passaria — e um subsistema inalcancavel
-    /// tambem esta errado.
-    /// </summary>
     [Fact]
     public void ThePublicEntryPointExistsAndNeverReturnsBytes()
     {
@@ -101,10 +68,6 @@ public sealed class MediaAccessibilityTests
         }
     }
 
-    /// <summary>
-    /// <see cref="MediaArtifact"/> — o registro que CARREGA os bytes — nao pode aparecer em
-    /// nenhuma assinatura publica do subsistema. Ele existe entre dois tipos internal.
-    /// </summary>
     [Fact]
     public void TheArtifactNeverAppearsInAPublicSignature()
     {

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