feat: calculation rules engine for decoupled cost attribution and chargeability

Introduces an admin-configurable rules engine that determines per-day cost
attribution (CHARGE/ZERO/REDUCE) and chargeability reporting (COUNT/SKIP)
for absence types (sick, vacation, public holiday). Includes shared types,
Zod schemas, Prisma model, rule matching with specificity scoring, default
rules, calculator integration, CRUD API router, seed data, chargeability
report integration, and admin UI.

283/283 engine tests, 209/209 API tests, 0 TS errors.

Co-Authored-By: claude-flow <ruv@ruv.net>

packages/api/src/router/chargeability-report.ts

@@ -7,8 +7,11 @@ import {
   getMonthKeys,
   countWorkingDaysInOverlap,
   calculateSAH,
+  calculateAllocation,
+  DEFAULT_CALCULATION_RULES,
   type AssignmentSlice,
 } from "@planarchy/engine";
+import type { CalculationRule, AbsenceDay } from "@planarchy/shared";
 import type { SpainScheduleRule } from "@planarchy/shared";
 import { isChargeabilityActualBooking, listAssignmentBookings } from "@planarchy/application";
 import { VacationStatus } from "@planarchy/db";
@@ -115,7 +118,7 @@ export const chargeabilityReportRouter = createTRPCRouter({
           },
         }));
 
-      // Fetch vacations/absences in the range
+      // Fetch vacations/absences in the range (including type for rules engine)
       const vacations = await ctx.db.vacation.findMany({
         where: {
           resourceId: { in: resourceIds },
@@ -127,9 +130,25 @@ export const chargeabilityReportRouter = createTRPCRouter({
           resourceId: true,
           startDate: true,
           endDate: true,
+          type: true,
+          isHalfDay: true,
         },
       });
 
+      // Load calculation rules for chargeability adjustments
+      let calcRules: CalculationRule[] = DEFAULT_CALCULATION_RULES;
+      try {
+        const dbRules = await ctx.db.calculationRule.findMany({
+          where: { isActive: true },
+          orderBy: [{ priority: "desc" }],
+        });
+        if (dbRules.length > 0) {
+          calcRules = dbRules as unknown as CalculationRule[];
+        }
+      } catch {
+        // table may not exist yet
+      }
+
       // Build per-resource, per-month forecasts
       const resourceRows = resources.map((resource) => {
         const resourceAssignments = assignments.filter((a) => a.resourceId === resource.id);
@@ -171,18 +190,65 @@ export const chargeabilityReportRouter = createTRPCRouter({
             absenceDays: absenceDates,
           });
 
-          // Build assignment slices for this month
+          // Build typed absence days for this resource in this month
+          const monthAbsenceDays: AbsenceDay[] = [];
+          for (const v of resourceVacations) {
+            const vStart = new Date(Math.max(v.startDate.getTime(), monthStart.getTime()));
+            const vEnd = new Date(Math.min(v.endDate.getTime(), monthEnd.getTime()));
+            if (vStart > vEnd) continue;
+            const absCursor = new Date(vStart);
+            absCursor.setUTCHours(0, 0, 0, 0);
+            const absEndNorm = new Date(vEnd);
+            absEndNorm.setUTCHours(0, 0, 0, 0);
+            const triggerType = v.type === "SICK" ? "SICK" as const
+              : v.type === "PUBLIC_HOLIDAY" ? "PUBLIC_HOLIDAY" as const
+              : "VACATION" as const;
+            while (absCursor <= absEndNorm) {
+              monthAbsenceDays.push({
+                date: new Date(absCursor),
+                type: triggerType,
+                ...(v.isHalfDay ? { isHalfDay: true } : {}),
+              });
+              absCursor.setUTCDate(absCursor.getUTCDate() + 1);
+            }
+          }
+
+          // Build assignment slices for this month, using rules to compute chargeable hours
           const slices: AssignmentSlice[] = [];
           for (const a of resourceAssignments) {
             const workingDays = countWorkingDaysInOverlap(monthStart, monthEnd, a.startDate, a.endDate);
             if (workingDays <= 0) continue;
 
             const categoryCode = a.project.utilizationCategory?.code ?? "Chg";
-            slices.push({
-              hoursPerDay: a.hoursPerDay,
-              workingDays,
-              categoryCode,
-            });
+
+            // If there are absences and rules, compute rules-adjusted chargeable hours
+            if (monthAbsenceDays.length > 0) {
+              const overlapStart = new Date(Math.max(monthStart.getTime(), a.startDate.getTime()));
+              const overlapEnd = new Date(Math.min(monthEnd.getTime(), a.endDate.getTime()));
+
+              const calcResult = calculateAllocation({
+                lcrCents: 0, // we only need hours, not costs
+                hoursPerDay: a.hoursPerDay,
+                startDate: overlapStart,
+                endDate: overlapEnd,
+                availability: { monday: dailyHours, tuesday: dailyHours, wednesday: dailyHours, thursday: dailyHours, friday: dailyHours, saturday: 0, sunday: 0 },
+                absenceDays: monthAbsenceDays,
+                calculationRules: calcRules,
+              });
+
+              slices.push({
+                hoursPerDay: a.hoursPerDay,
+                workingDays,
+                categoryCode,
+                ...(calcResult.totalChargeableHours !== undefined ? { totalChargeableHours: calcResult.totalChargeableHours } : {}),
+              });
+            } else {
+              slices.push({
+                hoursPerDay: a.hoursPerDay,
+                workingDays,
+                categoryCode,
+              });
+            }
           }
 
           const forecast = deriveResourceForecast({