@polymorphism-tech/morph-spec 8.37.1 → 8.40.0

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

@@ -4,9 +4,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests.Evals;
 
-/// <summary>
-/// O cliente que RECUSA: a peca de que depende "o eval roda no CI sem credencial".
-/// </summary>
 public sealed class OfflineChatClientTests
 {
     private static OfflineChatClient Build(Func<string>? scenario = null)
@@ -19,13 +16,9 @@ public sealed class OfflineChatClientTests
 
         var metadata = Assert.IsType<ChatClientMetadata>(client.GetService(typeof(ChatClientMetadata)));
 
-        // Estes DOIS campos entram na chave de cache. Se divergissem do run que gravou, todo
-        // cenario daria miss e a cache quente seria indistinguivel de uma cache vazia.
         Assert.Equal("morph-fake", metadata.ProviderName);
         Assert.Equal("modelo-exemplar", metadata.DefaultModelId);
 
-        // E o endpoint e NULO de proposito: ele nao entra na chave (medido na v10.9.0), e um
-        // cliente que nunca liga para lugar nenhum nao deve anunciar um destino.
         Assert.Null(metadata.ProviderUri);
     }
 
@@ -59,9 +52,7 @@ public sealed class OfflineChatClientTests
     [Fact]
     public void TheScenarioNameIsReadAtCALLTIME_NotCaptured()
     {
-        // Um fixture roda N cenarios com o MESMO cliente. Se o nome fosse capturado na
-        // construcao, toda mensagem de miss nomearia o primeiro cenario e mandaria o leitor
-        // investigar o arquivo errado.
+        // O fixture roda N cenarios com o mesmo cliente: o nome do cenario nao pode ser capturado na construcao.
         var current = "primeiro";
         using var client = Build(() => current);
 

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

@@ -3,30 +3,6 @@ using Microsoft.Extensions.AI;
 
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// <see cref="IChatClient"/> roteirizado: a costura que dispensa rede e chave de API na
-/// suite inteira do kit.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Por que ele e o coracao da historia de teste:</b> o unico ponto em que o kit toca um
-/// provider e um <see cref="IChatClient"/>. Trocando esse ponto por uma fila de respostas
-/// escritas a mao, TODO o resto — <c>ModelRegistry</c>, <c>AgentFactory</c>,
-/// <c>UsageCostMiddleware</c>, <c>ConversationStore</c> — passa a ser testavel sem socket,
-/// sem segredo e sem flake. Nenhum tipo desta pasta abre cliente HTTP nem le variavel de
-/// ambiente — o canario estrutural disso e um grep sobre <c>tests/</c> (chave de provider,
-/// leitura de ambiente, cliente HTTP) que precisa voltar VAZIO, e o canario de
-/// comportamento e
-/// <c>FakeChatClientTests.TheWholeSeamAnswersFromMemoryAloneWithNoConfigurationAndNoConnection</c>.
-/// </para>
-/// <para>
-/// <b>Chamada nao roteirizada e defeito de teste, nao "comportamento padrao".</b> Esgotada
-/// a fila, o fake lanca com a contagem exata de chamadas. Devolver uma resposta vazia
-/// silenciosamente faria um teste passar por engano — que e a unica coisa pior do que um
-/// teste falhando.
-/// </para>
-/// <para>Seguro para uso concorrente: fila, contadores e capturas vivem sob um lock unico.</para>
-/// </remarks>
 public sealed class FakeChatClient : IChatClient
 {
     private readonly Lock _gate = new();
@@ -34,12 +10,10 @@ public sealed class FakeChatClient : IChatClient
     private readonly List<ChatOptions?> _receivedOptions = [];
     private readonly List<IReadOnlyList<ChatMessage>> _receivedMessages = [];
 
-    /// <summary>Cria um fake com a fila vazia. Enfileire antes de usar.</summary>
     public FakeChatClient()
     {
     }
 
-    /// <summary>Cria um fake ja roteirizado com as respostas dadas, na ordem.</summary>
     public FakeChatClient(params ChatResponse[] scripted)
     {
         ArgumentNullException.ThrowIfNull(scripted);
@@ -50,7 +24,6 @@ public sealed class FakeChatClient : IChatClient
         }
     }
 
-    /// <summary>Atalho: uma resposta de assistente por texto, na ordem dada.</summary>
     public static FakeChatClient Scripted(params string[] texts)
     {
         ArgumentNullException.ThrowIfNull(texts);
@@ -64,51 +37,35 @@ public sealed class FakeChatClient : IChatClient
         return client;
     }
 
-    /// <summary>Quantas vezes o cliente foi invocado (streaming incluso).</summary>
     public int CallCount { get; private set; }
 
-    /// <summary>
-    /// O <c>ProviderName</c> anunciado no <see cref="ChatClientMetadata"/>. Configuravel
-    /// porque ele ENTRA NA CHAVE da cache de eval: a arvore que este fake grava so e legivel
-    /// depois pelo <c>OfflineChatClient</c> se os dois se apresentarem com a mesma
-    /// identidade. Default preservado ("fake"): quem nao usa eval nao muda de comportamento.
-    /// </summary>
+    // ProviderName e DefaultModelId entram na chave da cache de eval: o OfflineChatClient precisa anunciar os mesmos.
     public string MetadataProviderName { get; init; } = "fake";
 
-    /// <summary>
-    /// O <c>DefaultModelId</c> anunciado no <see cref="ChatClientMetadata"/>. Tambem entra na
-    /// chave de cache. Nulo por default, como antes.
-    /// </summary>
     public string? MetadataDefaultModelId { get; init; }
 
-    /// <summary>Se <see cref="Dispose"/> ja foi chamado — usado para provar ownership de cache.</summary>
     public bool IsDisposed { get; private set; }
 
-    /// <summary>As <see cref="ChatOptions"/> recebidas, uma entrada por chamada, na ordem.</summary>
     public IReadOnlyList<ChatOptions?> ReceivedOptions
     {
         get { lock (_gate) { return [.. _receivedOptions]; } }
     }
 
-    /// <summary>As mensagens recebidas, uma entrada por chamada, na ordem.</summary>
     public IReadOnlyList<IReadOnlyList<ChatMessage>> ReceivedMessages
     {
         get { lock (_gate) { return [.. _receivedMessages]; } }
     }
 
-    /// <summary>As opcoes da ultima chamada, ou nulo se nunca foi chamado.</summary>
     public ChatOptions? LastOptions
     {
         get { lock (_gate) { return _receivedOptions.Count == 0 ? null : _receivedOptions[^1]; } }
     }
 
-    /// <summary>As mensagens da ultima chamada, ou nulo se nunca foi chamado.</summary>
     public IReadOnlyList<ChatMessage>? LastMessages
     {
         get { lock (_gate) { return _receivedMessages.Count == 0 ? null : _receivedMessages[^1]; } }
     }
 
-    /// <summary>Enfileira uma resposta ja montada. Devolve o proprio fake, para encadear.</summary>
     public FakeChatClient Enqueue(ChatResponse response)
     {
         ArgumentNullException.ThrowIfNull(response);
@@ -121,18 +78,9 @@ public sealed class FakeChatClient : IChatClient
         return this;
     }
 
-    /// <summary>
-    /// Enfileira uma resposta de assistente com o texto dado e, opcionalmente, um
-    /// <see cref="UsageDetails"/> controlado — e assim que o teste do
-    /// <c>UsageCostMiddleware</c> (T11) verifica tarifa sem rede.
-    /// </summary>
     public FakeChatClient EnqueueText(string text, UsageDetails? usage = null)
         => Enqueue(new ChatResponse(new ChatMessage(ChatRole.Assistant, text)) { Usage = usage });
 
-    /// <summary>
-    /// Enfileira uma resposta com contagem de tokens conhecida. Atalho para o caso mais
-    /// comum de teste de custo.
-    /// </summary>
     public FakeChatClient EnqueueTextWithUsage(
         string text,
         long inputTokens,
@@ -148,7 +96,6 @@ public sealed class FakeChatClient : IChatClient
                 CachedInputTokenCount = cachedInputTokens,
             });
 
