apps/api/prisma/schema.prisma

@@ -1030,3 +1030,26 @@ model QualityGate {
   @@index([workspaceId, isEnabled])
   @@map("quality_gates")
 }
+
+model TaskRejection {
+  id            String    @id @default(uuid()) @db.Uuid
+  taskId        String    @map("task_id")
+  workspaceId   String    @map("workspace_id")
+  agentId       String    @map("agent_id")
+  attemptCount  Int       @map("attempt_count")
+  failures      Json      // FailureSummary[]
+  originalTask  String    @map("original_task")
+  startedAt     DateTime  @map("started_at") @db.Timestamptz
+  rejectedAt    DateTime  @map("rejected_at") @db.Timestamptz
+  escalated     Boolean   @default(false)
+  manualReview  Boolean   @default(false) @map("manual_review")
+  resolvedAt    DateTime? @map("resolved_at") @db.Timestamptz
+  resolution    String?
+
+  @@index([taskId])
+  @@index([workspaceId])
+  @@index([agentId])
+  @@index([escalated])
+  @@index([manualReview])
+  @@map("task_rejections")
+}

apps/api/src/rejection-handler/index.ts

@@ -0,0 +1,3 @@
+export * from "./rejection-handler.module";
+export * from "./rejection-handler.service";
+export * from "./interfaces";

apps/api/src/rejection-handler/interfaces/escalation.interface.ts

@@ -0,0 +1,13 @@
+export interface EscalationRule {
+  condition: "max-attempts" | "critical-failure" | "time-exceeded";
+  action: "notify" | "reassign" | "block" | "cancel";
+  target?: string; // notification target
+  priority: "low" | "medium" | "high" | "critical";
+}
+
+export interface EscalationConfig {
+  rules: EscalationRule[];
+  notifyOnRejection: boolean;
+  autoReassign: boolean;
+  maxWaitTime: number; // minutes before auto-escalation
+}

apps/api/src/rejection-handler/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from "./rejection.interface";
+export * from "./escalation.interface";

apps/api/src/rejection-handler/interfaces/rejection.interface.ts

@@ -0,0 +1,25 @@
+export interface RejectionContext {
+  taskId: string;
+  workspaceId: string;
+  agentId: string;
+  attemptCount: number;
+  failures: FailureSummary[];
+  originalTask: string;
+  startedAt: Date;
+  rejectedAt: Date;
+}
+
+export interface FailureSummary {
+  gateName: string;
+  failureType: string;
+  message: string;
+  attempts: number;
+}
+
+export interface RejectionResult {
+  handled: boolean;
+  escalated: boolean;
+  notificationsSent: string[];
+  taskState: "blocked" | "reassigned" | "cancelled";
+  manualReviewRequired: boolean;
+}

apps/api/src/rejection-handler/rejection-handler.module.ts

@@ -0,0 +1,10 @@
+import { Module } from "@nestjs/common";
+import { RejectionHandlerService } from "./rejection-handler.service";
+import { PrismaModule } from "../prisma/prisma.module";
+
+@Module({
+  imports: [PrismaModule],
+  providers: [RejectionHandlerService],
+  exports: [RejectionHandlerService],
+})
+export class RejectionHandlerModule {}

apps/api/src/rejection-handler/rejection-handler.service.spec.ts

