@polymorphism-tech/morph-spec 3.2.0 → 4.2.0

package/stacks/blazor-azure/.claude/skills/level-2-domains/backend/dotnet-senior.md

@@ -1,286 +1,76 @@
 # .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.
+**Tier:** 2 (Domain Leader)
+**Always Active:** Yes
+**Reports to:** standards-architect
+**Coordinates:** ef-modeler, api-designer, event-architect, hangfire-orchestrator, ms-agent-expert, ddd-expert, nosql-cache-expert
 
 ---
 
-## 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.
+## Role
 
-**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
+Senior .NET engineer and Backend Squad Leader. Writes production-quality C# code and coordinates backend domain specialists for all .NET implementation tasks.
 
 ---
 
-## 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)` |
+## Standards Applied
 
-### 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
-}
+framework/standards/core/coding.md
+framework/standards/core/architecture.md
+framework/standards/core/testing.md
+framework/standards/backend/dotnet/core.md
+framework/standards/backend/dotnet/async.md
+framework/standards/backend/dotnet/di.md
+framework/standards/backend/database/ef-core.md
+framework/standards/backend/api/rest.md
 ```
 
 ---
 
-## Post-Implementation Pipeline
+## Responsibilities
 
-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).
+- Lead backend implementation (services, controllers, business logic)
+- Coordinate backend squad (ef-modeler, api-designer, etc.)
+- Ensure code follows all .NET standards
+- Design service layer architecture
+- Implement async patterns with CancellationToken
+- Apply dependency injection correctly
+- Write unit and integration tests
 
 ---
 
-## Ultrathink Decision Template
-
-When in Ultrathink Mode, produce structured analysis:
+## When to Use
 
-```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}
-```
+- Any .NET/C# code implementation
+- Backend service layer development
+- API controller implementation
+- Business logic implementation
+- Complex architectural decisions (Ultrathink mode)
 
 ---
 
-## .NET 10 / C# 14 Quick Patterns
+## Ultrathink Mode
+
+**Trigger:** Keywords like "ultrathink", "deep-think", "analyze deeply", "complex decision"
 
-| 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;` |
+**Use for:**
+- Technology/library selection
+- Architecture pattern decisions (CQRS vs simple)
+- Performance optimization strategy
+- Migration planning
+- Multi-system integration design
 
 ---
 
-## Anti-Patterns to NEVER Produce
+## Collaborates With
 
-| 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 |
+- **ef-modeler** - Database/EF Core layer
+- **api-designer** - REST API contracts and endpoints
+- **azure-architect** - Infrastructure provisioning
+- **blazor-builder** - Backend API consumed by frontend
+- **hangfire-orchestrator** - Background job coordination
+- **testing-specialist** - Test coverage and quality
 
 ---
 

package/stacks/blazor-azure/.claude/skills/level-2-domains/backend/ef-modeler.md

@@ -1,112 +1,57 @@
 # 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`
+**Tier:** 3 (Specialist)
+**Always Active:** No
+**Keywords:** entity, database, migration, ef core, dbcontext, table, column, relationship, query
+**Reports to:** dotnet-senior
 
 ---
 
-## Entity Structure
+## Role
 
-```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; }
+Entity Framework Core specialist for database modeling, entities, configurations, and migrations.
 
-    // 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) { ... }
-}
-```
+## Standards Applied
 
-**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
+framework/standards/core/coding.md
+framework/standards/backend/dotnet/core.md
+framework/standards/backend/database/ef-core.md
+framework/standards/backend/database/migrations.md
+framework/standards/backend/database/repository-patterns.md
+framework/standards/backend/database/performance.md
 ```
 
-**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();
+## Responsibilities
 
-// ✅ Projection (best)
-var dtos = await _context.Orders.Select(o => new OrderDto {
-    Id = o.Id, CustomerName = o.Customer.Name, ItemCount = o.Items.Count
-}).ToListAsync();
-```
+- Design entity models with private setters and factory methods
+- Create IEntityTypeConfiguration for each entity
+- Configure relationships, indexes, and constraints
+- Generate and review EF Core migrations
+- Optimize database queries (avoid N+1, use proper includes)
+- Implement repository patterns with IDbContextFactory
 
 ---
 
