feat(medios,secciones): application layer + handlers TDD — ADM-001 B3+B4

- IMedioRepository, ISeccionRepository interfaces
- MediosQuery, SeccionesQuery common records
- TipoSeccion static AllowedTipos helper
- Medios: 6 use cases (Create/Update/Deactivate/Reactivate/List/GetById) with validators, handlers and DTOs
- Secciones: 6 use cases mirroring Medios; Create validates MedioId active via IMedioRepository
- 52 unit tests (xUnit + NSubstitute) all green; audit LogAsync asserted per mutating handler
- DI registrations for all 12 handlers and validators auto-scanned via AddValidatorsFromAssemblyContaining

src/api/SIGCM2.Application/Abstractions/Persistence/IMedioRepository.cs

@@ -0,0 +1,13 @@
+using SIGCM2.Application.Common;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Abstractions.Persistence;
+
+public interface IMedioRepository
+{
+    Task<int> AddAsync(Medio m, CancellationToken ct = default);
+    Task<Medio?> GetByIdAsync(int id, CancellationToken ct = default);
+    Task<bool> ExistsByCodigoAsync(string codigo, CancellationToken ct = default);
+    Task UpdateAsync(Medio m, CancellationToken ct = default);
+    Task<PagedResult<Medio>> GetPagedAsync(MediosQuery q, CancellationToken ct = default);
+}

src/api/SIGCM2.Application/Abstractions/Persistence/ISeccionRepository.cs

@@ -0,0 +1,13 @@
+using SIGCM2.Application.Common;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Abstractions.Persistence;
+
+public interface ISeccionRepository
+{
+    Task<int> AddAsync(Seccion s, CancellationToken ct = default);
+    Task<Seccion?> GetByIdAsync(int id, CancellationToken ct = default);
+    Task<bool> ExistsByCodigoInMedioAsync(int medioId, string codigo, CancellationToken ct = default);
+    Task UpdateAsync(Seccion s, CancellationToken ct = default);
+    Task<PagedResult<Seccion>> GetPagedAsync(SeccionesQuery q, CancellationToken ct = default);
+}

src/api/SIGCM2.Application/Common/MediosQuery.cs

@@ -0,0 +1,12 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Common;
+
+/// <summary>Query parameters for listing medios with optional filters and paging.</summary>
+public sealed record MediosQuery(
+    int Page,
+    int PageSize,
+    bool? Activo,
+    TipoMedio? Tipo,
+    string? Search
+);

src/api/SIGCM2.Application/Common/SeccionesQuery.cs

@@ -0,0 +1,11 @@
+namespace SIGCM2.Application.Common;
+
+/// <summary>Query parameters for listing secciones with optional filters and paging.</summary>
+public sealed record SeccionesQuery(
+    int Page,
+    int PageSize,
+    int? MedioId,
+    string? Tipo,
+    bool? Activo,
+    string? Search
+);

src/api/SIGCM2.Application/DependencyInjection.cs

@@ -5,6 +5,12 @@ using SIGCM2.Application.Auth.Login;
 using SIGCM2.Application.Auth.Logout;
 using SIGCM2.Application.Auth.Refresh;
 using SIGCM2.Application.Common;
+using SIGCM2.Application.Medios.Create;
+using SIGCM2.Application.Medios.Deactivate;
+using SIGCM2.Application.Medios.GetById;
+using SIGCM2.Application.Medios.List;
+using SIGCM2.Application.Medios.Reactivate;
+using SIGCM2.Application.Medios.Update;
 using SIGCM2.Application.Permisos.Assign;
 using SIGCM2.Application.Permisos.Dtos;
 using SIGCM2.Application.Permisos.GetByRol;
@@ -15,6 +21,12 @@ using SIGCM2.Application.Roles.Dtos;
 using SIGCM2.Application.Roles.Get;
 using SIGCM2.Application.Roles.List;
 using SIGCM2.Application.Roles.Update;
+using SIGCM2.Application.Secciones.Create;
+using SIGCM2.Application.Secciones.Deactivate;
+using SIGCM2.Application.Secciones.GetById;
+using SIGCM2.Application.Secciones.List;
+using SIGCM2.Application.Secciones.Reactivate;
+using SIGCM2.Application.Secciones.Update;
 using SIGCM2.Application.Usuarios.ChangeMyPassword;
 using SIGCM2.Application.Usuarios.Create;
 using SIGCM2.Application.Usuarios.Deactivate;
@@ -62,6 +74,22 @@ public static class DependencyInjection
         services.AddScoped<ICommandHandler<GetUsuarioPermisosQuery, UsuarioPermisosDto>, GetUsuarioPermisosQueryHandler>();
         services.AddScoped<ICommandHandler<UpdateUsuarioPermisosOverridesCommand, UsuarioPermisosDto>, UpdateUsuarioPermisosOverridesCommandHandler>();
 
+        // Medios (ADM-001)
+        services.AddScoped<ICommandHandler<CreateMedioCommand, MedioCreatedDto>, CreateMedioCommandHandler>();
+        services.AddScoped<ICommandHandler<UpdateMedioCommand, MedioUpdatedDto>, UpdateMedioCommandHandler>();
+        services.AddScoped<ICommandHandler<DeactivateMedioCommand, MedioStatusDto>, DeactivateMedioCommandHandler>();
+        services.AddScoped<ICommandHandler<ReactivateMedioCommand, MedioStatusDto>, ReactivateMedioCommandHandler>();
+        services.AddScoped<ICommandHandler<ListMediosQuery, PagedResult<MedioListItemDto>>, ListMediosQueryHandler>();
+        services.AddScoped<ICommandHandler<GetMedioByIdQuery, MedioDetailDto>, GetMedioByIdQueryHandler>();
+
+        // Secciones (ADM-001)
+        services.AddScoped<ICommandHandler<CreateSeccionCommand, SeccionCreatedDto>, CreateSeccionCommandHandler>();
+        services.AddScoped<ICommandHandler<UpdateSeccionCommand, SeccionUpdatedDto>, UpdateSeccionCommandHandler>();
+        services.AddScoped<ICommandHandler<DeactivateSeccionCommand, SeccionStatusDto>, DeactivateSeccionCommandHandler>();
+        services.AddScoped<ICommandHandler<ReactivateSeccionCommand, SeccionStatusDto>, ReactivateSeccionCommandHandler>();
+        services.AddScoped<ICommandHandler<ListSeccionesQuery, PagedResult<SeccionListItemDto>>, ListSeccionesQueryHandler>();
+        services.AddScoped<ICommandHandler<GetSeccionByIdQuery, SeccionDetailDto>, GetSeccionByIdQueryHandler>();
+
         // FluentValidation validators (scans entire Application assembly)
         services.AddValidatorsFromAssemblyContaining<LoginCommandValidator>();
 

src/api/SIGCM2.Application/Medios/Create/CreateMedioCommand.cs

@@ -0,0 +1,9 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.Create;
+
+public sealed record CreateMedioCommand(
+    string Codigo,
+    string Nombre,
+    TipoMedio Tipo,
+    int? PlataformaEmpresaId);

src/api/SIGCM2.Application/Medios/Create/CreateMedioCommandHandler.cs

