Migrate from Gin to Echo framework and add comprehensive integration tests

Major changes:
- Migrate all handlers from Gin to Echo framework
- Add new apperrors, echohelpers, and validator packages
- Update middleware for Echo compatibility
- Add ArchivedHandler to task categorization chain (archived tasks go to cancelled_tasks column)
- Add 6 new integration tests:
  - RecurringTaskLifecycle: NextDueDate advancement for weekly/monthly tasks
  - MultiUserSharing: Complex sharing with user removal
  - TaskStateTransitions: All state transitions and kanban column changes
  - DateBoundaryEdgeCases: Threshold boundary testing
  - CascadeOperations: Residence deletion cascade effects
  - MultiUserOperations: Shared residence collaboration
- Add single-purpose repository functions for kanban columns (GetOverdueTasks, GetDueSoonTasks, etc.)
- Fix RemoveUser route param mismatch (userId -> user_id)
- Fix determineExpectedColumn helper to correctly prioritize in_progress over overdue

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

internal/handlers/task_handler.go

@@ -1,18 +1,17 @@
 package handlers
 
 import (
-	"errors"
 	"mime/multipart"
 	"net/http"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/labstack/echo/v4"
 	"github.com/shopspring/decimal"
 
+	"github.com/treytartt/casera-api/internal/apperrors"
 	"github.com/treytartt/casera-api/internal/dto/requests"
-	"github.com/treytartt/casera-api/internal/i18n"
 	"github.com/treytartt/casera-api/internal/middleware"
 	"github.com/treytartt/casera-api/internal/models"
 	"github.com/treytartt/casera-api/internal/services"
@@ -33,55 +32,44 @@ func NewTaskHandler(taskService *services.TaskService, storageService *services.
 }
 
 // ListTasks handles GET /api/tasks/
-func (h *TaskHandler) ListTasks(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) ListTasks(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	response, err := h.taskService.ListTasks(user.ID, userNow)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // GetTask handles GET /api/tasks/:id/
-func (h *TaskHandler) GetTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) GetTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.GetTask(uint(taskID), user.ID)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // GetTasksByResidence handles GET /api/tasks/by-residence/:residence_id/
-func (h *TaskHandler) GetTasksByResidence(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) GetTasksByResidence(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	residenceID, err := strconv.ParseUint(c.Param("residence_id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_residence_id")})
-		return
+		return apperrors.BadRequest("error.invalid_residence_id")
 	}
 
 	daysThreshold := 30