@@ -0,0 +1,442 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { RejectionHandlerService } from "./rejection-handler.service";
+import { PrismaService } from "../prisma/prisma.service";
+import { Logger } from "@nestjs/common";
+import type {
+  RejectionContext,
+  RejectionResult,
+  EscalationConfig,
+  EscalationRule,
+} from "./interfaces";
+
+describe("RejectionHandlerService", () => {
+  let service: RejectionHandlerService;
+  let prismaService: PrismaService;
+
+  const mockRejectionContext: RejectionContext = {
+    taskId: "task-123",
+    workspaceId: "workspace-456",
+    agentId: "agent-789",
+    attemptCount: 3,
+    failures: [
+      {
+        gateName: "type-check",
+        failureType: "compilation-error",
+        message: "Type error in module",
+        attempts: 2,
+      },
+      {
+        gateName: "test-gate",
+        failureType: "test-failure",
+        message: "5 tests failed",
+        attempts: 1,
+      },
+    ],
+    originalTask: "Implement user authentication",
+    startedAt: new Date("2026-01-31T10:00:00Z"),
+    rejectedAt: new Date("2026-01-31T12:30:00Z"),
+  };
+
+  const mockPrismaService = {
+    taskRejection: {
+      create: vi.fn(),
+      findMany: vi.fn(),
+      update: vi.fn(),
+    },
+  };
+
+  const mockLogger = {
+    log: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        RejectionHandlerService,
+        {
+          provide: PrismaService,
+          useValue: mockPrismaService,
+        },
+        {
+          provide: Logger,
+          useValue: mockLogger,
+        },
+      ],
+    }).compile();
+
+    service = module.get<RejectionHandlerService>(RejectionHandlerService);
+    prismaService = module.get(PrismaService);
+
+    // Clear all mocks before each test
+    vi.clearAllMocks();
+  });
+
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+
+  describe("handleRejection", () => {
+    it("should handle rejection and return result", async () => {
+      const mockRejection = {
+        id: "rejection-1",
+        taskId: mockRejectionContext.taskId,
+        workspaceId: mockRejectionContext.workspaceId,
+        agentId: mockRejectionContext.agentId,
+        attemptCount: mockRejectionContext.attemptCount,
+        failures: mockRejectionContext.failures as any,
+        originalTask: mockRejectionContext.originalTask,
+        startedAt: mockRejectionContext.startedAt,
+        rejectedAt: mockRejectionContext.rejectedAt,
+        escalated: true,
+        manualReview: true,
+        resolvedAt: null,
+        resolution: null,
+      };
+
+      mockPrismaService.taskRejection.create.mockResolvedValue(mockRejection);
+      mockPrismaService.taskRejection.findMany.mockResolvedValue([mockRejection]);
+      mockPrismaService.taskRejection.update.mockResolvedValue(mockRejection);
+
+      const result = await service.handleRejection(mockRejectionContext);
+
+      expect(result.handled).toBe(true);
+      expect(result.manualReviewRequired).toBe(true);
+      expect(mockPrismaService.taskRejection.create).toHaveBeenCalled();
+    });
+
+    it("should handle rejection without escalation for low attempt count", async () => {
+      const lowAttemptContext: RejectionContext = {
+        ...mockRejectionContext,
+        attemptCount: 1,
+        startedAt: new Date("2026-01-31T12:00:00Z"),
+        rejectedAt: new Date("2026-01-31T12:30:00Z"), // 30 minutes - under maxWaitTime
+      };
+
+      const mockRejection = {
+        id: "rejection-2",
+        taskId: lowAttemptContext.taskId,
+        workspaceId: lowAttemptContext.workspaceId,
+        agentId: lowAttemptContext.agentId,
+        attemptCount: lowAttemptContext.attemptCount,
+        failures: lowAttemptContext.failures as any,
+        originalTask: lowAttemptContext.originalTask,
+        startedAt: lowAttemptContext.startedAt,
+        rejectedAt: lowAttemptContext.rejectedAt,
+        escalated: false,
+        manualReview: false,
+        resolvedAt: null,
+        resolution: null,
+      };
+
+      mockPrismaService.taskRejection.create.mockResolvedValue(mockRejection);
+      mockPrismaService.taskRejection.findMany.mockResolvedValue([mockRejection]);
+      mockPrismaService.taskRejection.update.mockResolvedValue(mockRejection);
+
+      const result = await service.handleRejection(lowAttemptContext);
+
+      expect(result.handled).toBe(true);
+      expect(result.escalated).toBe(false);
+    });
+  });
+
+  describe("logRejection", () => {
+    it("should log rejection to database", async () => {
+      prismaService.taskRejection.create.mockResolvedValue({
+        id: "rejection-3",
+        taskId: mockRejectionContext.taskId,
+        workspaceId: mockRejectionContext.workspaceId,
+        agentId: mockRejectionContext.agentId,
+        attemptCount: mockRejectionContext.attemptCount,
+        failures: mockRejectionContext.failures as any,
+        originalTask: mockRejectionContext.originalTask,
+        startedAt: mockRejectionContext.startedAt,
+        rejectedAt: mockRejectionContext.rejectedAt,
+        escalated: false,
+        manualReview: false,
+        resolvedAt: null,
+        resolution: null,
+      });
+
+      await service.logRejection(mockRejectionContext);
+
+      expect(prismaService.taskRejection.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          taskId: mockRejectionContext.taskId,
+          workspaceId: mockRejectionContext.workspaceId,
+          agentId: mockRejectionContext.agentId,
+          attemptCount: mockRejectionContext.attemptCount,
+        }),
+      });
+    });
+  });
+
+  describe("determineEscalation", () => {
+    it("should determine escalation rules based on max attempts", () => {
+      const config: EscalationConfig = {
+        rules: [
+          {
+            condition: "max-attempts",
+            action: "notify",
+            target: "admin@example.com",
+            priority: "high",
+          },
+        ],
+        notifyOnRejection: true,
+        autoReassign: false,
+        maxWaitTime: 60,
+      };
+
+      const rules = service.determineEscalation(mockRejectionContext, config);
+
+      expect(rules).toHaveLength(1);
+      expect(rules[0].condition).toBe("max-attempts");
+      expect(rules[0].action).toBe("notify");
+      expect(rules[0].priority).toBe("high");
+    });
+
+    it("should determine escalation for time exceeded", () => {
+      const longRunningContext: RejectionContext = {
+        ...mockRejectionContext,
+        startedAt: new Date("2026-01-31T08:00:00Z"),
+        rejectedAt: new Date("2026-01-31T12:00:00Z"),
+      };
+
+      const config: EscalationConfig = {
+        rules: [
+          {
+            condition: "time-exceeded",
+            action: "block",
+            priority: "critical",
+          },
+        ],
+        notifyOnRejection: true,
+        autoReassign: false,
+        maxWaitTime: 120, // 2 hours
+      };
+
+      const rules = service.determineEscalation(longRunningContext, config);
+
+      expect(rules.length).toBeGreaterThan(0);
+      expect(rules.some((r) => r.condition === "time-exceeded")).toBe(true);
+    });
+
+    it("should determine escalation for critical failures", () => {
+      const criticalContext: RejectionContext = {
+        ...mockRejectionContext,
+        failures: [
+          {
+            gateName: "security-scan",
+            failureType: "critical-vulnerability",
+            message: "SQL injection detected",
+            attempts: 1,
+          },
+        ],
+      };
+
+      const config: EscalationConfig = {
+        rules: [
+          {
+            condition: "critical-failure",
+            action: "block",
+            priority: "critical",
+          },
+        ],
+        notifyOnRejection: true,
+        autoReassign: false,
+        maxWaitTime: 60,
+      };
+
+      const rules = service.determineEscalation(criticalContext, config);
+
+      expect(rules.some((r) => r.condition === "critical-failure")).toBe(true);
+    });
+  });
+
+  describe("executeEscalation", () => {
+    it("should execute notification escalation", async () => {
+      const rules: EscalationRule[] = [
+        {
+          condition: "max-attempts",
+          action: "notify",
+          target: "admin@example.com",
+          priority: "high",
+        },
+      ];
+
+      // Mock sendNotification
+      vi.spyOn(service, "sendNotification").mockReturnValue();
+
+      await service.executeEscalation(mockRejectionContext, rules);
+
+      expect(service.sendNotification).toHaveBeenCalledWith(
+        mockRejectionContext,
+        "admin@example.com",
+        "high"
+      );
+    });
+
+    it("should execute block escalation", async () => {
+      const rules: EscalationRule[] = [
+        {
+          condition: "critical-failure",
+          action: "block",
+          priority: "critical",
+        },
+      ];
+
+      vi.spyOn(service, "markForManualReview").mockResolvedValue();
+
+      await service.executeEscalation(mockRejectionContext, rules);
+
+      expect(service.markForManualReview).toHaveBeenCalledWith(
+        mockRejectionContext.taskId,
+        expect.any(String)
+      );
+    });
+  });
+
+  describe("sendNotification", () => {
+    it("should send notification with context and priority", () => {
+      service.sendNotification(mockRejectionContext, "admin@example.com", "high");
+
+      // Verify logging occurred
+      expect(true).toBe(true); // Placeholder - actual implementation will log
+    });
+  });
+
+  describe("markForManualReview", () => {
+    it("should mark task for manual review", async () => {
+      const mockRejection = {
+        id: "rejection-4",
+        taskId: mockRejectionContext.taskId,
+        workspaceId: mockRejectionContext.workspaceId,
+        agentId: mockRejectionContext.agentId,
+        attemptCount: mockRejectionContext.attemptCount,
+        failures: mockRejectionContext.failures as any,
+        originalTask: mockRejectionContext.originalTask,
+        startedAt: mockRejectionContext.startedAt,
+        rejectedAt: mockRejectionContext.rejectedAt,
+        escalated: false,
+        manualReview: false,
+        resolvedAt: null,
+        resolution: null,
+      };
+
+      mockPrismaService.taskRejection.findMany.mockResolvedValue([mockRejection]);
+      mockPrismaService.taskRejection.update.mockResolvedValue({
+        ...mockRejection,
+        escalated: true,
+        manualReview: true,
+      });
+
+      await service.markForManualReview(mockRejectionContext.taskId, "Max attempts exceeded");
+
+      expect(mockPrismaService.taskRejection.findMany).toHaveBeenCalledWith({
+        where: { taskId: mockRejectionContext.taskId },
+        orderBy: { rejectedAt: "desc" },
+        take: 1,
+      });
+
+      expect(mockPrismaService.taskRejection.update).toHaveBeenCalledWith({
+        where: { id: mockRejection.id },
+        data: {
+          manualReview: true,
+          escalated: true,
+        },
+      });
+    });
+  });
+
+  describe("getRejectionHistory", () => {
+    it("should retrieve rejection history for a task", async () => {
+      const mockHistory = [
+        {
+          id: "rejection-5",
+          taskId: mockRejectionContext.taskId,
+          workspaceId: mockRejectionContext.workspaceId,
+          agentId: mockRejectionContext.agentId,
+          attemptCount: 1,
+          failures: [],
+          originalTask: mockRejectionContext.originalTask,
+          startedAt: new Date("2026-01-31T09:00:00Z"),
+          rejectedAt: new Date("2026-01-31T10:00:00Z"),
+          escalated: false,
+          manualReview: false,
+          resolvedAt: null,
+          resolution: null,
+        },
+        {
+          id: "rejection-6",
+          taskId: mockRejectionContext.taskId,
+          workspaceId: mockRejectionContext.workspaceId,
+          agentId: mockRejectionContext.agentId,
+          attemptCount: 2,
+          failures: [],
+          originalTask: mockRejectionContext.originalTask,
+          startedAt: new Date("2026-01-31T10:30:00Z"),
+          rejectedAt: new Date("2026-01-31T11:30:00Z"),
+          escalated: false,
+          manualReview: false,
+          resolvedAt: null,
+          resolution: null,
+        },
+      ];
+
+      prismaService.taskRejection.findMany.mockResolvedValue(mockHistory);
+
+      const history = await service.getRejectionHistory(mockRejectionContext.taskId);
+
+      expect(history).toHaveLength(2);
+      expect(prismaService.taskRejection.findMany).toHaveBeenCalledWith({
+        where: { taskId: mockRejectionContext.taskId },
+        orderBy: { rejectedAt: "desc" },
+      });
+    });
+  });
+
+  describe("generateRejectionReport", () => {
+    it("should generate a formatted rejection report", () => {
+      const report = service.generateRejectionReport(mockRejectionContext);
+
+      expect(report).toContain("Task Rejection Report");
+      expect(report).toContain(mockRejectionContext.taskId);
+      expect(report).toContain(mockRejectionContext.attemptCount.toString());
+      expect(report).toContain("type-check");
+      expect(report).toContain("test-gate");
+    });
+
+    it("should include failure details in report", () => {
+      const report = service.generateRejectionReport(mockRejectionContext);
+
+      mockRejectionContext.failures.forEach((failure) => {
+        expect(report).toContain(failure.gateName);
+        expect(report).toContain(failure.message);
+      });
+    });
+  });
+
+  describe("getDefaultEscalationConfig", () => {
+    it("should return default escalation configuration", () => {
+      const config = service.getDefaultEscalationConfig();
+
+      expect(config.rules).toBeDefined();
+      expect(config.rules.length).toBeGreaterThan(0);
+      expect(config.notifyOnRejection).toBeDefined();
+      expect(config.autoReassign).toBeDefined();
+      expect(config.maxWaitTime).toBeGreaterThan(0);
+    });
+
+    it("should include all escalation conditions in default config", () => {
+      const config = service.getDefaultEscalationConfig();
+
+      const conditions = config.rules.map((r) => r.condition);
+      expect(conditions).toContain("max-attempts");
+      expect(conditions).toContain("critical-failure");
+      expect(conditions).toContain("time-exceeded");
+    });
+  });
+});