@@ -0,0 +1,63 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Medios.Create;
+
+public sealed class CreateMedioCommandHandler : ICommandHandler<CreateMedioCommand, MedioCreatedDto>
+{
+    private readonly IMedioRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public CreateMedioCommandHandler(IMedioRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<MedioCreatedDto> Handle(CreateMedioCommand command)
+    {
+        var codigoNorm = command.Codigo.ToUpperInvariant();
+
+        var exists = await _repo.ExistsByCodigoAsync(codigoNorm);
+        if (exists)
+            throw new MedioCodigoDuplicadoException(codigoNorm);
+
+        var medio = Medio.ForCreation(codigoNorm, command.Nombre, command.Tipo, command.PlataformaEmpresaId);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        var newId = await _repo.AddAsync(medio);
+
+        await _audit.LogAsync(
+            action: "medio.create",
+            targetType: "Medio",
+            targetId: newId.ToString(),
+            metadata: new
+            {
+                after = new
+                {
+                    medio.Codigo,
+                    medio.Nombre,
+                    medio.Tipo,
+                    medio.PlataformaEmpresaId,
+                },
+            });
+
+        tx.Complete();
+
+        return new MedioCreatedDto(
+            Id: newId,
+            Codigo: medio.Codigo,
+            Nombre: medio.Nombre,
+            Tipo: medio.Tipo,
+            PlataformaEmpresaId: medio.PlataformaEmpresaId,
+            Activo: medio.Activo);
+    }
+}

src/api/SIGCM2.Application/Medios/Create/CreateMedioCommandValidator.cs

@@ -0,0 +1,25 @@
+using FluentValidation;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.Create;
+
+public sealed class CreateMedioCommandValidator : AbstractValidator<CreateMedioCommand>
+{
+    private const int CodigoMaxLength = 30;
+    private const int NombreMaxLength = 100;
+
+    public CreateMedioCommandValidator()
+    {
+        RuleFor(x => x.Codigo)
+            .NotEmpty().WithMessage("El código es requerido.")
+            .MaximumLength(CodigoMaxLength).WithMessage($"El código no puede superar los {CodigoMaxLength} caracteres.")
+            .Matches(@"^[A-Za-z0-9_]+$").WithMessage("El código solo puede contener letras, dígitos y guiones bajos.");
+
+        RuleFor(x => x.Nombre)
+            .NotEmpty().WithMessage("El nombre es requerido.")
+            .MaximumLength(NombreMaxLength).WithMessage($"El nombre no puede superar los {NombreMaxLength} caracteres.");
+
+        RuleFor(x => x.Tipo)
+            .IsInEnum().WithMessage("El tipo de medio no es válido.");
+    }
+}

src/api/SIGCM2.Application/Medios/Create/MedioCreatedDto.cs

@@ -0,0 +1,11 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.Create;
+
+public sealed record MedioCreatedDto(
+    int Id,
+    string Codigo,
+    string Nombre,
+    TipoMedio Tipo,
+    int? PlataformaEmpresaId,
+    bool Activo);

src/api/SIGCM2.Application/Medios/Deactivate/DeactivateMedioCommand.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Medios.Deactivate;
+
+public sealed record DeactivateMedioCommand(int Id);

src/api/SIGCM2.Application/Medios/Deactivate/DeactivateMedioCommandHandler.cs

@@ -0,0 +1,48 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Medios.Deactivate;
+
+public sealed class DeactivateMedioCommandHandler : ICommandHandler<DeactivateMedioCommand, MedioStatusDto>
+{
+    private readonly IMedioRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public DeactivateMedioCommandHandler(IMedioRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<MedioStatusDto> Handle(DeactivateMedioCommand command)
+    {
+        var target = await _repo.GetByIdAsync(command.Id)
+            ?? throw new MedioNotFoundException(command.Id);
+
+        // Idempotent: already inactive → return as-is without writing an audit event
+        if (!target.Activo)
+            return new MedioStatusDto(target.Id, target.Codigo, target.Activo);
+
+        var updated = target.WithActivo(false);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        await _repo.UpdateAsync(updated);
+
+        await _audit.LogAsync(
+            action: "medio.deactivate",
+            targetType: "Medio",
+            targetId: command.Id.ToString());
+
+        tx.Complete();
+
+        return new MedioStatusDto(updated.Id, updated.Codigo, updated.Activo);
+    }
+}

src/api/SIGCM2.Application/Medios/Deactivate/MedioStatusDto.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Medios.Deactivate;
+
+public sealed record MedioStatusDto(int Id, string Codigo, bool Activo);

src/api/SIGCM2.Application/Medios/GetById/GetMedioByIdQuery.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Medios.GetById;
+
+public sealed record GetMedioByIdQuery(int Id);

src/api/SIGCM2.Application/Medios/GetById/GetMedioByIdQueryHandler.cs

@@ -0,0 +1,31 @@
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Medios.GetById;
+
+public sealed class GetMedioByIdQueryHandler : ICommandHandler<GetMedioByIdQuery, MedioDetailDto>
+{
+    private readonly IMedioRepository _repo;
+
+    public GetMedioByIdQueryHandler(IMedioRepository repo)
+    {
+        _repo = repo;
+    }
+
+    public async Task<MedioDetailDto> Handle(GetMedioByIdQuery query)
+    {
+        var medio = await _repo.GetByIdAsync(query.Id)
+            ?? throw new MedioNotFoundException(query.Id);
+
+        return new MedioDetailDto(
+            Id: medio.Id,
+            Codigo: medio.Codigo,
+            Nombre: medio.Nombre,
+            Tipo: medio.Tipo,
+            PlataformaEmpresaId: medio.PlataformaEmpresaId,
+            Activo: medio.Activo,
+            FechaCreacion: medio.FechaCreacion,
+            FechaModificacion: medio.FechaModificacion);
+    }
+}

src/api/SIGCM2.Application/Medios/GetById/MedioDetailDto.cs

@@ -0,0 +1,13 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.GetById;
+
+public sealed record MedioDetailDto(
+    int Id,
+    string Codigo,
+    string Nombre,
+    TipoMedio Tipo,
+    int? PlataformaEmpresaId,
+    bool Activo,
+    DateTime FechaCreacion,
+    DateTime? FechaModificacion);

src/api/SIGCM2.Application/Medios/List/ListMediosQuery.cs

@@ -0,0 +1,10 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.List;
+
+public sealed record ListMediosQuery(
+    int Page = 1,
+    int PageSize = 20,
+    bool? Activo = true,
+    TipoMedio? Tipo = null,
+    string? Search = null);

src/api/SIGCM2.Application/Medios/List/ListMediosQueryHandler.cs

@@ -0,0 +1,31 @@
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Common;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.List;
+
+public sealed class ListMediosQueryHandler : ICommandHandler<ListMediosQuery, PagedResult<MedioListItemDto>>
+{
+    private readonly IMedioRepository _repo;
+
+    public ListMediosQueryHandler(IMedioRepository repo)
+    {
+        _repo = repo;
+    }
+
+    public async Task<PagedResult<MedioListItemDto>> Handle(ListMediosQuery query)
+    {
+        var page = Math.Max(1, query.Page);
+        var pageSize = Math.Clamp(query.PageSize, 1, 100);
+
+        var repoQuery = new MediosQuery(page, pageSize, query.Activo, query.Tipo, query.Search);
+        var paged = await _repo.GetPagedAsync(repoQuery);
+
+        var items = paged.Items
+            .Select(m => new MedioListItemDto(m.Id, m.Codigo, m.Nombre, m.Tipo, m.PlataformaEmpresaId, m.Activo))
+            .ToList();
+
+        return new PagedResult<MedioListItemDto>(items, paged.Page, paged.PageSize, paged.Total);
+    }
+}

src/api/SIGCM2.Application/Medios/List/MedioListItemDto.cs

@@ -0,0 +1,11 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.List;
+
+public sealed record MedioListItemDto(
+    int Id,
+    string Codigo,
+    string Nombre,
+    TipoMedio Tipo,
+    int? PlataformaEmpresaId,
+    bool Activo);

src/api/SIGCM2.Application/Medios/Reactivate/ReactivateMedioCommand.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Medios.Reactivate;
+
+public sealed record ReactivateMedioCommand(int Id);

src/api/SIGCM2.Application/Medios/Reactivate/ReactivateMedioCommandHandler.cs

@@ -0,0 +1,49 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Medios.Deactivate;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Medios.Reactivate;
+
+public sealed class ReactivateMedioCommandHandler : ICommandHandler<ReactivateMedioCommand, MedioStatusDto>
+{
+    private readonly IMedioRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public ReactivateMedioCommandHandler(IMedioRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<MedioStatusDto> Handle(ReactivateMedioCommand command)
+    {
+        var target = await _repo.GetByIdAsync(command.Id)
+            ?? throw new MedioNotFoundException(command.Id);
+
+        // Idempotent: already active → return as-is without writing an audit event
+        if (target.Activo)
+            return new MedioStatusDto(target.Id, target.Codigo, target.Activo);
+
+        var updated = target.WithActivo(true);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        await _repo.UpdateAsync(updated);
+
+        await _audit.LogAsync(
+            action: "medio.reactivate",
+            targetType: "Medio",
+            targetId: command.Id.ToString());
+
+        tx.Complete();
+
+        return new MedioStatusDto(updated.Id, updated.Codigo, updated.Activo);
+    }
+}

src/api/SIGCM2.Application/Medios/Update/MedioUpdatedDto.cs

@@ -0,0 +1,11 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.Update;
+
+public sealed record MedioUpdatedDto(
+    int Id,
+    string Codigo,
+    string Nombre,
+    TipoMedio Tipo,
+    int? PlataformaEmpresaId,
+    bool Activo);

src/api/SIGCM2.Application/Medios/Update/UpdateMedioCommand.cs

@@ -0,0 +1,9 @@
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Medios.Update;
+
+public sealed record UpdateMedioCommand(
+    int Id,
+    string Nombre,
+    TipoMedio Tipo,
+    int? PlataformaEmpresaId);

src/api/SIGCM2.Application/Medios/Update/UpdateMedioCommandHandler.cs

@@ -0,0 +1,55 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Medios.Update;
+
+public sealed class UpdateMedioCommandHandler : ICommandHandler<UpdateMedioCommand, MedioUpdatedDto>
+{
+    private readonly IMedioRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public UpdateMedioCommandHandler(IMedioRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<MedioUpdatedDto> Handle(UpdateMedioCommand command)
+    {
+        var target = await _repo.GetByIdAsync(command.Id)
+            ?? throw new MedioNotFoundException(command.Id);
+
+        var updated = target.WithUpdatedProfile(command.Nombre, command.Tipo, command.PlataformaEmpresaId);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        await _repo.UpdateAsync(updated);
+
+        await _audit.LogAsync(
+            action: "medio.update",
+            targetType: "Medio",
+            targetId: command.Id.ToString(),
+            metadata: new
+            {
+                before = new { target.Nombre, target.Tipo, target.PlataformaEmpresaId },
+                after = new { updated.Nombre, updated.Tipo, updated.PlataformaEmpresaId },
+            });
+
+        tx.Complete();
+
+        return new MedioUpdatedDto(
+            Id: updated.Id,
+            Codigo: updated.Codigo,
+            Nombre: updated.Nombre,
+            Tipo: updated.Tipo,
+            PlataformaEmpresaId: updated.PlataformaEmpresaId,
+            Activo: updated.Activo);
+    }
+}

src/api/SIGCM2.Application/Medios/Update/UpdateMedioCommandValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+
+namespace SIGCM2.Application.Medios.Update;
+
+public sealed class UpdateMedioCommandValidator : AbstractValidator<UpdateMedioCommand>
+{
+    private const int NombreMaxLength = 100;
+
+    public UpdateMedioCommandValidator()
+    {
+        RuleFor(x => x.Id)
+            .GreaterThan(0).WithMessage("El id debe ser mayor a 0.");
+
+        RuleFor(x => x.Nombre)
+            .NotEmpty().WithMessage("El nombre es requerido.")
+            .MaximumLength(NombreMaxLength).WithMessage($"El nombre no puede superar los {NombreMaxLength} caracteres.");
+
+        RuleFor(x => x.Tipo)
+            .IsInEnum().WithMessage("El tipo de medio no es válido.");
+    }
+}

src/api/SIGCM2.Application/Secciones/Create/CreateSeccionCommand.cs

@@ -0,0 +1,7 @@
+namespace SIGCM2.Application.Secciones.Create;
+
+public sealed record CreateSeccionCommand(
+    int MedioId,
+    string Codigo,
+    string Nombre,
+    string Tipo);

src/api/SIGCM2.Application/Secciones/Create/CreateSeccionCommandHandler.cs

@@ -0,0 +1,68 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Secciones.Create;
+
+public sealed class CreateSeccionCommandHandler : ICommandHandler<CreateSeccionCommand, SeccionCreatedDto>
+{
+    private readonly ISeccionRepository _repo;
+    private readonly IMedioRepository _medioRepo;
+    private readonly IAuditLogger _audit;
+
+    public CreateSeccionCommandHandler(ISeccionRepository repo, IMedioRepository medioRepo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _medioRepo = medioRepo;
+        _audit = audit;
+    }
+
+    public async Task<SeccionCreatedDto> Handle(CreateSeccionCommand command)
+    {
+        // Validate medio exists and is active (REQ-SEC-001)
+        var medio = await _medioRepo.GetByIdAsync(command.MedioId);
+        if (medio is null || !medio.Activo)
+            throw new MedioNotFoundException(command.MedioId);
+
+        var exists = await _repo.ExistsByCodigoInMedioAsync(command.MedioId, command.Codigo);
+        if (exists)
+            throw new SeccionCodigoDuplicadoEnMedioException(command.MedioId, command.Codigo);
+
+        var seccion = Seccion.ForCreation(command.MedioId, command.Codigo, command.Nombre, command.Tipo);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        var newId = await _repo.AddAsync(seccion);
+
+        await _audit.LogAsync(
+            action: "seccion.create",
+            targetType: "Seccion",
+            targetId: newId.ToString(),
+            metadata: new
+            {
+                after = new
+                {
+                    seccion.MedioId,
+                    seccion.Codigo,
+                    seccion.Nombre,
+                    seccion.Tipo,
+                },
+            });
+
+        tx.Complete();
+
+        return new SeccionCreatedDto(
+            Id: newId,
+            MedioId: seccion.MedioId,
+            Codigo: seccion.Codigo,
+            Nombre: seccion.Nombre,
+            Tipo: seccion.Tipo,
+            Activo: seccion.Activo);
+    }
+}

src/api/SIGCM2.Application/Secciones/Create/CreateSeccionCommandValidator.cs

@@ -0,0 +1,29 @@
+using FluentValidation;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Secciones.Create;
+
+public sealed class CreateSeccionCommandValidator : AbstractValidator<CreateSeccionCommand>
+{
+    private const int CodigoMaxLength = 30;
+    private const int NombreMaxLength = 100;
+
+    public CreateSeccionCommandValidator()
+    {
+        RuleFor(x => x.MedioId)
+            .GreaterThan(0).WithMessage("El medioId debe ser mayor a 0.");
+
+        RuleFor(x => x.Codigo)
+            .NotEmpty().WithMessage("El código es requerido.")
+            .MaximumLength(CodigoMaxLength).WithMessage($"El código no puede superar los {CodigoMaxLength} caracteres.");
+
+        RuleFor(x => x.Nombre)
+            .NotEmpty().WithMessage("El nombre es requerido.")
+            .MaximumLength(NombreMaxLength).WithMessage($"El nombre no puede superar los {NombreMaxLength} caracteres.");
+
+        RuleFor(x => x.Tipo)
+            .NotEmpty().WithMessage("El tipo es requerido.")
+            .Must(t => TipoSeccion.AllowedTipos.Contains(t))
+            .WithMessage($"El tipo debe ser uno de: {string.Join(", ", TipoSeccion.AllowedTipos)}.");
+    }
+}

src/api/SIGCM2.Application/Secciones/Create/SeccionCreatedDto.cs

@@ -0,0 +1,9 @@
+namespace SIGCM2.Application.Secciones.Create;
+
+public sealed record SeccionCreatedDto(
+    int Id,
+    int MedioId,
+    string Codigo,
+    string Nombre,
+    string Tipo,
+    bool Activo);

src/api/SIGCM2.Application/Secciones/Deactivate/DeactivateSeccionCommand.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Secciones.Deactivate;
+
+public sealed record DeactivateSeccionCommand(int Id);

src/api/SIGCM2.Application/Secciones/Deactivate/DeactivateSeccionCommandHandler.cs

@@ -0,0 +1,48 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Secciones.Deactivate;
+
+public sealed class DeactivateSeccionCommandHandler : ICommandHandler<DeactivateSeccionCommand, SeccionStatusDto>
+{
+    private readonly ISeccionRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public DeactivateSeccionCommandHandler(ISeccionRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<SeccionStatusDto> Handle(DeactivateSeccionCommand command)
+    {
+        var target = await _repo.GetByIdAsync(command.Id)
+            ?? throw new SeccionNotFoundException(command.Id);
+
+        // Idempotent: already inactive → return as-is without writing an audit event
+        if (!target.Activo)
+            return new SeccionStatusDto(target.Id, target.Codigo, target.Activo);
+
+        var updated = target.WithActivo(false);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        await _repo.UpdateAsync(updated);
+
+        await _audit.LogAsync(
+            action: "seccion.deactivate",
+            targetType: "Seccion",
+            targetId: command.Id.ToString());
+
+        tx.Complete();
+
+        return new SeccionStatusDto(updated.Id, updated.Codigo, updated.Activo);
+    }
+}

src/api/SIGCM2.Application/Secciones/Deactivate/SeccionStatusDto.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Secciones.Deactivate;
+
+public sealed record SeccionStatusDto(int Id, string Codigo, bool Activo);

src/api/SIGCM2.Application/Secciones/GetById/GetSeccionByIdQuery.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Secciones.GetById;
+
+public sealed record GetSeccionByIdQuery(int Id);

src/api/SIGCM2.Application/Secciones/GetById/GetSeccionByIdQueryHandler.cs

@@ -0,0 +1,31 @@
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Secciones.GetById;
+
+public sealed class GetSeccionByIdQueryHandler : ICommandHandler<GetSeccionByIdQuery, SeccionDetailDto>
+{
+    private readonly ISeccionRepository _repo;
+
+    public GetSeccionByIdQueryHandler(ISeccionRepository repo)
+    {
+        _repo = repo;
+    }
+
+    public async Task<SeccionDetailDto> Handle(GetSeccionByIdQuery query)
+    {
+        var seccion = await _repo.GetByIdAsync(query.Id)
+            ?? throw new SeccionNotFoundException(query.Id);
+
+        return new SeccionDetailDto(
+            Id: seccion.Id,
+            MedioId: seccion.MedioId,
+            Codigo: seccion.Codigo,
+            Nombre: seccion.Nombre,
+            Tipo: seccion.Tipo,
+            Activo: seccion.Activo,
+            FechaCreacion: seccion.FechaCreacion,
+            FechaModificacion: seccion.FechaModificacion);
+    }
+}

src/api/SIGCM2.Application/Secciones/GetById/SeccionDetailDto.cs

@@ -0,0 +1,11 @@
+namespace SIGCM2.Application.Secciones.GetById;
+
+public sealed record SeccionDetailDto(
+    int Id,
+    int MedioId,
+    string Codigo,
+    string Nombre,
+    string Tipo,
+    bool Activo,
+    DateTime FechaCreacion,
+    DateTime? FechaModificacion);

src/api/SIGCM2.Application/Secciones/List/ListSeccionesQuery.cs

@@ -0,0 +1,9 @@
+namespace SIGCM2.Application.Secciones.List;
+
+public sealed record ListSeccionesQuery(
+    int Page = 1,
+    int PageSize = 20,
+    int? MedioId = null,
+    string? Tipo = null,
+    bool? Activo = true,
+    string? Search = null);

src/api/SIGCM2.Application/Secciones/List/ListSeccionesQueryHandler.cs

@@ -0,0 +1,30 @@
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Common;
+
+namespace SIGCM2.Application.Secciones.List;
+
+public sealed class ListSeccionesQueryHandler : ICommandHandler<ListSeccionesQuery, PagedResult<SeccionListItemDto>>
+{
+    private readonly ISeccionRepository _repo;
+
+    public ListSeccionesQueryHandler(ISeccionRepository repo)
+    {
+        _repo = repo;
+    }
+
+    public async Task<PagedResult<SeccionListItemDto>> Handle(ListSeccionesQuery query)
+    {
+        var page = Math.Max(1, query.Page);
+        var pageSize = Math.Clamp(query.PageSize, 1, 100);
+
+        var repoQuery = new SeccionesQuery(page, pageSize, query.MedioId, query.Tipo, query.Activo, query.Search);
+        var paged = await _repo.GetPagedAsync(repoQuery);
+
+        var items = paged.Items
+            .Select(s => new SeccionListItemDto(s.Id, s.MedioId, s.Codigo, s.Nombre, s.Tipo, s.Activo))
+            .ToList();
+
+        return new PagedResult<SeccionListItemDto>(items, paged.Page, paged.PageSize, paged.Total);
+    }
+}

src/api/SIGCM2.Application/Secciones/List/SeccionListItemDto.cs

@@ -0,0 +1,9 @@
+namespace SIGCM2.Application.Secciones.List;
+
+public sealed record SeccionListItemDto(
+    int Id,
+    int MedioId,
+    string Codigo,
+    string Nombre,
+    string Tipo,
+    bool Activo);

src/api/SIGCM2.Application/Secciones/Reactivate/ReactivateSeccionCommand.cs

@@ -0,0 +1,3 @@
+namespace SIGCM2.Application.Secciones.Reactivate;
+
+public sealed record ReactivateSeccionCommand(int Id);

src/api/SIGCM2.Application/Secciones/Reactivate/ReactivateSeccionCommandHandler.cs

@@ -0,0 +1,49 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Secciones.Deactivate;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Secciones.Reactivate;
+
+public sealed class ReactivateSeccionCommandHandler : ICommandHandler<ReactivateSeccionCommand, SeccionStatusDto>
+{
+    private readonly ISeccionRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public ReactivateSeccionCommandHandler(ISeccionRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<SeccionStatusDto> Handle(ReactivateSeccionCommand command)
+    {
+        var target = await _repo.GetByIdAsync(command.Id)
+            ?? throw new SeccionNotFoundException(command.Id);
+
+        // Idempotent: already active → return as-is without writing an audit event
+        if (target.Activo)
+            return new SeccionStatusDto(target.Id, target.Codigo, target.Activo);
+
+        var updated = target.WithActivo(true);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        await _repo.UpdateAsync(updated);
+
+        await _audit.LogAsync(
+            action: "seccion.reactivate",
+            targetType: "Seccion",
+            targetId: command.Id.ToString());
+
+        tx.Complete();
+
+        return new SeccionStatusDto(updated.Id, updated.Codigo, updated.Activo);
+    }
+}

src/api/SIGCM2.Application/Secciones/Update/SeccionUpdatedDto.cs

@@ -0,0 +1,9 @@
+namespace SIGCM2.Application.Secciones.Update;
+
+public sealed record SeccionUpdatedDto(
+    int Id,
+    int MedioId,
+    string Codigo,
+    string Nombre,
+    string Tipo,
+    bool Activo);

src/api/SIGCM2.Application/Secciones/Update/UpdateSeccionCommand.cs

@@ -0,0 +1,6 @@
+namespace SIGCM2.Application.Secciones.Update;
+
+public sealed record UpdateSeccionCommand(
+    int Id,
+    string Nombre,
+    string Tipo);

src/api/SIGCM2.Application/Secciones/Update/UpdateSeccionCommandHandler.cs

@@ -0,0 +1,55 @@
+using System.Transactions;
+using SIGCM2.Application.Abstractions;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Secciones.Update;
+
+public sealed class UpdateSeccionCommandHandler : ICommandHandler<UpdateSeccionCommand, SeccionUpdatedDto>
+{
+    private readonly ISeccionRepository _repo;
+    private readonly IAuditLogger _audit;
+
+    public UpdateSeccionCommandHandler(ISeccionRepository repo, IAuditLogger audit)
+    {
+        _repo = repo;
+        _audit = audit;
+    }
+
+    public async Task<SeccionUpdatedDto> Handle(UpdateSeccionCommand command)
+    {
+        var target = await _repo.GetByIdAsync(command.Id)
+            ?? throw new SeccionNotFoundException(command.Id);
+
+        var updated = target.WithUpdatedProfile(command.Nombre, command.Tipo);
+
+        using var tx = new TransactionScope(
+            TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted },
+            TransactionScopeAsyncFlowOption.Enabled);
+
+        await _repo.UpdateAsync(updated);
+
+        await _audit.LogAsync(
+            action: "seccion.update",
+            targetType: "Seccion",
+            targetId: command.Id.ToString(),
+            metadata: new
+            {
+                before = new { target.Nombre, target.Tipo },
+                after = new { updated.Nombre, updated.Tipo },
+            });
+
+        tx.Complete();
+
+        return new SeccionUpdatedDto(
+            Id: updated.Id,
+            MedioId: updated.MedioId,
+            Codigo: updated.Codigo,
+            Nombre: updated.Nombre,
+            Tipo: updated.Tipo,
+            Activo: updated.Activo);
+    }
+}

src/api/SIGCM2.Application/Secciones/Update/UpdateSeccionCommandValidator.cs

@@ -0,0 +1,24 @@
+using FluentValidation;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Secciones.Update;
+
+public sealed class UpdateSeccionCommandValidator : AbstractValidator<UpdateSeccionCommand>
+{
+    private const int NombreMaxLength = 100;
+
+    public UpdateSeccionCommandValidator()
+    {
+        RuleFor(x => x.Id)
+            .GreaterThan(0).WithMessage("El id debe ser mayor a 0.");
+
+        RuleFor(x => x.Nombre)
+            .NotEmpty().WithMessage("El nombre es requerido.")
+            .MaximumLength(NombreMaxLength).WithMessage($"El nombre no puede superar los {NombreMaxLength} caracteres.");
+
+        RuleFor(x => x.Tipo)
+            .NotEmpty().WithMessage("El tipo es requerido.")
+            .Must(t => TipoSeccion.AllowedTipos.Contains(t))
+            .WithMessage($"El tipo debe ser uno de: {string.Join(", ", TipoSeccion.AllowedTipos)}.");
+    }
+}

src/api/SIGCM2.Domain/Entities/TipoSeccion.cs

@@ -0,0 +1,10 @@
+namespace SIGCM2.Domain.Entities;
+
+/// <summary>
+/// Allowed string values for Seccion.Tipo.
+/// Enforced at application layer (validator) and database layer (CHECK constraint).
+/// </summary>
+public static class TipoSeccion
+{
+    public static readonly string[] AllowedTipos = { "clasificados", "notables", "suplementos" };
+}

tests/SIGCM2.Application.Tests/Medios/Create/CreateMedioCommandHandlerTests.cs

@@ -0,0 +1,113 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Medios.Create;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Medios.Create;
+
+public class CreateMedioCommandHandlerTests
+{
+    private readonly IMedioRepository _repo = Substitute.For<IMedioRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly CreateMedioCommandHandler _handler;
+
+    private static CreateMedioCommand ValidCommand() => new(
+        Codigo: "DIARIO_LA_VOZ",
+        Nombre: "Diario La Voz",
+        Tipo: TipoMedio.Diario,
+        PlataformaEmpresaId: null);
+
+    public CreateMedioCommandHandlerTests()
+    {
+        _handler = new CreateMedioCommandHandler(_repo, _audit);
+        _repo.ExistsByCodigoAsync(Arg.Any<string>(), Arg.Any<CancellationToken>()).Returns(false);
+        _repo.AddAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>()).Returns(1);
+    }
+
+    // ── duplicate → throws ───────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_DuplicateCodigo_ThrowsMedioCodigoDuplicadoException()
+    {
+        _repo.ExistsByCodigoAsync("DIARIO_LA_VOZ", Arg.Any<CancellationToken>()).Returns(true);
+
+        await Assert.ThrowsAsync<MedioCodigoDuplicadoException>(
+            () => _handler.Handle(ValidCommand()));
+    }
+
+    [Fact]
+    public async Task Handle_DuplicateCodigo_DoesNotCallAddAsync()
+    {
+        _repo.ExistsByCodigoAsync(Arg.Any<string>(), Arg.Any<CancellationToken>()).Returns(true);
+
+        try { await _handler.Handle(ValidCommand()); } catch (MedioCodigoDuplicadoException) { }
+
+        await _repo.DidNotReceive().AddAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>());
+    }
+
+    // ── happy path ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_HappyPath_ReturnsDtoWithIdFromRepository()
+    {
+        _repo.AddAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>()).Returns(42);
+
+        var result = await _handler.Handle(ValidCommand());
+
+        Assert.Equal(42, result.Id);
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_DtoContainsCorrectFields()
+    {
+        _repo.AddAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>()).Returns(5);
+
+        var result = await _handler.Handle(ValidCommand());
+
+        Assert.Equal("DIARIO_LA_VOZ", result.Codigo);
+        Assert.Equal("Diario La Voz", result.Nombre);
+        Assert.Equal(TipoMedio.Diario, result.Tipo);
+        Assert.Null(result.PlataformaEmpresaId);
+        Assert.True(result.Activo);
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_NormalizesCodigoToUppercase()
+    {
+        var cmd = new CreateMedioCommand("diario_la_voz", "Diario La Voz", TipoMedio.Diario, null);
+
+        await _handler.Handle(cmd);
+
+        await _repo.Received(1).AddAsync(
+            Arg.Is<Medio>(m => m.Codigo == "DIARIO_LA_VOZ"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_CallsAuditLogWithCreateAction()
+    {
+        _repo.AddAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>()).Returns(7);
+
+        await _handler.Handle(ValidCommand());
+
+        await _audit.Received(1).LogAsync(
+            action: "medio.create",
+            targetType: "Medio",
+            targetId: "7",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_ChecksNormalizedCodigoForDuplicate()
+    {
+        var cmd = new CreateMedioCommand("diario_la_voz", "Diario La Voz", TipoMedio.Diario, null);
+
+        await _handler.Handle(cmd);
+
+        // ExistsByCodigoAsync should be called with the uppercased version
+        await _repo.Received(1).ExistsByCodigoAsync("DIARIO_LA_VOZ", Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Medios/Deactivate/DeactivateMedioCommandHandlerTests.cs

@@ -0,0 +1,87 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Medios.Deactivate;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Medios.Deactivate;
+
+public class DeactivateMedioCommandHandlerTests
+{
+    private readonly IMedioRepository _repo = Substitute.For<IMedioRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly DeactivateMedioCommandHandler _handler;
+
+    private static Medio MakeMedio(int id = 1, bool activo = true)
+        => new(id, "COD" + id, "Nombre", TipoMedio.Diario, null, activo, DateTime.UtcNow, null);
+
+    public DeactivateMedioCommandHandlerTests()
+    {
+        _handler = new DeactivateMedioCommandHandler(_repo, _audit);
+    }
+
+    // ── not found → throws ──────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsMedioNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Medio?)null);
+
+        await Assert.ThrowsAsync<MedioNotFoundException>(
+            () => _handler.Handle(new DeactivateMedioCommand(999)));
+    }
+
+    // ── idempotent ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_AlreadyInactive_IsIdempotentAndDoesNotCallUpdateAsync()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, false));
+
+        await _handler.Handle(new DeactivateMedioCommand(1));
+
+        await _repo.DidNotReceive().UpdateAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_AlreadyInactive_DoesNotWriteAuditEvent()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, false));
+
+        await _handler.Handle(new DeactivateMedioCommand(1));
+
+        await _audit.DidNotReceive().LogAsync(
+            Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(),
+            Arg.Any<object?>(), Arg.Any<CancellationToken>());
+    }
+
+    // ── happy path ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_ActiveMedio_CallsUpdateAsyncWithInactiveEntity()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, true));
+
+        await _handler.Handle(new DeactivateMedioCommand(1));
+
+        await _repo.Received(1).UpdateAsync(
+            Arg.Is<Medio>(m => !m.Activo),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_ActiveMedio_WritesAuditWithDeactivateAction()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, true));
+
+        await _handler.Handle(new DeactivateMedioCommand(1));
+
+        await _audit.Received(1).LogAsync(
+            action: "medio.deactivate",
+            targetType: "Medio",
+            targetId: "1",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Medios/GetById/GetMedioByIdQueryHandlerTests.cs

@@ -0,0 +1,46 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Medios.GetById;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Medios.GetById;
+
+public class GetMedioByIdQueryHandlerTests
+{
+    private readonly IMedioRepository _repo = Substitute.For<IMedioRepository>();
+    private readonly GetMedioByIdQueryHandler _handler;
+
+    public GetMedioByIdQueryHandlerTests()
+    {
+        _handler = new GetMedioByIdQueryHandler(_repo);
+    }
+
+    private static Medio MakeMedio(int id) =>
+        new(id, "COD" + id, "Nombre " + id, TipoMedio.Radio, 10, true, DateTime.UtcNow, null);
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsMedioNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Medio?)null);
+
+        await Assert.ThrowsAsync<MedioNotFoundException>(
+            () => _handler.Handle(new GetMedioByIdQuery(999)));
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_ReturnsDtoWithCorrectFields()
+    {
+        var medio = MakeMedio(3);
+        _repo.GetByIdAsync(3, Arg.Any<CancellationToken>()).Returns(medio);
+
+        var result = await _handler.Handle(new GetMedioByIdQuery(3));
+
+        Assert.Equal(3, result.Id);
+        Assert.Equal("COD3", result.Codigo);
+        Assert.Equal("Nombre 3", result.Nombre);
+        Assert.Equal(TipoMedio.Radio, result.Tipo);
+        Assert.Equal(10, result.PlataformaEmpresaId);
+        Assert.True(result.Activo);
+    }
+}

tests/SIGCM2.Application.Tests/Medios/List/ListMediosQueryHandlerTests.cs

@@ -0,0 +1,65 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Common;
+using SIGCM2.Application.Medios.List;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Tests.Medios.List;
+
+public class ListMediosQueryHandlerTests
+{
+    private readonly IMedioRepository _repo = Substitute.For<IMedioRepository>();
+    private readonly ListMediosQueryHandler _handler;
+
+    public ListMediosQueryHandlerTests()
+    {
+        _handler = new ListMediosQueryHandler(_repo);
+    }
+
+    private static Medio MakeMedio(int id) =>
+        new(id, "COD" + id, "Medio " + id, TipoMedio.Diario, null, true, DateTime.UtcNow, null);
+
+    [Fact]
+    public async Task Handle_ReturnsPagedDtoItems()
+    {
+        var items = new List<Medio> { MakeMedio(1), MakeMedio(2) };
+        var pagedResult = new PagedResult<Medio>(items, 1, 20, 2);
+
+        _repo.GetPagedAsync(Arg.Any<MediosQuery>(), Arg.Any<CancellationToken>())
+            .Returns(pagedResult);
+
+        var query = new ListMediosQuery(1, 20, null, null, null);
+        var result = await _handler.Handle(query);
+
+        Assert.Equal(2, result.Total);
+        Assert.Equal(2, result.Items.Count);
+        Assert.Equal("COD1", result.Items[0].Codigo);
+        Assert.Equal("COD2", result.Items[1].Codigo);
+    }
+
+    [Fact]
+    public async Task Handle_ClampsPageSizeToMax100()
+    {
+        _repo.GetPagedAsync(Arg.Any<MediosQuery>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedResult<Medio>([], 1, 100, 0));
+
+        await _handler.Handle(new ListMediosQuery(1, 999, null, null, null));
+
+        await _repo.Received(1).GetPagedAsync(
+            Arg.Is<MediosQuery>(q => q.PageSize == 100),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_ClampsPageToMin1()
+    {
+        _repo.GetPagedAsync(Arg.Any<MediosQuery>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedResult<Medio>([], 1, 20, 0));
+
+        await _handler.Handle(new ListMediosQuery(0, 20, null, null, null));
+
+        await _repo.Received(1).GetPagedAsync(
+            Arg.Is<MediosQuery>(q => q.Page == 1),
+            Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Medios/Reactivate/ReactivateMedioCommandHandlerTests.cs

@@ -0,0 +1,88 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Medios.Deactivate;
+using SIGCM2.Application.Medios.Reactivate;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Medios.Reactivate;
+
+public class ReactivateMedioCommandHandlerTests
+{
+    private readonly IMedioRepository _repo = Substitute.For<IMedioRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly ReactivateMedioCommandHandler _handler;
+
+    private static Medio MakeMedio(int id = 1, bool activo = false)
+        => new(id, "COD" + id, "Nombre", TipoMedio.Diario, null, activo, DateTime.UtcNow, null);
+
+    public ReactivateMedioCommandHandlerTests()
+    {
+        _handler = new ReactivateMedioCommandHandler(_repo, _audit);
+    }
+
+    // ── not found → throws ──────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsMedioNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Medio?)null);
+
+        await Assert.ThrowsAsync<MedioNotFoundException>(
+            () => _handler.Handle(new ReactivateMedioCommand(999)));
+    }
+
+    // ── idempotent ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_AlreadyActive_IsIdempotentAndDoesNotCallUpdateAsync()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, true));
+
+        await _handler.Handle(new ReactivateMedioCommand(1));
+
+        await _repo.DidNotReceive().UpdateAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_AlreadyActive_DoesNotWriteAuditEvent()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, true));
+
+        await _handler.Handle(new ReactivateMedioCommand(1));
+
+        await _audit.DidNotReceive().LogAsync(
+            Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(),
+            Arg.Any<object?>(), Arg.Any<CancellationToken>());
+    }
+
+    // ── happy path ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_InactiveMedio_CallsUpdateAsyncWithActiveEntity()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, false));
+
+        await _handler.Handle(new ReactivateMedioCommand(1));
+
+        await _repo.Received(1).UpdateAsync(
+            Arg.Is<Medio>(m => m.Activo),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_InactiveMedio_WritesAuditWithReactivateAction()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, false));
+
+        await _handler.Handle(new ReactivateMedioCommand(1));
+
+        await _audit.Received(1).LogAsync(
+            action: "medio.reactivate",
+            targetType: "Medio",
+            targetId: "1",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Medios/Update/UpdateMedioCommandHandlerTests.cs

@@ -0,0 +1,83 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Medios.Update;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Medios.Update;
+
+public class UpdateMedioCommandHandlerTests
+{
+    private readonly IMedioRepository _repo = Substitute.For<IMedioRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly UpdateMedioCommandHandler _handler;
+
+    private static Medio MakeMedio(int id = 1, string nombre = "Original", TipoMedio tipo = TipoMedio.Diario, bool activo = true)
+        => new(id, "COD" + id, nombre, tipo, null, activo, DateTime.UtcNow, null);
+
+    private static UpdateMedioCommand ValidCommand(int id = 1) => new(
+        Id: id,
+        Nombre: "Nuevo Nombre",
+        Tipo: TipoMedio.Radio,
+        PlataformaEmpresaId: 5);
+
+    public UpdateMedioCommandHandlerTests()
+    {
+        _handler = new UpdateMedioCommandHandler(_repo, _audit);
+    }
+
+    // ── not found → throws ──────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsMedioNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Medio?)null);
+
+        await Assert.ThrowsAsync<MedioNotFoundException>(
+            () => _handler.Handle(new UpdateMedioCommand(999, "X", TipoMedio.Diario, null)));
+    }
+
+    // ── happy path ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_HappyPath_CallsUpdateAsyncOnce()
+    {
+        var medio = MakeMedio(1);
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(medio);
+
+        await _handler.Handle(ValidCommand(1));
+
+        await _repo.Received(1).UpdateAsync(Arg.Any<Medio>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_ReturnsDtoWithUpdatedFields()
+    {
+        var medio = MakeMedio(1, "Original", TipoMedio.Diario);
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(medio);
+
+        var result = await _handler.Handle(ValidCommand(1));
+
+        Assert.Equal(1, result.Id);
+        Assert.Equal("Nuevo Nombre", result.Nombre);
+        Assert.Equal(TipoMedio.Radio, result.Tipo);
+        Assert.Equal(5, result.PlataformaEmpresaId);
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_CallsAuditWithUpdateAction()
+    {
+        var medio = MakeMedio(1);
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(medio);
+
+        await _handler.Handle(ValidCommand(1));
+
+        await _audit.Received(1).LogAsync(
+            action: "medio.update",
+            targetType: "Medio",
+            targetId: "1",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Secciones/Create/CreateSeccionCommandHandlerTests.cs

@@ -0,0 +1,113 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Secciones.Create;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Secciones.Create;
+
+public class CreateSeccionCommandHandlerTests
+{
+    private readonly ISeccionRepository _repo = Substitute.For<ISeccionRepository>();
+    private readonly IMedioRepository _medioRepo = Substitute.For<IMedioRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly CreateSeccionCommandHandler _handler;
+
+    private static Medio MakeMedio(int id = 1, bool activo = true) =>
+        new(id, "COD" + id, "Medio " + id, TipoMedio.Diario, null, activo, DateTime.UtcNow, null);
+
+    private static CreateSeccionCommand ValidCommand() => new(
+        MedioId: 1,
+        Codigo: "CLASIFICADOS_LUNES",
+        Nombre: "Clasificados Lunes",
+        Tipo: "clasificados");
+
+    public CreateSeccionCommandHandlerTests()
+    {
+        _handler = new CreateSeccionCommandHandler(_repo, _medioRepo, _audit);
+        _medioRepo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1));
+        _repo.ExistsByCodigoInMedioAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>()).Returns(false);
+        _repo.AddAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>()).Returns(10);
+    }
+
+    // ── medio not found → throws ─────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_MedioNotFound_ThrowsMedioNotFoundException()
+    {
+        _medioRepo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns((Medio?)null);
+
+        await Assert.ThrowsAsync<MedioNotFoundException>(
+            () => _handler.Handle(ValidCommand()));
+    }
+
+    // ── duplicate codigo in medio → throws ──────────────────────────────────
+
+    [Fact]
+    public async Task Handle_DuplicateCodigoInMedio_ThrowsSeccionCodigoDuplicadoEnMedioException()
+    {
+        _repo.ExistsByCodigoInMedioAsync(1, "CLASIFICADOS_LUNES", Arg.Any<CancellationToken>()).Returns(true);
+
+        await Assert.ThrowsAsync<SeccionCodigoDuplicadoEnMedioException>(
+            () => _handler.Handle(ValidCommand()));
+    }
+
+    [Fact]
+    public async Task Handle_DuplicateCodigo_DoesNotCallAddAsync()
+    {
+        _repo.ExistsByCodigoInMedioAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>()).Returns(true);
+
+        try { await _handler.Handle(ValidCommand()); } catch (SeccionCodigoDuplicadoEnMedioException) { }
+
+        await _repo.DidNotReceive().AddAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>());
+    }
+
+    // ── happy path ───────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Handle_HappyPath_ReturnsDtoWithIdFromRepository()
+    {
+        _repo.AddAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>()).Returns(10);
+
+        var result = await _handler.Handle(ValidCommand());
+
+        Assert.Equal(10, result.Id);
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_DtoContainsCorrectFields()
+    {
+        var result = await _handler.Handle(ValidCommand());
+
+        Assert.Equal(1, result.MedioId);
+        Assert.Equal("CLASIFICADOS_LUNES", result.Codigo);
+        Assert.Equal("Clasificados Lunes", result.Nombre);
+        Assert.Equal("clasificados", result.Tipo);
+        Assert.True(result.Activo);
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_CallsAuditWithCreateAction()
+    {
+        _repo.AddAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>()).Returns(10);
+
+        await _handler.Handle(ValidCommand());
+
+        await _audit.Received(1).LogAsync(
+            action: "seccion.create",
+            targetType: "Seccion",
+            targetId: "10",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_InactiveMedio_ThrowsMedioNotFoundException()
+    {
+        _medioRepo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeMedio(1, false));
+
+        await Assert.ThrowsAsync<MedioNotFoundException>(
+            () => _handler.Handle(ValidCommand()));
+    }
+}

tests/SIGCM2.Application.Tests/Secciones/Deactivate/DeactivateSeccionCommandHandlerTests.cs

@@ -0,0 +1,81 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Secciones.Deactivate;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Secciones.Deactivate;
+
+public class DeactivateSeccionCommandHandlerTests
+{
+    private readonly ISeccionRepository _repo = Substitute.For<ISeccionRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly DeactivateSeccionCommandHandler _handler;
+
+    private static Seccion MakeSeccion(int id = 1, bool activo = true)
+        => new(id, 1, "COD" + id, "Nombre", "clasificados", activo, DateTime.UtcNow, null);
+
+    public DeactivateSeccionCommandHandlerTests()
+    {
+        _handler = new DeactivateSeccionCommandHandler(_repo, _audit);
+    }
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsSeccionNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Seccion?)null);
+
+        await Assert.ThrowsAsync<SeccionNotFoundException>(
+            () => _handler.Handle(new DeactivateSeccionCommand(999)));
+    }
+
+    [Fact]
+    public async Task Handle_AlreadyInactive_IsIdempotentAndDoesNotCallUpdateAsync()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, false));
+
+        await _handler.Handle(new DeactivateSeccionCommand(1));
+
+        await _repo.DidNotReceive().UpdateAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_AlreadyInactive_DoesNotWriteAuditEvent()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, false));
+
+        await _handler.Handle(new DeactivateSeccionCommand(1));
+
+        await _audit.DidNotReceive().LogAsync(
+            Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(),
+            Arg.Any<object?>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_ActiveSeccion_CallsUpdateAsyncWithInactiveEntity()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, true));
+
+        await _handler.Handle(new DeactivateSeccionCommand(1));
+
+        await _repo.Received(1).UpdateAsync(
+            Arg.Is<Seccion>(s => !s.Activo),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_ActiveSeccion_WritesAuditWithDeactivateAction()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, true));
+
+        await _handler.Handle(new DeactivateSeccionCommand(1));
+
+        await _audit.Received(1).LogAsync(
+            action: "seccion.deactivate",
+            targetType: "Seccion",
+            targetId: "1",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Secciones/GetById/GetSeccionByIdQueryHandlerTests.cs

@@ -0,0 +1,46 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Secciones.GetById;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Secciones.GetById;
+
+public class GetSeccionByIdQueryHandlerTests
+{
+    private readonly ISeccionRepository _repo = Substitute.For<ISeccionRepository>();
+    private readonly GetSeccionByIdQueryHandler _handler;
+
+    public GetSeccionByIdQueryHandlerTests()
+    {
+        _handler = new GetSeccionByIdQueryHandler(_repo);
+    }
+
+    private static Seccion MakeSeccion(int id) =>
+        new(id, 2, "COD" + id, "Nombre " + id, "suplementos", true, DateTime.UtcNow, null);
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsSeccionNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Seccion?)null);
+
+        await Assert.ThrowsAsync<SeccionNotFoundException>(
+            () => _handler.Handle(new GetSeccionByIdQuery(999)));
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_ReturnsDtoWithCorrectFields()
+    {
+        var seccion = MakeSeccion(5);
+        _repo.GetByIdAsync(5, Arg.Any<CancellationToken>()).Returns(seccion);
+
+        var result = await _handler.Handle(new GetSeccionByIdQuery(5));
+
+        Assert.Equal(5, result.Id);
+        Assert.Equal(2, result.MedioId);
+        Assert.Equal("COD5", result.Codigo);
+        Assert.Equal("Nombre 5", result.Nombre);
+        Assert.Equal("suplementos", result.Tipo);
+        Assert.True(result.Activo);
+    }
+}

