@polymorphism-tech/morph-spec 7.7.2 → 7.8.0

package/framework/templates/CLAUDE.md.core.template

@@ -6,7 +6,7 @@
 
 VSA + .NET 10 + EF Core + Neon (Postgres) + Microsoft Agent Framework + Next.js (App Router) + Tailwind + Framer Motion + Shadcn + Hangfire (quando necessário).
 
-Padrões proibidos por padrão: `Guid.NewGuid()` (use `Guid.CreateVersion7()`), classes não-sealed sem justificativa, exceptions como fluxo de controle, camada de Service/Manager entre handler e dados, SQL cru sem justificativa. Acesso a dados é híbrido: `IRepository<T>` + `IUnitOfWork` para CRUD; `DbContext` direto no slice para queries específicas.
+Padrões proibidos por padrão: `Guid.NewGuid()` (use `Guid.CreateVersion7()`), classes não-sealed sem justificativa, exceptions como fluxo de controle, camada de Service/Manager entre handler e dados, repository genérico (`IRepository<T>`/`IUnitOfWork`), SQL cru sem justificativa. Acesso a dados: `ApplicationDbContext` direto no slice (`DbSet<T>` já é repository, `DbContext` já é unit of work); para concorrência ou SQL específico, store dedicado hand-written com justificativa em `decisions.md`.
 
 ## Harness
 

package/framework/templates/README.md

@@ -30,7 +30,6 @@ framework/templates/
 │   ├── dotnet/
 │   │   ├── backend/
 │   │   │   ├── service.cs          # Service layer
-│   │   │   ├── repository.cs       # Data access layer
 │   │   │   └── test.cs             # Unit tests
 │   │   ├── database/
 │   │   │   └── migration.cs        # EF Core migrations

package/framework/templates/REGISTRY.json

@@ -256,27 +256,6 @@
       "technology": null,
       "validatePlaceholders": true
     },