-	if d := c.Query("days_threshold"); d != "" {
+	if d := c.QueryParam("days_threshold"); d != "" {
 		if parsed, err := strconv.Atoi(d); err == nil {
 			daysThreshold = parsed
 		}
@@ -89,352 +77,241 @@ func (h *TaskHandler) GetTasksByResidence(c *gin.Context) {
 
 	response, err := h.taskService.GetTasksByResidence(uint(residenceID), user.ID, daysThreshold, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrResidenceAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.residence_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // CreateTask handles POST /api/tasks/
-func (h *TaskHandler) CreateTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) CreateTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	var req requests.CreateTaskRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
+	if err := c.Bind(&req); err != nil {
+		return apperrors.BadRequest("error.invalid_request")
 	}
 
 	response, err := h.taskService.CreateTask(&req, user.ID, userNow)
 	if err != nil {
-		if errors.Is(err, services.ErrResidenceAccessDenied) {
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.residence_access_denied")})
-			return
-		}
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+		return err
 	}
-	c.JSON(http.StatusCreated, response)
+	return c.JSON(http.StatusCreated, response)
 }
 
 // UpdateTask handles PUT/PATCH /api/tasks/:id/
-func (h *TaskHandler) UpdateTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) UpdateTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	var req requests.UpdateTaskRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
+	if err := c.Bind(&req); err != nil {
+		return apperrors.BadRequest("error.invalid_request")
 	}
 
 	response, err := h.taskService.UpdateTask(uint(taskID), user.ID, &req, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // DeleteTask handles DELETE /api/tasks/:id/
-func (h *TaskHandler) DeleteTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) DeleteTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.DeleteTask(uint(taskID), user.ID)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // MarkInProgress handles POST /api/tasks/:id/mark-in-progress/
-func (h *TaskHandler) MarkInProgress(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) MarkInProgress(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.MarkInProgress(uint(taskID), user.ID, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // CancelTask handles POST /api/tasks/:id/cancel/
-func (h *TaskHandler) CancelTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) CancelTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.CancelTask(uint(taskID), user.ID, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		case errors.Is(err, services.ErrTaskAlreadyCancelled):
-			c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.task_already_cancelled")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // UncancelTask handles POST /api/tasks/:id/uncancel/
-func (h *TaskHandler) UncancelTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) UncancelTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.UncancelTask(uint(taskID), user.ID, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // ArchiveTask handles POST /api/tasks/:id/archive/
-func (h *TaskHandler) ArchiveTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) ArchiveTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.ArchiveTask(uint(taskID), user.ID, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		case errors.Is(err, services.ErrTaskAlreadyArchived):
-			c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.task_already_archived")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // UnarchiveTask handles POST /api/tasks/:id/unarchive/
-func (h *TaskHandler) UnarchiveTask(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) UnarchiveTask(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.UnarchiveTask(uint(taskID), user.ID, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // QuickComplete handles POST /api/tasks/:id/quick-complete/
 // Lightweight endpoint for widget - just returns 200 OK on success
-func (h *TaskHandler) QuickComplete(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) QuickComplete(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	err = h.taskService.QuickComplete(uint(taskID), user.ID)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.Status(http.StatusOK)
+	return c.NoContent(http.StatusOK)
 }
 
 // === Task Completions ===
 
 // GetTaskCompletions handles GET /api/tasks/:id/completions/
-func (h *TaskHandler) GetTaskCompletions(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) GetTaskCompletions(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id")})
-		return
+		return apperrors.BadRequest("error.invalid_task_id")
 	}
 
 	response, err := h.taskService.GetCompletionsByTask(uint(taskID), user.ID)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // ListCompletions handles GET /api/task-completions/
-func (h *TaskHandler) ListCompletions(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) ListCompletions(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	response, err := h.taskService.ListCompletions(user.ID)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // GetCompletion handles GET /api/task-completions/:id/
-func (h *TaskHandler) GetCompletion(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) GetCompletion(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	completionID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_completion_id")})
-		return
+		return apperrors.BadRequest("error.invalid_completion_id")
 	}
 
 	response, err := h.taskService.GetCompletion(uint(completionID), user.ID)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrCompletionNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.completion_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // CreateCompletion handles POST /api/task-completions/
 // Supports both JSON and multipart form data (for image uploads)
-func (h *TaskHandler) CreateCompletion(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) CreateCompletion(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	userNow := middleware.GetUserNow(c)
 
 	var req requests.CreateTaskCompletionRequest
 
-	contentType := c.GetHeader("Content-Type")
+	contentType := c.Request().Header.Get("Content-Type")
 
 	// Check if this is a multipart form request (image upload)
 	if strings.HasPrefix(contentType, "multipart/form-data") {
 		// Parse multipart form
-		if err := c.Request.ParseMultipartForm(32 << 20); err != nil { // 32MB max
-			c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.failed_to_parse_form")})
-			return
+		if err := c.Request().ParseMultipartForm(32 << 20); err != nil { // 32MB max
+			return apperrors.BadRequest("error.failed_to_parse_form")
 		}
 
 		// Parse task_id (required)
-		taskIDStr := c.PostForm("task_id")
+		taskIDStr := c.FormValue("task_id")
 		if taskIDStr == "" {
-			c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.task_id_required")})
-			return
+			return apperrors.BadRequest("error.task_id_required")
 		}
 		taskID, err := strconv.ParseUint(taskIDStr, 10, 32)
 		if err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_task_id_value")})
-			return
+			return apperrors.BadRequest("error.invalid_task_id_value")
 		}
 		req.TaskID = uint(taskID)
 
 		// Parse notes (optional)
-		req.Notes = c.PostForm("notes")
+		req.Notes = c.FormValue("notes")
 
 		// Parse actual_cost (optional)
-		if costStr := c.PostForm("actual_cost"); costStr != "" {
+		if costStr := c.FormValue("actual_cost"); costStr != "" {
 			cost, err := decimal.NewFromString(costStr)
 			if err == nil {
 				req.ActualCost = &cost
@@ -442,7 +319,7 @@ func (h *TaskHandler) CreateCompletion(c *gin.Context) {
 		}
 
 		// Parse completed_at (optional)
-		if completedAtStr := c.PostForm("completed_at"); completedAtStr != "" {
+		if completedAtStr := c.FormValue("completed_at"); completedAtStr != "" {
 			if t, err := time.Parse(time.RFC3339, completedAtStr); err == nil {
 				req.CompletedAt = &t
 			}
@@ -462,87 +339,65 @@ func (h *TaskHandler) CreateCompletion(c *gin.Context) {
 			if h.storageService != nil {
 				result, err := h.storageService.Upload(file, "completions")
 				if err != nil {
-					c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.failed_to_upload_image")})
-					return
+					return apperrors.BadRequest("error.failed_to_upload_image")
 				}
 				req.ImageURLs = append(req.ImageURLs, result.URL)
 			}
 		}
 	} else {
 		// Standard JSON request
-		if err := c.ShouldBindJSON(&req); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-			return
+		if err := c.Bind(&req); err != nil {
+			return apperrors.BadRequest("error.invalid_request")
 		}
 	}
 
 	response, err := h.taskService.CreateCompletion(&req, user.ID, userNow)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrTaskNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.task_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusCreated, response)
+	return c.JSON(http.StatusCreated, response)
 }
 
 // DeleteCompletion handles DELETE /api/task-completions/:id/
-func (h *TaskHandler) DeleteCompletion(c *gin.Context) {
-	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+func (h *TaskHandler) DeleteCompletion(c echo.Context) error {
+	user := c.Get(middleware.AuthUserKey).(*models.User)
 	completionID, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": i18n.LocalizedMessage(c, "error.invalid_completion_id")})
-		return
+		return apperrors.BadRequest("error.invalid_completion_id")
 	}
 
 	response, err := h.taskService.DeleteCompletion(uint(completionID), user.ID)
 	if err != nil {
-		switch {
-		case errors.Is(err, services.ErrCompletionNotFound):
-			c.JSON(http.StatusNotFound, gin.H{"error": i18n.LocalizedMessage(c, "error.completion_not_found")})
-		case errors.Is(err, services.ErrTaskAccessDenied):
-			c.JSON(http.StatusForbidden, gin.H{"error": i18n.LocalizedMessage(c, "error.task_access_denied")})
-		default:
-			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		}
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, response)
+	return c.JSON(http.StatusOK, response)
 }
 
 // === Lookups ===
 
 // GetCategories handles GET /api/tasks/categories/
-func (h *TaskHandler) GetCategories(c *gin.Context) {
+func (h *TaskHandler) GetCategories(c echo.Context) error {
 	categories, err := h.taskService.GetCategories()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, categories)
+	return c.JSON(http.StatusOK, categories)
 }
 
 // GetPriorities handles GET /api/tasks/priorities/
-func (h *TaskHandler) GetPriorities(c *gin.Context) {
+func (h *TaskHandler) GetPriorities(c echo.Context) error {
 	priorities, err := h.taskService.GetPriorities()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, priorities)
+	return c.JSON(http.StatusOK, priorities)
 }
 
 // GetFrequencies handles GET /api/tasks/frequencies/
-func (h *TaskHandler) GetFrequencies(c *gin.Context) {
+func (h *TaskHandler) GetFrequencies(c echo.Context) error {
 	frequencies, err := h.taskService.GetFrequencies()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+		return err
 	}
-	c.JSON(http.StatusOK, frequencies)
+	return c.JSON(http.StatusOK, frequencies)
 }