@polymorphism-tech/morph-spec 2.3.0 → 3.0.0

package/content/.claude/skills/level-2-domains/architecture/standards-architect.md

@@ -0,0 +1,156 @@
+# Standards Architect
+
+> **Layer:** 0 | **Load:** always | **Scope:** All .NET projects (Core Agent)
+
+Guardiao dos padroes de codigo, nomenclatura e arquitetura. Valida aderencia aos standards antes de aprovar merges.
+
+> **Ref:** `framework/standards/coding.md` for complete C# naming conventions and .editorconfig template.
+> **Ref:** `framework/standards/architecture.md` for Clean Architecture layers, SOLID, service patterns.
+
+## Responsabilidades
+
+1. **Garantir aderencia aos padroes** definidos em `framework/standards/` e `.morph/project/standards/`
+2. **Validar nomenclatura** contra `coding.md` (PascalCase, _camelCase, etc.)
+3. **Revisar codigo** antes de aprovar merges
+4. **Definir convencoes** de projeto
+5. **Orquestrar validacao:** Standards Architect (naming) -> Code Analyzer (architecture) -> Code Review (runtime patterns)
+
+## Triggers
+
+Ativado automaticamente em todo projeto MORPH-SPEC (Core Agent).
+
+Keywords: `standards`, `naming`, `convention`, `pattern`, `review`, `quality`, `editorconfig`, `style`
+
+---
+
+## Naming Quick Reference
+
+> Full reference: `framework/standards/coding.md`
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Classes, Methods, Properties | PascalCase | `OrderService`, `GetOrderAsync` |
+| Interfaces | `I` + PascalCase | `IOrderService` |
+| Constants | PascalCase | `DefaultPageSize`, `MaxRetryCount` |
+| Private fields | `_camelCase` | `_repository`, `_logger` |
+| Parameters, locals | camelCase | `orderId`, `orderTotal` |
+| Enums | PascalCase | `OrderStatus.PendingPayment` |
+| Async methods | PascalCase + `Async` | `ProcessPaymentAsync` |
+
+**CRITICAL:** Constants use PascalCase, NOT UPPER_SNAKE_CASE. This follows Microsoft .NET guidelines.
+
+---
+
+## Instant-Fail Rules (Severity: Error)
+
+These rules MUST be satisfied. Code that violates them cannot be merged.
+
+| # | Rule | Signal | Ref |
+|---|------|--------|-----|
+| 1 | **Constants in ALL_CAPS** | `MAX_RETRY_COUNT` instead of `MaxRetryCount` | coding.md |
+| 2 | **Hungarian notation** | `strName`, `iCount`, `btnSubmit` | coding.md |
+| 3 | **Missing CancellationToken** | Async method without `ct` parameter | coding.md |
+| 4 | **`.Result` or `.Wait()`** | Synchronous blocking on async (deadlock) | coding.md |
+| 5 | **Scoped DbContext in background** | Direct `DbContext` in Task.Run/Hangfire | blazor-efcore.md |
+| 6 | **Empty catch block** | `catch { }` or `catch (Exception) { }` | coding.md |
+| 7 | **Domain referencing Infrastructure** | `using MyApp.Infrastructure` in Domain project | architecture.md |
+| 8 | **Hardcoded secrets** | Connection strings, API keys in code | architecture.md |
+| 9 | **Missing `sealed`** | Non-abstract class without `sealed` | coding.md |
+| 10 | **Generic `Exception` throw** | `throw new Exception("...")` | coding.md |
+
+---
+
+## Warning Rules (Severity: Warning)
+
+| # | Rule | Signal |
+|---|------|--------|
+| 1 | Method > 30 lines | Needs extraction |
+| 2 | Class > 300 lines | SRP violation, split |
+| 3 | > 4 constructor parameters | Consider grouping or splitting |
+| 4 | Missing structured logging | Service method without `ILogger` usage |
+| 5 | `string.Format` or `$""` in log | Use message templates |
+| 6 | Abbreviations in names | `repo`, `ctx`, `mgr` (use full words) |
+| 7 | Missing `null` check | Parameter not validated at boundary |
+| 8 | Unused `using` | Dead imports |
+
+---
+
+## Enforcement
+
+### .editorconfig
+
+Every project MUST have an `.editorconfig` in the root. Template in `coding.md`.
+
+```bash
+# Validate naming rules at build time
+dotnet build /warnaserror:IDE1006
+```
+
+### Validation Workflow
+
+```
+1. Standards Architect    → Naming, style, conventions (coding.md)
+2. Code Analyzer          → Architecture, clean code, duplication (architecture.md)
+3. Code Review Checklist  → Runtime patterns: async, DI, logging (code-review.md)
+```
+
+This pipeline runs:
+- **Automatically** at FASE 5 completion and at every checkpoint (every 3 tasks)
+- **Manually** when requested via `review`, `analyze`, `check standards`
+
+---
+
+## Estrutura de Projeto
+
+> Full reference: `framework/standards/architecture.md`
+
+```
+src/
+├── {Project}.Domain/          # Entidades, Value Objects, Enums
+├── {Project}.Application/     # Services, DTOs, Interfaces
+├── {Project}.Infrastructure/  # EF Core, External Services
+├── {Project}.Web/             # Blazor, API Controllers
+└── tests/                     # Unit, Integration tests
+```
+
+---
+
+## Padroes Blazor
+
+```razor
+@* Componentes: PascalCase.razor *@
+@* Parameters: [Parameter] obrigatorio *@
+@* EventCallbacks: On{Event}Async *@
+
+<OrderList Orders="@_orders" OnSelectAsync="HandleSelectAsync" />
+```
+
+---
+
+## Documentacao de Referencia
+
+- `framework/standards/coding.md` — C# naming, style, .editorconfig
+- `framework/standards/architecture.md` — Clean Architecture, SOLID, DI
+- `framework/standards/blazor-efcore.md` — DbContext, Repository Factory
+- `framework/standards/blazor-pitfalls.md` — Common Blazor issues
+- [Microsoft C# Coding Conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions)
+- [.NET Naming Guidelines](https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/naming-guidelines)
+
+---
+
+## Checklist de Revisao
+
+- [ ] Nomenclatura segue `coding.md` (PascalCase constants, _camelCase fields)
+- [ ] `.editorconfig` presente no projeto
+- [ ] Async/await com CancellationToken
+- [ ] Nullable reference types habilitado
+- [ ] DI registrado corretamente (lifetimes corretos)
+- [ ] Logs estruturados com `ILogger<T>` (message templates)
+- [ ] Exceptions tratadas adequadamente (Result pattern para business)
+- [ ] Classes `sealed` por padrao
+- [ ] Codigo sem warnings (IDE1006 enforced)
+- [ ] Arquitetura segue `architecture.md` (layers, SOLID)
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/content/.claude/skills/level-2-domains/backend/dotnet-senior.md

@@ -0,0 +1,287 @@
+# .NET Senior Engineer
+
+> **Layer:** 1 | **Load:** always | **Scope:** All .NET projects (Core Agent)
+
+Senior .NET engineer specialist. Writes production-quality C# following all framework standards. Includes **Ultrathink Mode** for complex architectural decisions.
+
+> **Ref:** `framework/standards/coding.md` — ALL code output MUST follow these conventions.
+> **Ref:** `framework/standards/architecture.md` — ALL code MUST respect layer boundaries.
+> **Ref:** `.claude/skills/checklists/code-review.md` — Self-check before delivering code.
+
+---
+
+## Two Modes
+
+### Standard Mode (default)
+
+Active for all C# code writing. Every file produced follows the coding standards and architecture patterns.
+
+**Trigger:** Any implementation task (always active as Core Agent).
+
+### Ultrathink Mode
+
+Extended deep-reasoning mode for complex decisions. Think step by step through trade-offs before recommending.
+
+**Trigger keywords:** `ultrathink`, `deep-think`, `think deeply`, `analyze deeply`, `complex decision`
+
+**Use for:**
+- Technology/library selection (MudBlazor vs Fluent UI, Hangfire vs Azure Functions)
+- Architecture pattern decisions (CQRS vs simple, Repository vs direct DbContext)
+- Performance optimization strategy
+- Migration planning (.NET version upgrades, library migrations)
+- Multi-system integration design
+- Database schema design for complex domains
+
+---
+
+## Code Writing Rules
+
+**MANDATORY for ALL C# code output.** No exceptions.
+
+### Naming (ref: coding.md)
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Classes | PascalCase + `sealed` | `public sealed class OrderService` |
+| Interfaces | `I` + PascalCase | `public interface IOrderService` |
+| Methods | PascalCase + `Async` | `public async Task<Result<Order>> GetByIdAsync(...)` |
+| Constants | PascalCase | `private const int MaxRetryCount = 3;` |
+| Private fields | `_camelCase` | `private readonly ILogger<OrderService> _logger;` |
+| Parameters | camelCase | `(int orderId, CancellationToken ct = default)` |
+
+### Structure
+
+```csharp
+// 1. File-scoped namespace
+namespace MyApp.Application.Services;
+
+// 2. Primary constructor for DI (preferred) or traditional constructor
+public sealed class OrderService(
+    IOrderRepository repository,
+    IPaymentGateway paymentGateway,
+    ILogger<OrderService> logger) : IOrderService
+{
+    // 3. Constants first (PascalCase)
+    private const int MaxRetryCount = 3;
+    private const string DefaultCurrency = "BRL";
+
+    // 4. Public methods (business operations)
+    public async Task<Result<OrderResponse>> CreateAsync(
+        CreateOrderRequest request,
+        CancellationToken ct = default)
+    {
+        // 5. Entry logging with correlation
+        logger.LogInformation("Creating order for customer {CustomerId}", request.CustomerId);
+
+        // 6. Validation (early return with Result)
+        if (request.Items.Count == 0)
+            return Result.Failure<OrderResponse>("Order must have at least one item");
+
+        // 7. Domain logic
+        var order = Order.Create(request.CustomerId, request.Items);
+
+        // 8. Persistence
+        await repository.AddAsync(order, ct);
+        await repository.SaveChangesAsync(ct);
+
+        // 9. Exit logging
+        logger.LogInformation("Order {OrderId} created successfully", order.Id);
+
+        // 10. Return mapped response
+        return Result.Success(order.ToResponse());
+    }
+}
+```
+
+### Mandatory Patterns
+
+| Pattern | Rule | Example |
+|---------|------|---------|
+| **CancellationToken** | Last parameter on ALL async methods | `CancellationToken ct = default` |
+| **Result pattern** | Business errors return Result, NOT exceptions | `Result.Failure<T>("message")` |
+| **Structured logging** | Entry + exit + error on every service method | `logger.LogInformation("...", correlationId)` |
+| **sealed** | All classes sealed unless designed for inheritance | `public sealed class OrderService` |
+| **Nullable types** | Always enabled, `?` only when truly optional | `string? middleName` (optional) vs `string name` (required) |
+| **Primary constructors** | For DI injection (C# 12+) | `class OrderService(IRepo repo)` |
+| **Expression body** | Single-line members | `public int Count => _items.Count;` |
+| **Pattern matching** | `is null` / `is not null` | `if (order is null) return ...` |
+| **Collection expressions** | Prefer `[..]` syntax | `List<int> ids = [1, 2, 3];` |
+
+### Entity Pattern
+
+```csharp
+namespace MyApp.Domain.Entities;
+
+public sealed class Order
+{
+    // Private constructor — force factory method
+    private Order() { }
+
+    public Guid Id { get; private set; }
+    public int CustomerId { get; private set; }
+    public OrderStatus Status { get; private set; }
+    public decimal Total { get; private set; }
+    public DateTime CreatedAt { get; private set; }
+
+    // Factory method with validation
+    public static Order Create(int customerId, List<OrderItem> items)
+    {
+        if (items.Count == 0)
+            throw new DomainException("Order must have at least one item");
+
+        return new Order
+        {
+            Id = Guid.NewGuid(),
+            CustomerId = customerId,
+            Status = OrderStatus.Created,
+            Total = items.Sum(i => i.Price * i.Quantity),
+            CreatedAt = DateTime.UtcNow
+        };
+    }
+
+    // Behavior methods (not anemic)
+    public void MarkAsPaid()
+    {
+        if (Status >= OrderStatus.Completed || Status == OrderStatus.Failed)
+            throw new DomainException($"Cannot mark order {Id} as paid in status {Status}");
+        Status = OrderStatus.PendingPayment;
+    }
+}
+```
+
+### DTO Pattern
+
+```csharp
+namespace MyApp.Application.DTOs;
+
+// Request: record with required properties
+public sealed record CreateOrderRequest(
+    int CustomerId,
+    List<OrderItemRequest> Items);
+
+// Response: record with computed properties
+public sealed record OrderResponse(
+    Guid Id,
+    int CustomerId,
+    string StatusDisplay,
+    decimal Total,
+    DateTime CreatedAt);
+
+// Enum: PascalCase members, error states at 100+
+public enum OrderStatus
+{
+    Created = 0,
+    PendingPayment = 1,
+    Processing = 2,
+    Shipped = 3,
+    Completed = 4,
+    // Error states (high values for comparison operators)
+    Failed = 100,
+    Cancelled = 101,
+    Refunded = 102
+}
+```
+
+---
+
+## Post-Implementation Pipeline
+
+After writing code, self-check before delivering:
+
+```
+1. NAMING CHECK     → Does every identifier follow coding.md?
+2. ARCHITECTURE     → Are files in the correct layer? No forbidden references?
+3. ASYNC            → CancellationToken on all async? No .Result/.Wait()?
+4. LOGGING          → Entry/exit/error logging? Message templates (not $"")?
+5. ERROR HANDLING   → Result pattern for business? No empty catch?
+6. SEALED           → All classes sealed?
+7. NULLABLE         → <Nullable>enable</Nullable>? ? only where optional?
+```
+
+Then trigger **Code Analyzer** for deeper review (automatic at checkpoints and FASE 5).
+
+---
+
+## Ultrathink Decision Template
+
+When in Ultrathink Mode, produce structured analysis:
+
+```markdown
+## Decision: {Title}
+
+### Context
+{Why this decision is needed now. What triggered it. Current state.}
+
+### Constraints
+- {Constraint 1: budget, timeline, team skill, existing tech}
+- {Constraint 2}
+
+### Options Analysis
+
+| Criterion | Option A: {Name} | Option B: {Name} | Option C: {Name} |
+|-----------|------------------|------------------|------------------|
+| **Performance** | {assessment} | {assessment} | {assessment} |
+| **Complexity** | {Low/Medium/High} | {Low/Medium/High} | {Low/Medium/High} |
+| **Maintainability** | {assessment} | {assessment} | {assessment} |
+| **Cost** | {assessment} | {assessment} | {assessment} |
+| **Risk** | {assessment} | {assessment} | {assessment} |
+| **Team familiarity** | {assessment} | {assessment} | {assessment} |
+
+### Option A: {Name}
+**Pros:** {list}
+**Cons:** {list}
+**Best when:** {scenario}
+
+### Option B: {Name}
+**Pros:** {list}
+**Cons:** {list}
+**Best when:** {scenario}
+
+### Recommendation
+**{Option X}** because {justification tied to constraints and criteria}.
+
+### Implementation Impact
+- **Files affected:** {count and key files}
+- **Migrations:** {yes/no, what changes}
+- **Breaking changes:** {yes/no, what breaks}
+- **Estimated effort:** {T-shirt size with rationale}
+- **Rollback plan:** {how to revert if needed}
+```
+
+---
+
+## .NET 10 / C# 14 Quick Patterns
+
+| Pattern | When | Example |
+|---------|------|---------|
+| Primary constructors | DI injection | `class Service(IRepo repo)` |
+| Collection expressions | Initialize collections | `List<int> ids = [1, 2, 3]` |
+| File-scoped namespaces | Always | `namespace MyApp.Services;` |
+| Raw string literals | Multi-line strings, SQL | `"""SELECT * FROM ..."""` |
+| Records | Immutable DTOs | `record OrderResponse(Guid Id, ...)` |
+| Pattern matching | Type checks, null checks | `if (x is Order { Status: > 0 } order)` |
+| `required` modifier | Non-nullable init props | `public required string Name { get; init; }` |
+| `sealed` classes | Default for all classes | `public sealed class OrderService` |
+| Extension methods | Add behavior to existing types | `public static class OrderExtensions` |
+| Global usings | Reduce repetitive imports | `global using MyApp.Domain.Entities;` |
+
+---
+
+## Anti-Patterns to NEVER Produce
+
+| Anti-Pattern | Why | Instead |
+|--------------|-----|---------|
+| `async void` | Exceptions lost, can't await | `async Task` (always) |
+| `.Result` / `.Wait()` | Deadlock in Blazor Server | `await` |
+| `new DbContext()` in service | Wrong lifetime, no DI | Constructor injection |
+| `catch (Exception) { }` | Swallowed exception | Log + rethrow or Result |
+| Public fields | Encapsulation broken | Properties with `{ get; private set; }` |
+| `string.Format` in logs | Defeats structured logging | Message templates |
+| `== null` | Not idiomatic C# | `is null` |
+| Unsealed classes | Unintended inheritance | `sealed` keyword |
+| Service Locator | Hidden dependencies | Constructor injection |
+| God class (500+ lines) | Unmaintainable | Split by responsibility |
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/content/.claude/skills/level-2-domains/backend/ef-modeler.md

@@ -0,0 +1,113 @@
+# EF Modeler
+
+> **Layer:** 2 | **Load:** on-keyword | **Keywords:** entity, database, migration, ef core, dbcontext, table, column, relationship, query
+
+Especialista em Entity Framework Core para modelagem de dados e banco de dados.
+
+## .NET 10 Compatibility
+- EF Core: **>= 10.0.0** | New: Vector search, primitive collections
+- **Ref:** `framework/standards/dotnet10-compatibility.md`
+
+---
+
+## Entity Structure
+
+```csharp
+public class Order : BaseEntity
+{
+    public string OrderNumber { get; private set; } = null!;
+    public OrderStatus Status { get; private set; }
+    public decimal Total { get; private set; }
+    public DateTime CreatedAt { get; private set; }
+
+    // Navigation
+    public int CustomerId { get; private set; }
+    public Customer Customer { get; private set; } = null!;
+    public ICollection<OrderItem> Items { get; private set; } = new List<OrderItem>();
+
+    // Factory method
+    public static Order Create(int customerId, IEnumerable<OrderItem> items) { ... }
+}
+```
+
+**Rules:** Private setters, factory methods, explicit navigation properties.
+
+## Configuration
+
+```csharp
+public class OrderConfiguration : IEntityTypeConfiguration<Order>
+{
+    public void Configure(EntityTypeBuilder<Order> builder)
+    {
+        builder.ToTable("Orders");
+        builder.HasKey(o => o.Id);
+        builder.Property(o => o.OrderNumber).IsRequired().HasMaxLength(20);
+        builder.Property(o => o.Total).HasPrecision(18, 2);
+        builder.HasIndex(o => o.OrderNumber).IsUnique();
+        builder.HasOne(o => o.Customer).WithMany(c => c.Orders)
+            .HasForeignKey(o => o.CustomerId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasMany(o => o.Items).WithOne(i => i.Order)
+            .HasForeignKey(i => i.OrderId).OnDelete(DeleteBehavior.Cascade);
+    }
+}
+```
+
+## Migrations
+
+```powershell
+dotnet ef migrations add {Name} --project src/Infrastructure --startup-project src/Web
+dotnet ef migrations script --idempotent --output migration.sql
+dotnet ef database update
+```
+
+**Naming:** `{YYYYMMDD}_{Number}_{Description}` (e.g., `20240301_001_CreateOrdersTable`)
+
+## Query Optimization
+
+```csharp
+// ❌ N+1 problem
+var orders = await _context.Orders.ToListAsync();
+foreach (var o in orders) { var items = o.Items; } // N extra queries!
+
+// ✅ Include
+var orders = await _context.Orders.Include(o => o.Items).Include(o => o.Customer).ToListAsync();
+
+// ✅ Projection (best)
+var dtos = await _context.Orders.Select(o => new OrderDto {
+    Id = o.Id, CustomerName = o.Customer.Name, ItemCount = o.Items.Count
+}).ToListAsync();
+```
+
+---
+
+## Background Operations
+
+> **Ref:** `framework/standards/blazor-efcore.md` — Repository Factory pattern for background ops
+
+**Rule:** Separate thread = isolated DbContext via `IDbContextFactory`.
+Background tasks, `Task.Run`, SignalR, Hangfire jobs — all need `IDbContextFactory`.
+
+---
+
+## Troubleshooting
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Invalid object name 'Table'` | Migration not applied | Run `database update` |
+| `PendingModelChangesWarning` | Model changed without migration | Create new migration |
+| `Include() doesn't load` | `HasMany<T>()` without navigation | Use `HasMany(x => x.Nav)` |
+| `A second operation was started` | Shared DbContext | Use `IDbContextFactory` |
+
+## Checklist
+- [ ] Entities with private setters + factory methods
+- [ ] Separate configuration (IEntityTypeConfiguration)
+- [ ] Indexes on search columns
+- [ ] Precision defined for decimals
+- [ ] Delete behavior explicit
+- [ ] Migration script generated and reviewed
+- [ ] Queries with Include or Projection (no N+1)
+- [ ] `IDbContextFactory` for background ops
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/content/.claude/skills/level-2-domains/backend/hangfire-orchestrator.md

@@ -0,0 +1,126 @@
+# Hangfire Orchestrator
+
+> **Layer:** 2 | **Load:** on-keyword | **Keywords:** scheduled, job, background, cron, recurring, batch, queue, hangfire
+
+Especialista em background jobs, tarefas agendadas e processamento assíncrono com Hangfire.
+
+## .NET 10 Compatibility
+- Hangfire.AspNetCore: **>= 1.8.22** (required for .NET 10)
+
+## Why Hangfire (not Azure Functions)
+
+| Aspect | Hangfire | Azure Functions |
+|--------|----------|-----------------|
+| Cost | Free (in-process) | Pay per execution |
+| Dashboard | Built-in | App Insights separate |
+| Debugging | Local easy | Emulator needed |
+| Complexity | Low | Medium-High |
+
+---
+
+## Setup
+
+```csharp
+// Program.cs
+builder.Services.AddHangfire(config => config
+    .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
+    .UseSimpleAssemblyNameTypeSerializer()
+    .UseRecommendedSerializerSettings()
+    .UseSqlServerStorage(connString, new SqlServerStorageOptions
+    {
+        CommandBatchMaxTimeout = TimeSpan.FromMinutes(5),
+        QueuePollInterval = TimeSpan.Zero,
+        UseRecommendedIsolationLevel = true,
+        DisableGlobalLocks = true
+    }));
+
+builder.Services.AddHangfireServer(options =>
+{
+    options.WorkerCount = Environment.ProcessorCount * 2;
+    options.Queues = new[] { "critical", "default", "low" };
+});
+
+app.UseHangfireDashboard("/hangfire", new DashboardOptions
+{
+    Authorization = new[] { new HangfireAuthorizationFilter() }
+});
+```
+
+## Job Types
+
+| Type | API | Example |
+|------|-----|---------|
+| **Fire-and-Forget** | `BackgroundJob.Enqueue<T>(...)` | Send email |
+| **Delayed** | `BackgroundJob.Schedule<T>(..., TimeSpan)` | Abandoned cart check |
+| **Recurring** | `RecurringJob.AddOrUpdate<T>(..., cron)` | Daily report |
+| **Continuation** | `BackgroundJob.ContinueJobWith(id, ...)` | Post-import notify |
+
+### Common Cron Expressions
+`"0 * * * *"` hourly | `"*/5 * * * *"` every 5m | `"0 8 * * 1-5"` 8am weekdays | `"0 0 1 * *"` monthly
+
+---
+
+## CRITICAL: Scoped Repository Pattern
+
+> **Ref:** `framework/standards/blazor-efcore.md` — Repository Factory pattern
+
+**Hangfire jobs run OUTSIDE the HTTP request.** The scoped DbContext does NOT exist.
+
+```csharp
+// ✅ ALWAYS use Factory
+public class OrderProcessorJob(IOrderRepositoryFactory repoFactory, ILogger<OrderProcessorJob> logger)
+{
+    [AutomaticRetry(Attempts = 3, DelaysInSeconds = new[] { 60, 300, 900 })]
+    public async Task ProcessAsync(Guid orderId, CancellationToken ct)
+    {
+        await using var repo = repoFactory.CreateScoped();  // Isolated DbContext
+        var order = await repo.GetByIdAsync(orderId, ct);
+        if (order == null || order.Status >= OrderStatus.Completed) return;  // Idempotent
+        order.MarkAsProcessed();
+        await repo.UpdateAsync(order, ct);
+    }
+}
+
+// ❌ NEVER inject repository directly — DbContext will be disposed
+```
+
+## Retry & Error Handling
+
+```csharp
+[AutomaticRetry(Attempts = 5, DelaysInSeconds = new[] { 60, 300, 900, 3600, 7200 })]
+[Queue("critical")]
+public async Task ProcessPaymentAsync(int orderId)
+{
+    try { await _paymentService.ProcessAsync(orderId); }
+    catch (PaymentGatewayException ex) { _logger.LogWarning(ex, "..."); throw; } // Rethrow for retry
+}
+```
+
+## Dashboard Authorization
+
+```csharp
+public class HangfireAuthorizationFilter : IDashboardAuthorizationFilter
+{
+    public bool Authorize(DashboardContext context)
+    {
+        var http = context.GetHttpContext();
+        return http.User.Identity?.IsAuthenticated == true && http.User.IsInRole("Admin");
+    }
+}
+```
+
+---
+
+## Checklist
+- [ ] Uses `IRepositoryFactory` (NOT direct repository)
+- [ ] `await using` for dispose
+- [ ] Job is idempotent (safe to retry)
+- [ ] AutomaticRetry configured
+- [ ] Queue defined (critical/default/low)
+- [ ] CancellationToken propagated
+- [ ] Dashboard protected with auth
+- [ ] Timezone set for recurring jobs
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*