-    {
-      "id": "dotnet-backend-repository",
-      "kind": "template",
-      "name": ".NET Repository Class",
-      "path": "code/dotnet/backend/repository.cs",
-      "location": "framework",
-      "category": "code",
-      "phase": "implement",
-      "required": false,
-      "description": "C# repository class template with EF Core patterns",
-      "outputName": "{FeatureName}Repository.cs",
-      "placeholders": [],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "technology": "dotnet",
-      "applicableStacks": [
-        "nextjs-neon"
-      ],
-      "validatePlaceholders": true
-    },
     {
       "id": "dotnet-backend-test",
       "kind": "template",

package/framework/templates/code/dotnet/abstractions/handler.cs

@@ -1,6 +1,3 @@
-using Azure.Core;
-
-
 namespace {{pascalCase PROJECT_NAME}}.Abstractions
 {
     public interface IHandler<in TRequest, TResponse>

package/framework/templates/code/dotnet/constants/api-tags.cs

@@ -2,5 +2,5 @@ namespace {{pascalCase PROJECT_NAME}}.Constants;
 
 public static class ApiTags
 {
-    public const string {{pascalCase FEATURE_NAME}} = "{{pascalCase FEATURE_NAME}}";
+    public const string {{pascalCase FEATURE_NAME}}s = "{{kebabCase FEATURE_NAME}}s";
 }

package/framework/templates/code/dotnet/contracts/contracts-vsa.cs

@@ -178,8 +178,8 @@ public static class {{pascalCase FEATURE_NAME}}Errors
 namespace {{NAMESPACE}}.Features.{{pascalCase FEATURE_NAME}}Feature.Create{{pascalCase FEATURE_NAME}};
 
 using {{NAMESPACE}}.Abstractions;
+using {{NAMESPACE}}.Database;
 using {{NAMESPACE}}.Entities;
-using {{NAMESPACE}}.Repository;
 
 // TODO: adicionar todos os campos do request (campos obrigatórios para criação)
 public sealed record Create{{pascalCase FEATURE_NAME}}Request(/* string Name, decimal Price, ... */);
@@ -188,8 +188,7 @@ public sealed record Create{{pascalCase FEATURE_NAME}}Request(/* string Name, de
 public sealed record Create{{pascalCase FEATURE_NAME}}Response(Guid Id /* , string Name, ... */);
 
 public sealed class Create{{pascalCase FEATURE_NAME}}Handler(
-    IRepository<{{pascalCase FEATURE_NAME}}> _repo,
-    IUnitOfWork _unitOfWork) : IHandler<Create{{pascalCase FEATURE_NAME}}Request, Result<Create{{pascalCase FEATURE_NAME}}Response>>
+    ApplicationDbContext _db) : IHandler<Create{{pascalCase FEATURE_NAME}}Request, Result<Create{{pascalCase FEATURE_NAME}}Response>>
 {
     public async Task<Result<Create{{pascalCase FEATURE_NAME}}Response>> HandleAsync(
         Create{{pascalCase FEATURE_NAME}}Request command, CancellationToken cancellationToken)
@@ -202,8 +201,8 @@ public sealed class Create{{pascalCase FEATURE_NAME}}Handler(
             // Price = command.Price,
         };
 
-        await _repo.AddAsync(entity, cancellationToken);
-        await _unitOfWork.CommitAsync(cancellationToken);
+        _db.Set<{{pascalCase FEATURE_NAME}}>().Add(entity);
+        await _db.SaveChangesAsync(cancellationToken);
 
         return Result.Success(new Create{{pascalCase FEATURE_NAME}}Response(entity.Id /* , entity.Name, ... */));
     }

package/framework/templates/code/dotnet/feature/handler.cs.hbs

@@ -1,24 +1,23 @@
-namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
-
-using {{pascalCase PROJECT_NAME}}.Abstractions;
-using {{pascalCase PROJECT_NAME}}.Entities;
-using {{pascalCase PROJECT_NAME}}.Repository;
-
-public sealed class {{pascalCase SLICE_NAME}}Handler(
-    IRepository<{{pascalCase FEATURE_NAME}}> _repository,
-    IUnitOfWork _unitOfWork) : IHandler<{{pascalCase SLICE_NAME}}Request, Result<{{pascalCase SLICE_NAME}}Response>>
-{
-    public async Task<Result<{{pascalCase SLICE_NAME}}Response>> HandleAsync({{pascalCase SLICE_NAME}}Request command, CancellationToken cancellationToken)
-    {
-        var entity = new {{pascalCase FEATURE_NAME}}
-        {
-            Id = Guid.CreateVersion7(),
-            // TODO: Map command properties to entity
-        };
-
-        await _repository.AddAsync(entity, cancellationToken);
-        await _unitOfWork.CommitAsync(cancellationToken);
-
-        return Result.Success(new {{pascalCase SLICE_NAME}}Response(entity.Id));
-    }
-}
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
+
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+using {{pascalCase PROJECT_NAME}}.Database;
+using {{pascalCase PROJECT_NAME}}.Entities;
+
+public sealed class {{pascalCase SLICE_NAME}}Handler(
+    ApplicationDbContext _db) : IHandler<{{pascalCase SLICE_NAME}}Request, Result<{{pascalCase SLICE_NAME}}Response>>
+{
+    public async Task<Result<{{pascalCase SLICE_NAME}}Response>> HandleAsync({{pascalCase SLICE_NAME}}Request command, CancellationToken cancellationToken)
+    {
+        var entity = new {{pascalCase FEATURE_NAME}}
+        {
+            Id = Guid.CreateVersion7(),
+            // TODO: Map command properties to entity
+        };
+
+        _db.Set<{{pascalCase FEATURE_NAME}}>().Add(entity);
+        await _db.SaveChangesAsync(cancellationToken);
+
+        return Result.Success(new {{pascalCase SLICE_NAME}}Response(entity.Id));
+    }
+}

package/framework/templates/code/dotnet/jobs/job.cs

@@ -1,22 +1,22 @@
 // ============================================================
-// HANGFIRE JOB TEMPLATE (VSA Pattern — Repository + UnitOfWork)
+// HANGFIRE JOB TEMPLATE (VSA Pattern — ApplicationDbContext direto)
 // Generated by MORPH Framework
 // ============================================================
 
 using Hangfire;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using {{pascalCase PROJECT_NAME}}.Repository;
+using {{pascalCase PROJECT_NAME}}.Database;
 
 namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}.Jobs;
 
 /// <summary>
 /// Background job for processing {{pascalCase FEATURE_NAME}}.
 /// Uses Hangfire for scheduling and retry handling.