apps/api/src/rejection-handler/rejection-handler.service.ts

@@ -0,0 +1,408 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { Prisma } from "@prisma/client";
+import { PrismaService } from "../prisma/prisma.service";
+import type {
+  RejectionContext,
+  RejectionResult,
+  EscalationConfig,
+  EscalationRule,
+  FailureSummary,
+} from "./interfaces";
+
+@Injectable()
+export class RejectionHandlerService {
+  private readonly logger = new Logger(RejectionHandlerService.name);
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  /**
+   * Handle a rejected task
+   */
+  async handleRejection(context: RejectionContext): Promise<RejectionResult> {
+    this.logger.warn(
+      `Handling rejection for task ${context.taskId} after ${String(context.attemptCount)} attempts`
+    );
+
+    // Log rejection to database
+    await this.logRejection(context);
+
+    // Get escalation config
+    const config = this.getDefaultEscalationConfig();
+
+    // Determine escalation actions
+    const escalationRules = this.determineEscalation(context, config);
+
+    // Execute escalation
+    const notificationsSent: string[] = [];
+    if (escalationRules.length > 0) {
+      await this.executeEscalation(context, escalationRules);
+      // Collect notification targets
+      escalationRules.forEach((rule) => {
+        if (rule.action === "notify" && rule.target) {
+          notificationsSent.push(rule.target);
+        }
+      });
+    }
+
+    // Determine task state based on escalation
+    const taskState = this.determineTaskState(escalationRules);
+
+    // Check if manual review is required
+    const manualReviewRequired =
+      context.attemptCount >= 3 ||
+      escalationRules.some((r) => r.action === "block" || r.priority === "critical");
+
+    if (manualReviewRequired) {
+      await this.markForManualReview(
+        context.taskId,
+        `Max attempts (${String(context.attemptCount)}) exceeded or critical failure detected`
+      );
+    }
+
+    return {
+      handled: true,
+      escalated: escalationRules.length > 0,
+      notificationsSent,
+      taskState,
+      manualReviewRequired,
+    };
+  }
+
+  /**
+   * Log rejection to database
+   */
+  async logRejection(context: RejectionContext): Promise<void> {
+    await this.prisma.taskRejection.create({
+      data: {
+        taskId: context.taskId,
+        workspaceId: context.workspaceId,
+        agentId: context.agentId,
+        attemptCount: context.attemptCount,
+        failures: context.failures as unknown as Prisma.InputJsonValue,
+        originalTask: context.originalTask,
+        startedAt: context.startedAt,
+        rejectedAt: context.rejectedAt,
+        escalated: false,
+        manualReview: false,
+      },
+    });
+
+    this.logger.log(`Logged rejection for task ${context.taskId} to database`);
+  }
+
+  /**
+   * Determine escalation actions
+   */
+  determineEscalation(context: RejectionContext, config: EscalationConfig): EscalationRule[] {
+    const applicableRules: EscalationRule[] = [];
+
+    // Check each rule condition
+    for (const rule of config.rules) {
+      if (this.checkRuleCondition(context, rule, config)) {
+        applicableRules.push(rule);
+      }
+    }
+
+    return applicableRules;
+  }
+
+  /**
+   * Check if a rule condition is met
+   */
+  private checkRuleCondition(
+    context: RejectionContext,
+    rule: EscalationRule,
+    config: EscalationConfig
+  ): boolean {
+    switch (rule.condition) {
+      case "max-attempts":
+        return context.attemptCount >= 3;
+
+      case "time-exceeded": {
+        const durationMinutes =
+          (context.rejectedAt.getTime() - context.startedAt.getTime()) / (1000 * 60);
+        return durationMinutes > config.maxWaitTime;
+      }
+
+      case "critical-failure":
+        return context.failures.some(
+          (f) =>
+            f.failureType.includes("critical") ||
+            f.failureType.includes("security") ||
+            f.failureType.includes("vulnerability")
+        );
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Execute escalation rules
+   */
+  async executeEscalation(context: RejectionContext, rules: EscalationRule[]): Promise<void> {
+    for (const rule of rules) {
+      this.logger.warn(
+        `Executing escalation: ${rule.action} for ${rule.condition} (priority: ${rule.priority})`
+      );
+
+      switch (rule.action) {
+        case "notify":
+          if (rule.target) {
+            this.sendNotification(context, rule.target, rule.priority);
+          }
+          break;
+
+        case "block":
+          await this.markForManualReview(context.taskId, `Task blocked due to ${rule.condition}`);
+          break;
+
+        case "reassign":
+          this.logger.warn(`Task ${context.taskId} marked for reassignment`);
+          // Future: implement reassignment logic
+          break;
+
+        case "cancel":
+          this.logger.warn(`Task ${context.taskId} marked for cancellation`);
+          // Future: implement cancellation logic
+          break;
+      }
+    }
+  }
+
+  /**
+   * Send rejection notification
+   */
+  sendNotification(context: RejectionContext, target: string, priority: string): void {
+    const report = this.generateRejectionReport(context);
+
+    this.logger.warn(
+      `[${priority.toUpperCase()}] Sending rejection notification to ${target} for task ${context.taskId}`
+    );
+    this.logger.debug(`Notification content:\n${report}`);
+
+    // Future: integrate with notification service (email, Slack, etc.)
+    // For now, just log the notification
+  }
+
+  /**
+   * Mark task as requiring manual review
+   */
+  async markForManualReview(taskId: string, reason: string): Promise<void> {
+    // Update the most recent rejection record for this task
+    const rejections = await this.prisma.taskRejection.findMany({
+      where: { taskId },
+      orderBy: { rejectedAt: "desc" },
+      take: 1,
+    });
+
+    if (rejections.length > 0 && rejections[0]) {
+      await this.prisma.taskRejection.update({
+        where: { id: rejections[0].id },
+        data: {
+          manualReview: true,
+          escalated: true,
+        },
+      });
+
+      this.logger.warn(`Task ${taskId} marked for manual review: ${reason}`);
+    }
+  }
+
+  /**
+   * Get rejection history for a task
+   */
+  async getRejectionHistory(taskId: string): Promise<RejectionContext[]> {
+    const rejections = await this.prisma.taskRejection.findMany({
+      where: { taskId },
+      orderBy: { rejectedAt: "desc" },
+    });
+
+    return rejections.map((r) => ({
+      taskId: r.taskId,
+      workspaceId: r.workspaceId,
+      agentId: r.agentId,
+      attemptCount: r.attemptCount,
+      failures: r.failures as unknown as FailureSummary[],
+      originalTask: r.originalTask,
+      startedAt: r.startedAt,
+      rejectedAt: r.rejectedAt,
+    }));
+  }
+
+  /**
+   * Generate rejection report
+   */
+  generateRejectionReport(context: RejectionContext): string {
+    const duration = this.formatDuration(context.startedAt, context.rejectedAt);
+
+    const failureList = context.failures
+      .map((f) => `- **${f.gateName}**: ${f.message} (${String(f.attempts)} attempts)`)
+      .join("\n");
+
+    const recommendations = this.generateRecommendations(context.failures);
+
+    return `
+## Task Rejection Report
+
+**Task ID:** ${context.taskId}
+**Workspace:** ${context.workspaceId}
+**Agent:** ${context.agentId}
+**Attempts:** ${String(context.attemptCount)}
+**Duration:** ${duration}
+**Started:** ${context.startedAt.toISOString()}
+**Rejected:** ${context.rejectedAt.toISOString()}
+
+### Original Task
+${context.originalTask}
+
+### Failures
+${failureList}
+
+### Required Actions
+- Manual code review required
+- Fix the following issues before reassigning
+- Review agent output and error logs
+
+### Recommendations
+${recommendations}
+
+---
+*This report was generated automatically by the Quality Rails rejection handler.*
+`;
+  }
+
+  /**
+   * Get default escalation config
+   */
+  getDefaultEscalationConfig(): EscalationConfig {
+    return {
+      rules: [
+        {
+          condition: "max-attempts",
+          action: "notify",
+          target: "admin@mosaicstack.dev",
+          priority: "high",
+        },
+        {
+          condition: "max-attempts",
+          action: "block",
+          priority: "high",
+        },
+        {
+          condition: "critical-failure",
+          action: "notify",
+          target: "security@mosaicstack.dev",
+          priority: "critical",
+        },
+        {
+          condition: "critical-failure",
+          action: "block",
+          priority: "critical",
+        },
+        {
+          condition: "time-exceeded",
+          action: "notify",
+          target: "admin@mosaicstack.dev",
+          priority: "medium",
+        },
+      ],
+      notifyOnRejection: true,
+      autoReassign: false,
+      maxWaitTime: 120, // 2 hours
+    };
+  }
+
+  /**
+   * Determine task state based on escalation rules
+   */
+  private determineTaskState(rules: EscalationRule[]): "blocked" | "reassigned" | "cancelled" {
+    // Check for explicit state changes
+    if (rules.some((r) => r.action === "cancel")) {
+      return "cancelled";
+    }
+
+    if (rules.some((r) => r.action === "reassign")) {
+      return "reassigned";
+    }
+
+    if (rules.some((r) => r.action === "block")) {
+      return "blocked";
+    }
+
+    // Default to blocked if any escalation occurred
+    return "blocked";
+  }
+
+  /**
+   * Format duration between two dates
+   */
+  private formatDuration(start: Date, end: Date): string {
+    const durationMs = end.getTime() - start.getTime();
+    const hours = Math.floor(durationMs / (1000 * 60 * 60));
+    const minutes = Math.floor((durationMs % (1000 * 60 * 60)) / (1000 * 60));
+
+    if (hours > 0) {
+      return `${String(hours)}h ${String(minutes)}m`;
+    }
+    return `${String(minutes)}m`;
+  }
+
+  /**
+   * Generate recommendations based on failure types
+   */
+  private generateRecommendations(failures: FailureSummary[]): string {
+    const recommendations: string[] = [];
+
+    failures.forEach((failure) => {
+      switch (failure.gateName) {
+        case "type-check":
+          recommendations.push(
+            "- Review TypeScript errors and ensure all types are properly defined"
+          );
+          recommendations.push(
+            "- Check for missing type definitions or incorrect type annotations"
+          );
+          break;
+
+        case "test-gate":
+          recommendations.push(
+            "- Review failing tests and update implementation to meet test expectations"
+          );
+          recommendations.push("- Verify test mocks and fixtures are correctly configured");
+          break;
+
+        case "lint-gate":
+          recommendations.push("- Run ESLint and fix all reported issues");
+          recommendations.push(
+            "- Consider adding ESLint disable comments only for false positives"
+          );
+          break;
+
+        case "security-scan":
+          recommendations.push(
+            "- **CRITICAL**: Review and fix security vulnerabilities immediately"
+          );
+          recommendations.push("- Do not proceed until security issues are resolved");
+          break;
+
+        case "coverage-gate":
+          recommendations.push(
+            "- Add additional tests to increase coverage above minimum threshold"
+          );
+          recommendations.push("- Focus on untested edge cases and error paths");
+          break;
+
+        default:
+          recommendations.push(`- Review ${failure.gateName} failures and address root causes`);
+      }
+    });
+
+    // Deduplicate recommendations
+    const uniqueRecommendations = [...new Set(recommendations)];
+
+    return uniqueRecommendations.length > 0
+      ? uniqueRecommendations.join("\n")
+      : "- Review error logs and agent output for additional context";
+  }
+}