-    /// <inheritdoc />
     public Task<ChatResponse> GetResponseAsync(
         IEnumerable<ChatMessage> messages,
         ChatOptions? options = null,
@@ -160,7 +107,6 @@ public sealed class FakeChatClient : IChatClient
         return Task.FromResult(Record(messages, options));
     }
 
-    /// <inheritdoc />
     public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
         IEnumerable<ChatMessage> messages,
         ChatOptions? options = null,
@@ -180,7 +126,6 @@ public sealed class FakeChatClient : IChatClient
         await Task.CompletedTask.ConfigureAwait(false);
     }
 
-    /// <inheritdoc />
     public object? GetService(Type serviceType, object? serviceKey = null)
     {
         ArgumentNullException.ThrowIfNull(serviceType);
@@ -198,7 +143,6 @@ public sealed class FakeChatClient : IChatClient
         return serviceType.IsInstanceOfType(this) ? this : null;
     }
 
-    /// <inheritdoc />
     public void Dispose() => IsDisposed = true;
 
     private ChatResponse Record(IEnumerable<ChatMessage> messages, ChatOptions? options)

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

@@ -4,17 +4,6 @@ using Xunit;
 
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// Canarios da costura de teste (T9). Um fake so vale se ele proprio for testado: um fake
-/// que devolve na ordem errada, ou que engole as <see cref="ChatOptions"/> recebidas,
-/// transforma todo teste que depende dele num teste que nao mede nada.
-/// </summary>
-/// <remarks>
-/// Todo <c>await</c> passa <c>TestContext.Current.CancellationToken</c> porque o analisador
-/// xUnit1051 cobra isso e <c>TreatWarningsAsErrors</c> transforma a cobranca em build
-/// vermelho. Nao ha <c>#pragma</c> aqui: a regra e boa (teste cancelavel) e o custo e um
-/// argumento.
-/// </remarks>
 public sealed class FakeChatClientTests
 {
     [Fact]
@@ -114,8 +103,6 @@ public sealed class FakeChatClientTests
     [Fact]
     public async Task UsageIsControlledByTheTestAndSurvivesTheRoundTrip()
     {
-        // E assim que a T11 vai verificar tarifa sem rede: Usage conhecido entra,
-        // Usage conhecido sai.
         using var client = new FakeChatClient();
         client.EnqueueTextWithUsage("ok", inputTokens: 1_000, outputTokens: 250, cachedInputTokens: 400);
 
@@ -155,17 +142,6 @@ public sealed class FakeChatClientTests
     [Fact]
     public async Task TheWholeSeamAnswersFromMemoryAloneWithNoConfigurationAndNoConnection()
     {
-        // O caminho inteiro que os consumidores usam — documento JSON, registry, fabrica,
-        // cliente — exercitado com nada alem de objetos em memoria: nenhuma chave, nenhum
-        // arquivo, nenhum socket. E este o teste a apontar quando alguem perguntar "como o
-        // kit testa IA sem provider".
-        //
-        // A propriedade "passa sem chave de provider no ambiente" NAO e afirmada aqui por
-        // codigo: afirma-la exigiria ler variavel de ambiente, e um teste que faz isso
-        // derruba o canario estrutural da T9 — o grep sobre tests/ (chave de provider,
-        // leitura de ambiente, cliente HTTP) tem de voltar VAZIO. A propriedade e
-        // DEMONSTRADA rodando a suite com o ambiente esvaziado, o que cobre os 50 testes
-        // em vez de um.
         var document = """
             {
               "version": "2.0",
@@ -195,8 +171,6 @@ public sealed class FakeChatClientTests
     [Fact]
     public async Task ConcurrentCallersNeverLoseACallOrACapture()
     {
-        // ConversationStore (T13) exercita duas sessoes sobre a MESMA instancia. Se o fake
-        // perdesse chamada sob concorrencia, aquele teste mediria o fake, nao o store.
         using var client = new FakeChatClient();
         for (var i = 0; i < 50; i++)
         {

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

@@ -1,30 +1,12 @@
 namespace Morph.AiKit.Tests.Fakes;
 
-/// <summary>
-/// <see cref="TimeProvider"/> controlado pelo teste: o relogio so anda quando o teste manda.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Existe <b>escrito a mao, em 20 linhas</b>, e nao via
-/// <c>Microsoft.Extensions.TimeProvider.Testing</c>, por uma razao de contrato desta
-/// feature: toda versao de pacote vem de <c>framework/ai-pin.json</c>, e aquele pacote nao
-/// esta no pin. Acrescenta-lo seria uma versao decidida fora do pin — exatamente a segunda
-/// verdade que o kit existe para impedir. O achado esta registrado no relatorio da T11.
-/// </para>
-/// <para>
-/// So o necessario esta implementado: <see cref="GetUtcNow"/> e o avanco manual. Timers nao
-/// sao usados por nenhum tipo do kit; herdar o comportamento base e mais honesto que
-/// simular um agendador que ninguem exercita.
-/// </para>
-/// </remarks>
+// Escrito a mao: Microsoft.Extensions.TimeProvider.Testing nao esta no pin (framework/ai-pin.json).
 public sealed class FakeClock(DateTimeOffset start) : TimeProvider
 {
     private DateTimeOffset _now = start;
 
-    /// <inheritdoc />
     public override DateTimeOffset GetUtcNow() => _now;
 
-    /// <summary>Avanca o relogio. Rejeita andar para tras: o tempo do teste e monotono.</summary>
     public void Advance(TimeSpan delta)
     {
         ArgumentOutOfRangeException.ThrowIfLessThan(delta, TimeSpan.Zero);

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