-/// Injects IRepository + IUnitOfWork directly (no service layer).
+/// Injects ApplicationDbContext directly (no service layer, no generic repository).
 /// </summary>
 public class {{pascalCase FEATURE_NAME}}ProcessorJob(
-    IRepository<{{pascalCase FEATURE_NAME}}> repository,
-    IUnitOfWork unitOfWork,
+    ApplicationDbContext db,
     I{{pascalCase FEATURE_NAME}}AnalyzerAgent analyzer,
     ILogger<{{pascalCase FEATURE_NAME}}ProcessorJob> logger) : I{{pascalCase FEATURE_NAME}}ProcessorJob
 {
@@ -34,8 +34,8 @@ public class {{pascalCase FEATURE_NAME}}ProcessorJob(
 
         try
         {
-            // Get the entity directly from the repository
-            var entity = await repository.GetByIdAsync(id, cancellationToken);
+            // Get the entity directly from the DbSet
+            var entity = await db.Set<{{pascalCase FEATURE_NAME}}>().FindAsync(new object[] { id }, cancellationToken);
             if (entity is null)
             {
                 logger.LogWarning("{{pascalCase FEATURE_NAME}} with ID {Id} not found, skipping", id);
@@ -57,10 +57,9 @@ public class {{pascalCase FEATURE_NAME}}ProcessorJob(
                 "{{pascalCase FEATURE_NAME}} {Id} analyzed. Confidence: {Confidence:P0}",
                 id, analysis.ConfidenceScore);
 
-            // Update entity directly via repository
+            // Update the tracked entity and persist
             entity.MarkAsCompleted(analysis);
-            await repository.UpdateAsync(entity, cancellationToken);
-            await unitOfWork.CommitAsync(cancellationToken);
+            await db.SaveChangesAsync(cancellationToken);
 
             logger.LogInformation("Completed {{pascalCase FEATURE_NAME}} processing for ID {Id}", id);
         }
@@ -104,10 +103,10 @@ public class {{pascalCase FEATURE_NAME}}ProcessorJob(
 
 /// <summary>
 /// Batch job for processing multiple {{pascalCase FEATURE_NAME}}s.
-/// Queries pending items via IRepository and enqueues individual jobs.
+/// Queries pending items via LINQ on the DbSet and enqueues individual jobs.
 /// </summary>
 public class {{pascalCase FEATURE_NAME}}BatchProcessorJob(
-    IRepository<{{pascalCase FEATURE_NAME}}> repository,
+    ApplicationDbContext db,
     ILogger<{{pascalCase FEATURE_NAME}}BatchProcessorJob> logger)
 {
     /// <summary>
@@ -120,8 +119,9 @@ public class {{pascalCase FEATURE_NAME}}BatchProcessorJob(
     {
         logger.LogInformation("Starting batch processing for pending {{pascalCase FEATURE_NAME}}s");
 
-        var allItems = await repository.GetAllAsync(cancellationToken);
-        var pending = allItems.Where(x => x.Status == {{pascalCase FEATURE_NAME}}Status.Pending).ToList();
+        var pending = await db.Set<{{pascalCase FEATURE_NAME}}>()
+            .Where(x => x.Status == {{pascalCase FEATURE_NAME}}Status.Pending)
+            .ToListAsync(cancellationToken);
 
         logger.LogInformation("Found {Count} pending {{pascalCase FEATURE_NAME}}s to process", pending.Count);
 
@@ -162,7 +162,7 @@ public class {{pascalCase FEATURE_NAME}}BatchProcessorJob(
 //     options.WorkerCount = Environment.ProcessorCount * 2;
 // });
 //
-// // Register jobs (repository + unit of work already registered)
+// // Register jobs (ApplicationDbContext already registered via AddDbContext)
 // builder.Services.AddScoped<I{{pascalCase FEATURE_NAME}}ProcessorJob, {{pascalCase FEATURE_NAME}}ProcessorJob>();
 // builder.Services.AddScoped<{{pascalCase FEATURE_NAME}}BatchProcessorJob>();
 //

package/framework/templates/code/dotnet/test.cs

@@ -6,9 +6,10 @@
 using FluentAssertions;
 using FluentValidation;
 using FluentValidation.Results;
-using Microsoft.Extensions.Logging;
-using NSubstitute;
-using {{pascalCase PROJECT_NAME}}.Repository;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using {{pascalCase PROJECT_NAME}}.Database;
+using {{pascalCase PROJECT_NAME}}.Entities;
 using Xunit;
 
 namespace {{pascalCase PROJECT_NAME}}.Tests.Unit.Features.{{pascalCase FEATURE_NAME}};
@@ -19,19 +20,31 @@ namespace {{pascalCase PROJECT_NAME}}.Tests.Unit.Features.{{pascalCase FEATURE_N
 
 /// <summary>
 /// Unit tests for {{pascalCase FEATURE_NAME}} handlers.
-/// Tests handlers directly with mocked IRepository and IUnitOfWork.
+/// Tests handlers directly against a real ApplicationDbContext backed by
+/// in-memory SQLite (no mocks — DbSet is the repository, DbContext is the unit of work).
 /// </summary>
-public class {{pascalCase FEATURE_NAME}}HandlerTests
+public class {{pascalCase FEATURE_NAME}}HandlerTests : IDisposable
 {
-    private readonly IRepository<{{pascalCase FEATURE_NAME}}> _repository;
-    private readonly IUnitOfWork _unitOfWork;
-    private readonly ILogger<Create{{pascalCase FEATURE_NAME}}.Handler> _logger;
+    private readonly SqliteConnection _connection;
+    private readonly ApplicationDbContext _db;
 
     public {{pascalCase FEATURE_NAME}}HandlerTests()
     {
-        _repository = Substitute.For<IRepository<{{pascalCase FEATURE_NAME}}>>();
-        _unitOfWork = Substitute.For<IUnitOfWork>();
-        _logger = Substitute.For<ILogger<Create{{pascalCase FEATURE_NAME}}.Handler>>();
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
+
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseSqlite(_connection)
+            .Options;
+
+        _db = new ApplicationDbContext(options);
+        _db.Database.EnsureCreated();
+    }
+
+    public void Dispose()
+    {
+        _db.Dispose();
+        _connection.Dispose();
     }
 
     #region Create Handler Tests
@@ -40,14 +53,8 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
     public async Task Create_HandleAsync_WithValidCommand_ReturnsSuccessResult()
     {
         // Arrange
-        var command = new Create{{pascalCase FEATURE_NAME}}.Command("Test {{pascalCase FEATURE_NAME}}");
-        var handler = new Create{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork, _logger);
-
-        _repository.AddAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => callInfo.Arg<{{pascalCase FEATURE_NAME}}>());
-
-        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
-            .Returns(1);
+        var command = new Create{{pascalCase FEATURE_NAME}}Request("Test {{pascalCase FEATURE_NAME}}");
+        var handler = new Create{{pascalCase FEATURE_NAME}}Handler(_db);
 
         // Act
         var result = await handler.HandleAsync(command, CancellationToken.None);
@@ -55,31 +62,9 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
         // Assert
         result.IsSuccess.Should().BeTrue();
         result.Value.Should().NotBeNull();
-        result.Value.Name.Should().Be("Test {{pascalCase FEATURE_NAME}}");
 
-        await _repository.Received(1).AddAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>());
-        await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
-    }
-
-    [Fact]
-    public async Task Create_HandleAsync_WhenCommitFails_ReturnsFailureResult()
-    {
-        // Arrange
-        var command = new Create{{pascalCase FEATURE_NAME}}.Command("Test {{pascalCase FEATURE_NAME}}");
-        var handler = new Create{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork, _logger);
-
-        _repository.AddAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => callInfo.Arg<{{pascalCase FEATURE_NAME}}>());
-
-        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
-            .ThrowsAsync(new InvalidOperationException("Database error"));
-
-        // Act
-        var act = async () => await handler.HandleAsync(command, CancellationToken.None);
-
-        // Assert
-        await act.Should().ThrowAsync<InvalidOperationException>()
-            .WithMessage("Database error");
+        var persisted = await _db.Set<{{pascalCase FEATURE_NAME}}>().SingleAsync();
+        persisted.Name.Should().Be("Test {{pascalCase FEATURE_NAME}}");
     }
 
     #endregion
@@ -90,12 +75,12 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
     public async Task GetById_HandleAsync_WithValidId_ReturnsSuccessResult()
     {
         // Arrange
-        var query = new GetById{{pascalCase FEATURE_NAME}}.Query(1);
-        var entity = CreateTestEntity(1, "Test {{pascalCase FEATURE_NAME}}");
-        var handler = new GetById{{pascalCase FEATURE_NAME}}.Handler(_repository);
+        var entity = CreateTestEntity("Test {{pascalCase FEATURE_NAME}}");
+        _db.Set<{{pascalCase FEATURE_NAME}}>().Add(entity);
+        await _db.SaveChangesAsync();
 
-        _repository.GetByIdAsync(1, Arg.Any<CancellationToken>())
-            .Returns(entity);
+        var query = new Get{{pascalCase FEATURE_NAME}}ByIdRequest(entity.Id);
+        var handler = new Get{{pascalCase FEATURE_NAME}}ByIdHandler(_db);
 
         // Act
         var result = await handler.HandleAsync(query, CancellationToken.None);
@@ -110,11 +95,8 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
     public async Task GetById_HandleAsync_WithInvalidId_ReturnsFailureResult()
     {
         // Arrange
-        var query = new GetById{{pascalCase FEATURE_NAME}}.Query(999);
-        var handler = new GetById{{pascalCase FEATURE_NAME}}.Handler(_repository);
-
-        _repository.GetByIdAsync(999, Arg.Any<CancellationToken>())
-            .Returns(({{pascalCase FEATURE_NAME}}?)null);
+        var query = new Get{{pascalCase FEATURE_NAME}}ByIdRequest(Guid.CreateVersion7());
+        var handler = new Get{{pascalCase FEATURE_NAME}}ByIdHandler(_db);
 
         // Act
         var result = await handler.HandleAsync(query, CancellationToken.None);
@@ -131,15 +113,12 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
     public async Task Update_HandleAsync_WithValidCommand_ReturnsSuccessResult()
     {
         // Arrange
-        var command = new Update{{pascalCase FEATURE_NAME}}.Command(1, "Updated Name");
-        var entity = CreateTestEntity(1, "Original Name");
-        var handler = new Update{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
-
-        _repository.GetByIdAsync(1, Arg.Any<CancellationToken>())
-            .Returns(entity);
+        var entity = CreateTestEntity("Original Name");
+        _db.Set<{{pascalCase FEATURE_NAME}}>().Add(entity);
+        await _db.SaveChangesAsync();
 
-        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
-            .Returns(1);
+        var command = new Update{{pascalCase FEATURE_NAME}}Request(entity.Id, "Updated Name");
+        var handler = new Update{{pascalCase FEATURE_NAME}}Handler(_db);
 
         // Act
         var result = await handler.HandleAsync(command, CancellationToken.None);
@@ -147,26 +126,22 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
         // Assert
         result.IsSuccess.Should().BeTrue();
 
-        await _repository.Received(1).UpdateAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>());
-        await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
+        var persisted = await _db.Set<{{pascalCase FEATURE_NAME}}>().SingleAsync(x => x.Id == entity.Id);
+        persisted.Name.Should().Be("Updated Name");
     }
 
     [Fact]
     public async Task Update_HandleAsync_WithNonExistentId_ReturnsFailureResult()
     {
         // Arrange
-        var command = new Update{{pascalCase FEATURE_NAME}}.Command(999, "Updated");
-        var handler = new Update{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
-
-        _repository.GetByIdAsync(999, Arg.Any<CancellationToken>())
-            .Returns(({{pascalCase FEATURE_NAME}}?)null);
+        var command = new Update{{pascalCase FEATURE_NAME}}Request(Guid.CreateVersion7(), "Updated");
+        var handler = new Update{{pascalCase FEATURE_NAME}}Handler(_db);
 
         // Act
         var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
         result.IsSuccess.Should().BeFalse();
-        await _unitOfWork.DidNotReceive().CommitAsync(Arg.Any<CancellationToken>());
     }
 
     #endregion
@@ -177,15 +152,12 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
     public async Task Delete_HandleAsync_WithValidId_ReturnsSuccessResult()
     {
         // Arrange
-        var command = new Delete{{pascalCase FEATURE_NAME}}.Command(1);
-        var entity = CreateTestEntity(1, "To Delete");
-        var handler = new Delete{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
+        var entity = CreateTestEntity("To Delete");
+        _db.Set<{{pascalCase FEATURE_NAME}}>().Add(entity);
+        await _db.SaveChangesAsync();
 
-        _repository.GetByIdAsync(1, Arg.Any<CancellationToken>())
-            .Returns(entity);
-
-        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
-            .Returns(1);
+        var command = new Delete{{pascalCase FEATURE_NAME}}Request(entity.Id);
+        var handler = new Delete{{pascalCase FEATURE_NAME}}Handler(_db);
 
         // Act
         var result = await handler.HandleAsync(command, CancellationToken.None);
@@ -193,36 +165,35 @@ public class {{pascalCase FEATURE_NAME}}HandlerTests
         // Assert
         result.IsSuccess.Should().BeTrue();
 
-        await _repository.Received(1).DeleteAsync(entity, Arg.Any<CancellationToken>());
-        await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
+        (await _db.Set<{{pascalCase FEATURE_NAME}}>().AnyAsync(x => x.Id == entity.Id)).Should().BeFalse();
     }
 
     [Fact]
     public async Task Delete_HandleAsync_WithNonExistentId_ReturnsFailureResult()
     {
         // Arrange
-        var command = new Delete{{pascalCase FEATURE_NAME}}.Command(999);
-        var handler = new Delete{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
-
-        _repository.GetByIdAsync(999, Arg.Any<CancellationToken>())
-            .Returns(({{pascalCase FEATURE_NAME}}?)null);
+        var command = new Delete{{pascalCase FEATURE_NAME}}Request(Guid.CreateVersion7());
+        var handler = new Delete{{pascalCase FEATURE_NAME}}Handler(_db);
 
         // Act
         var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
         result.IsSuccess.Should().BeFalse();
-        await _unitOfWork.DidNotReceive().CommitAsync(Arg.Any<CancellationToken>());
     }
 
     #endregion
 
     #region Helper Methods
 
-    private static {{pascalCase FEATURE_NAME}} CreateTestEntity(int id, string name)
+    private static {{pascalCase FEATURE_NAME}} CreateTestEntity(string name)
     {
-        return {{pascalCase FEATURE_NAME}}.Create(name);
-        // Note: In real tests, use reflection or a test factory to set the Id
+        return new {{pascalCase FEATURE_NAME}}
+        {
+            Id = Guid.CreateVersion7(),
+            Name = name,
+            // TODO: preencher demais campos obrigatórios da entidade
+        };
     }
 
     #endregion
@@ -244,8 +215,8 @@ public class {{pascalCase FEATURE_NAME}}ValidatorTests
     public async Task CreateValidator_WithValidCommand_PassesValidation()
     {
         // Arrange
-        var validator = new Create{{pascalCase FEATURE_NAME}}.Validator();
-        var command = new Create{{pascalCase FEATURE_NAME}}.Command("Valid Name");
+        var validator = new Create{{pascalCase FEATURE_NAME}}Validator();
+        var command = new Create{{pascalCase FEATURE_NAME}}Request("Valid Name");
 
         // Act
         ValidationResult result = await validator.ValidateAsync(command);
@@ -262,30 +233,30 @@ public class {{pascalCase FEATURE_NAME}}ValidatorTests
     public async Task CreateValidator_WithInvalidName_FailsValidation(string? name)
     {
         // Arrange
-        var validator = new Create{{pascalCase FEATURE_NAME}}.Validator();
-        var command = new Create{{pascalCase FEATURE_NAME}}.Command(name!);
+        var validator = new Create{{pascalCase FEATURE_NAME}}Validator();
+        var command = new Create{{pascalCase FEATURE_NAME}}Request(name!);
 
         // Act
         ValidationResult result = await validator.ValidateAsync(command);
 
         // Assert
         result.IsValid.Should().BeFalse();
-        result.Errors.Should().Contain(e => e.PropertyName == nameof(Create{{pascalCase FEATURE_NAME}}.Command.Name));
+        result.Errors.Should().Contain(e => e.PropertyName == nameof(Create{{pascalCase FEATURE_NAME}}Request.Name));
     }
 
     [Fact]
     public async Task CreateValidator_WithNameExceedingMaxLength_FailsValidation()
     {
         // Arrange
-        var validator = new Create{{pascalCase FEATURE_NAME}}.Validator();
-        var command = new Create{{pascalCase FEATURE_NAME}}.Command(new string('A', 201));
+        var validator = new Create{{pascalCase FEATURE_NAME}}Validator();
+        var command = new Create{{pascalCase FEATURE_NAME}}Request(new string('A', 201));
 
         // Act
         ValidationResult result = await validator.ValidateAsync(command);
 
         // Assert
         result.IsValid.Should().BeFalse();
-        result.Errors.Should().Contain(e => e.PropertyName == nameof(Create{{pascalCase FEATURE_NAME}}.Command.Name));
+        result.Errors.Should().Contain(e => e.PropertyName == nameof(Create{{pascalCase FEATURE_NAME}}Request.Name));
     }
 
     #endregion
@@ -296,8 +267,8 @@ public class {{pascalCase FEATURE_NAME}}ValidatorTests
     public async Task UpdateValidator_WithValidCommand_PassesValidation()
     {
         // Arrange
-        var validator = new Update{{pascalCase FEATURE_NAME}}.Validator();
-        var command = new Update{{pascalCase FEATURE_NAME}}.Command(1, "Updated Name");
+        var validator = new Update{{pascalCase FEATURE_NAME}}Validator();
+        var command = new Update{{pascalCase FEATURE_NAME}}Request(Guid.CreateVersion7(), "Updated Name");
 
         // Act
         ValidationResult result = await validator.ValidateAsync(command);
@@ -310,15 +281,15 @@ public class {{pascalCase FEATURE_NAME}}ValidatorTests
     public async Task UpdateValidator_WithInvalidId_FailsValidation()
     {
         // Arrange
-        var validator = new Update{{pascalCase FEATURE_NAME}}.Validator();
-        var command = new Update{{pascalCase FEATURE_NAME}}.Command(0, "Updated Name");
+        var validator = new Update{{pascalCase FEATURE_NAME}}Validator();
+        var command = new Update{{pascalCase FEATURE_NAME}}Request(Guid.Empty, "Updated Name");
 
         // Act
         ValidationResult result = await validator.ValidateAsync(command);
 
         // Assert
         result.IsValid.Should().BeFalse();
-        result.Errors.Should().Contain(e => e.PropertyName == nameof(Update{{pascalCase FEATURE_NAME}}.Command.Id));
+        result.Errors.Should().Contain(e => e.PropertyName == nameof(Update{{pascalCase FEATURE_NAME}}Request.Id));
     }
 
     #endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "7.7.2",
+  "version": "7.8.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/project/doctor.js

@@ -196,7 +196,10 @@ async function doctorFullCommand(frameworkRoot) {
       let projectTags = [];
       const cfgPath = join(frameworkRoot, '.morph/config/config.json');
       if (await pathExists(cfgPath)) {
-        try { projectTags = getProjectTags(JSON.parse(await fs.readFile(cfgPath, 'utf8'))); } catch { /* no tags */ }
+        try {
+          const rawCfg = (await fs.readFile(cfgPath, 'utf8')).replace(/^/, '');
+          projectTags = getProjectTags(JSON.parse(rawCfg));
+        } catch { /* no tags */ }
       }
       const drift = checkAgentsDrift(frameworkRoot, join(frameworkRoot, '.morph/framework'), projectTags);
       check(`Personas installed (${drift.expected - drift.missing.length}/${drift.expected})`,

package/src/commands/project/update.js

@@ -410,6 +410,8 @@ export async function updateCommand(options) {
     if (updateStandards) logger.dim('  ✓ .morph/framework/standards/');
     logger.dim('  ✓ .morph/framework/hooks/');
     logger.dim('  ✓ .morph/framework/agents.json');
+    logger.dim('  ✓ .morph/framework/MORPH.md + phases.json (NLH charter)');
+    logger.dim('  ✓ .morph/framework/schemas/ + rubrics/ + evals/ (bar 9 + LLM rubrics)');
     if (commandsCopied) logger.dim('  ✓ .claude/commands/');
 
     logger.dim(`  ✓ .claude/settings.local.json (${hooksResult.installed} hooks installed)`);

package/src/scripts/setup-infra.js

@@ -92,7 +92,10 @@ async function installStackAwareAssets(targetPath, log) {
   let projectTags = [];
   if (await pathExists(configPath)) {
     try {
-      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      // BOM-tolerant: a config.json hand-edited on Windows (PS 5.1 Out-File)
+      // carries a UTF-8 BOM; without stripping it this parse fails silently
+      // and only universal personas get installed.
+      const config = JSON.parse(readFileSync(configPath, 'utf-8').replace(/^/, ''));
       projectTags = getProjectTags(config);
     } catch { /* ignore malformed config */ }
   }