tests/SIGCM2.Application.Tests/Secciones/List/ListSeccionesQueryHandlerTests.cs

@@ -0,0 +1,64 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Common;
+using SIGCM2.Application.Secciones.List;
+using SIGCM2.Domain.Entities;
+
+namespace SIGCM2.Application.Tests.Secciones.List;
+
+public class ListSeccionesQueryHandlerTests
+{
+    private readonly ISeccionRepository _repo = Substitute.For<ISeccionRepository>();
+    private readonly ListSeccionesQueryHandler _handler;
+
+    public ListSeccionesQueryHandlerTests()
+    {
+        _handler = new ListSeccionesQueryHandler(_repo);
+    }
+
+    private static Seccion MakeSeccion(int id) =>
+        new(id, 1, "COD" + id, "Seccion " + id, "clasificados", true, DateTime.UtcNow, null);
+
+    [Fact]
+    public async Task Handle_ReturnsPagedDtoItems()
+    {
+        var items = new List<Seccion> { MakeSeccion(1), MakeSeccion(2) };
+        var pagedResult = new PagedResult<Seccion>(items, 1, 20, 2);
+
+        _repo.GetPagedAsync(Arg.Any<SeccionesQuery>(), Arg.Any<CancellationToken>())
+            .Returns(pagedResult);
+
+        var query = new ListSeccionesQuery(1, 20, null, null, null, null);
+        var result = await _handler.Handle(query);
+
+        Assert.Equal(2, result.Total);
+        Assert.Equal(2, result.Items.Count);
+        Assert.Equal("COD1", result.Items[0].Codigo);
+    }
+
+    [Fact]
+    public async Task Handle_ClampsPageSizeToMax100()
+    {
+        _repo.GetPagedAsync(Arg.Any<SeccionesQuery>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedResult<Seccion>([], 1, 100, 0));
+
+        await _handler.Handle(new ListSeccionesQuery(1, 500, null, null, null, null));
+
+        await _repo.Received(1).GetPagedAsync(
+            Arg.Is<SeccionesQuery>(q => q.PageSize == 100),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_ClampsPageToMin1()
+    {
+        _repo.GetPagedAsync(Arg.Any<SeccionesQuery>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedResult<Seccion>([], 1, 20, 0));
+
+        await _handler.Handle(new ListSeccionesQuery(0, 20, null, null, null, null));
+
+        await _repo.Received(1).GetPagedAsync(
+            Arg.Is<SeccionesQuery>(q => q.Page == 1),
+            Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Secciones/Reactivate/ReactivateSeccionCommandHandlerTests.cs

@@ -0,0 +1,82 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Secciones.Deactivate;
+using SIGCM2.Application.Secciones.Reactivate;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Secciones.Reactivate;
+
+public class ReactivateSeccionCommandHandlerTests
+{
+    private readonly ISeccionRepository _repo = Substitute.For<ISeccionRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly ReactivateSeccionCommandHandler _handler;
+
+    private static Seccion MakeSeccion(int id = 1, bool activo = false)
+        => new(id, 1, "COD" + id, "Nombre", "clasificados", activo, DateTime.UtcNow, null);
+
+    public ReactivateSeccionCommandHandlerTests()
+    {
+        _handler = new ReactivateSeccionCommandHandler(_repo, _audit);
+    }
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsSeccionNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Seccion?)null);
+
+        await Assert.ThrowsAsync<SeccionNotFoundException>(
+            () => _handler.Handle(new ReactivateSeccionCommand(999)));
+    }
+
+    [Fact]
+    public async Task Handle_AlreadyActive_IsIdempotentAndDoesNotCallUpdateAsync()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, true));
+
+        await _handler.Handle(new ReactivateSeccionCommand(1));
+
+        await _repo.DidNotReceive().UpdateAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_AlreadyActive_DoesNotWriteAuditEvent()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, true));
+
+        await _handler.Handle(new ReactivateSeccionCommand(1));
+
+        await _audit.DidNotReceive().LogAsync(
+            Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(),
+            Arg.Any<object?>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_InactiveSeccion_CallsUpdateAsyncWithActiveEntity()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, false));
+
+        await _handler.Handle(new ReactivateSeccionCommand(1));
+
+        await _repo.Received(1).UpdateAsync(
+            Arg.Is<Seccion>(s => s.Activo),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_InactiveSeccion_WritesAuditWithReactivateAction()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, false));
+
+        await _handler.Handle(new ReactivateSeccionCommand(1));
+
+        await _audit.Received(1).LogAsync(
+            action: "seccion.reactivate",
+            targetType: "Seccion",
+            targetId: "1",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+}