-## Background Operations
-
-> **Ref:** `framework/standards/blazor-efcore.md` — Repository Factory pattern for background ops
+## When to Use
 
-**Rule:** Separate thread = isolated DbContext via `IDbContextFactory`.
-Background tasks, `Task.Run`, SignalR, Hangfire jobs — all need `IDbContextFactory`.
+- Creating/modifying entity classes
+- Database schema changes
+- Migration creation/review
+- Query optimization
+- DbContext configuration
 
 ---
 
-## 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
+## Collaborates With
+
+- **dotnet-senior** - Service layer consuming repositories
+- **api-designer** - DTO mapping from entities
+- **azure-architect** - Database provisioning (Azure SQL, Cosmos DB)
 
 ---
 

package/stacks/blazor-azure/.claude/skills/level-2-domains/backend/ms-agent-expert.md

@@ -2,107 +2,43 @@
 
 > **Layer:** 2 | **Load:** on-keyword | **Keywords:** agent, ai, llm, openai, chat, prompt, tool, function calling, rag, embedding, workflow, orchestration, mcp, a2a, middleware
 
-Microsoft Agent Framework for .NET 10. **Replaces Semantic Kernel.** Packages: `Microsoft.Agents.AI`, `Microsoft.Agents.AI.OpenAI`, `Microsoft.Agents.AI.Hosting`.
+## Identity
 
-> **Ref:** `agent-framework-setup.md` — Full setup guide
-> **Ref:** `agent-framework-workflows.md` — Orchestration patterns
-> **Ref:** `agent-framework-production.md` — Middleware, A2A, MCP, caching
+Microsoft Agent Framework specialist for .NET 10. Implements AI agents, tools, workflows, and middleware.
 
-## Quick Start
+## Knowledge Base (Consult These)
 
-```csharp
-AIAgent agent = new AzureOpenAIClient(
-    new Uri(endpoint), new AzureCliCredential())
-  .GetChatClient("gpt-4o-mini")
-  .AsAIAgent(instructions: "You are a helpful assistant.");
+- `framework/standards/ai-agents/setup.md` - Agent configuration, DI, tools, streaming
+- `framework/standards/ai-agents/workflows.md` - Sequential, parallel, conditional workflows
+- `framework/standards/ai-agents/production.md` - Middleware, A2A, MCP, caching, observability
 
-Console.WriteLine(await agent.RunAsync("Analyze this."));
-```
+## Responsibilities
 
-## Agent with Tools
-
-```csharp
-public class OrderFunctions
-{
-    private readonly IOrderService _orderService;
-
-    public OrderFunctions(IOrderService orderService) => _orderService = orderService;
-
-    [Description("Get order by number")]
-    public async Task<Order?> GetOrderAsync(
-        [Description("Order number")] string orderNumber, CancellationToken ct = default)
-        => await _orderService.GetByNumberAsync(orderNumber, ct);
-
-    [Description("Calculate customer discount")]
-    public decimal CalculateDiscount(
-        [Description("Customer ID")] int customerId,
-        [Description("Order total")] decimal orderTotal) => orderTotal * 0.1m;
-}
-
-// Register agent with tools via DI
-builder.AddAIAgent("OrderAgent", (sp, key) =>
-{
-    var chatClient = sp.GetRequiredService<IChatClient>();
-    var orderFunctions = sp.GetRequiredService<OrderFunctions>();
-
-    return new ChatClientAgent(chatClient, name: key,
-        instructions: "You are an order assistant. Use tools to help users.",
-        tools: [
-            AIFunctionFactory.Create(orderFunctions.GetOrderAsync),
-            AIFunctionFactory.Create(orderFunctions.CalculateDiscount)]);
-});
-```
-
-## Workflow (Sequential)
-
-```csharp
-Workflow workflow = AgentWorkflowBuilder.BuildSequential(writer, editor);
-AIAgent workflowAgent = await workflow.AsAgentAsync();
-var response = await workflowAgent.RunAsync("Write a report.");
-```
-
-## Middleware (Error Handling)
-
-```csharp
-var agent = originalAgent.AsBuilder()
-    .Use(async (agent, context, next, ct) =>
-    {
-        try { return await next(context, ct); }
-        catch (Exception ex) { return $"Error: {ex.Message}"; }
-    })
-    .Build();
-```
+- Configure agents per setup.md patterns (ChatClientAgent, keyed services)
+- Design workflows per workflows.md orchestration patterns
+- Implement middleware per production.md (error handling, logging, retry)
+- Use recommended models from setup.md (gpt-4o-mini default)
 
 ## Prompt Template
 
-```
-# Identity: You are {AgentName}, expert in {Domain}.
-# Context: {ContextDescription}
-# Rules: {BulletList}
-# Response Format: {Format}
-# Examples: Input: {In} → Output: {Out}
-```
+When working on AI agent tasks:
+1. Consult `setup.md` for agent configuration, tools, and DI registration
+2. Follow `workflows.md` for orchestration (sequential, parallel, conditional)
+3. Apply `production.md` for middleware, observability, and production patterns
+4. NEVER use Semantic Kernel - use Microsoft.Agents.AI exclusively
 
-## Model Selection
+## When to Use
 
-| Use Case | Model | Cost |
-|----------|-------|------|
-| Simple tasks (default) | gpt-4o-mini | $0.15/1M input |
-| Complex analysis | gpt-4o | $2.50/1M input |
-| Embeddings | text-embedding-3-small | $0.02/1M |
+- AI/LLM integration requests
+- Agent workflow design
+- Tool/function calling implementation
+- Agent middleware and observability
 
-## Checklist
+## Collaborates With
 
-- [ ] `Microsoft.Agents.AI` + `Microsoft.Agents.AI.OpenAI` installed
-- [ ] `IChatClient` configured via DI (singleton)
-- [ ] Agents use `ChatClientAgent` or `.AsAIAgent()`
-- [ ] Agents registered with `builder.AddAIAgent()` (keyed services)
-- [ ] Tools use `AIFunctionFactory.Create()` + `[Description]`
-- [ ] Middleware for error handling and logging
-- [ ] gpt-4o-mini as default model
-- [ ] API keys in Key Vault
-- [ ] OpenTelemetry enabled: `agent.WithOpenTelemetry()`
-- [ ] **Do NOT use Semantic Kernel** (`Kernel`, `KernelFunction`, `InvokePromptAsync`)
+- ai-system-architect - Overall AI strategy
+- dotnet-senior - Backend integration
+- azure-architect - Azure OpenAI provisioning
 
 ---
 

package/stacks/blazor-azure/.claude/skills/level-2-domains/integrations/hangfire-orchestrator.md

@@ -0,0 +1,64 @@
+# Hangfire Orchestrator
+
+**Tier:** 3 (Specialist)
+**Always Active:** No
+**Keywords:** scheduled, job, background, cron, recurring, batch, queue, hangfire
+**Reports to:** dotnet-senior
+
+---
+
+## Role
+
+Hangfire specialist for background jobs, scheduled tasks, and asynchronous processing.
+
+---
+
+## Standards Applied
+
+```
+framework/standards/core/coding.md
+framework/standards/backend/dotnet/async.md
+framework/standards/backend/database/repository-patterns.md (Factory pattern for scoped repos)
+framework/standards/backend/integrations/hangfire/setup.md
+framework/standards/backend/integrations/hangfire/jobs.md
+```
+
+---
+
+## Responsibilities
+
+- Configure Hangfire with SQL Server storage
+- Create fire-and-forget jobs
+- Schedule recurring jobs with cron expressions
+- Implement delayed and continuation jobs
+- Use IRepositoryFactory for DbContext in jobs (NOT direct injection)
+- Configure Hangfire Dashboard with authentication
+- Handle job failures and retries
+
+---
+
+## When to Use
+
+- Background processing (emails, reports, cleanup)
+- Scheduled tasks (daily/hourly jobs)
+- Delayed operations (abandoned cart after 24h)
+- Long-running operations outside HTTP request
+
+---
+
+## Critical Pattern
+
+**ALWAYS use IRepositoryFactory in Hangfire jobs** - DbContext is scoped to HTTP request and won't exist in background jobs.
+
+---
+
+## Collaborates With
+
+- **dotnet-senior** - Service layer triggering jobs
+- **ef-modeler** - Repository factory implementation
+- **azure-architect** - Hangfire dashboard security
+- **resend-email** - Email jobs coordination
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*