tests/SIGCM2.Application.Tests/Secciones/Update/UpdateSeccionCommandHandlerTests.cs

@@ -0,0 +1,74 @@
+using NSubstitute;
+using SIGCM2.Application.Abstractions.Persistence;
+using SIGCM2.Application.Audit;
+using SIGCM2.Application.Secciones.Update;
+using SIGCM2.Domain.Entities;
+using SIGCM2.Domain.Exceptions;
+
+namespace SIGCM2.Application.Tests.Secciones.Update;
+
+public class UpdateSeccionCommandHandlerTests
+{
+    private readonly ISeccionRepository _repo = Substitute.For<ISeccionRepository>();
+    private readonly IAuditLogger _audit = Substitute.For<IAuditLogger>();
+    private readonly UpdateSeccionCommandHandler _handler;
+
+    private static Seccion MakeSeccion(int id = 1, string nombre = "Original", string tipo = "clasificados")
+        => new(id, 1, "COD" + id, nombre, tipo, true, DateTime.UtcNow, null);
+
+    private static UpdateSeccionCommand ValidCommand(int id = 1) => new(
+        Id: id,
+        Nombre: "Nuevo Nombre",
+        Tipo: "notables");
+
+    public UpdateSeccionCommandHandlerTests()
+    {
+        _handler = new UpdateSeccionCommandHandler(_repo, _audit);
+    }
+
+    [Fact]
+    public async Task Handle_NotFound_ThrowsSeccionNotFoundException()
+    {
+        _repo.GetByIdAsync(999, Arg.Any<CancellationToken>()).Returns((Seccion?)null);
+
+        await Assert.ThrowsAsync<SeccionNotFoundException>(
+            () => _handler.Handle(new UpdateSeccionCommand(999, "X", "clasificados")));
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_CallsUpdateAsyncOnce()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1));
+
+        await _handler.Handle(ValidCommand(1));
+
+        await _repo.Received(1).UpdateAsync(Arg.Any<Seccion>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_ReturnsDtoWithUpdatedFields()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1, "Original", "clasificados"));
+
+        var result = await _handler.Handle(ValidCommand(1));
+
+        Assert.Equal(1, result.Id);
+        Assert.Equal("Nuevo Nombre", result.Nombre);
+        Assert.Equal("notables", result.Tipo);
+    }
+
+    [Fact]
+    public async Task Handle_HappyPath_CallsAuditWithUpdateAction()
+    {
+        _repo.GetByIdAsync(1, Arg.Any<CancellationToken>()).Returns(MakeSeccion(1));
+
+        await _handler.Handle(ValidCommand(1));
+
+        await _audit.Received(1).LogAsync(
+            action: "seccion.update",
+            targetType: "Seccion",
+            targetId: "1",
+            metadata: Arg.Any<object?>(),
+            ct: Arg.Any<CancellationToken>());
+    }
+}