From f153b3fe44543a698a017a0407c2d59085a8483f Mon Sep 17 00:00:00 2001
From: shashank897 <shashank89.n@gmail.com>
Date: Mon, 12 Oct 2026 19:15:10 +0530
Subject: [PATCH] feat(elm): implement employee leave management module with
 domain state machine, services, api, and client UI

---
 .importlinter                                 |  17 +
 client/src/app/registry.ts                    |   5 +
 client/src/modules/elm/pages/AdminPage.tsx    |  72 ++++
 .../src/modules/elm/pages/ApplyLeavePage.tsx  | 151 ++++++++
 .../src/modules/elm/pages/ApprovalsPage.tsx   |  91 +++++
 client/src/modules/elm/pages/MyLeavesPage.tsx | 113 ++++++
 .../src/modules/elm/pages/SubstitutePage.tsx  |  66 ++++
 client/src/modules/elm/routes.tsx             |  19 +
 config/settings/base.py                       |   1 +
 config/urls.py                                |   1 +
 modules/elm/__init__.py                       |   1 +
 modules/elm/api/__init__.py                   |   1 +
 modules/elm/api/serializers.py                |  83 ++++
 modules/elm/api/urls.py                       |  19 +
 modules/elm/api/views.py                      | 199 ++++++++++
 modules/elm/apps.py                           |   7 +
 modules/elm/contracts.py                      |  78 ++++
 modules/elm/domain/__init__.py                |   1 +
 modules/elm/domain/calculations.py            | 159 ++++++++
 modules/elm/domain/entities.py                |  54 +++
 modules/elm/domain/state_machine.py           | 183 +++++++++
 modules/elm/models/__init__.py                |  12 +
 modules/elm/models/balances.py                |  74 ++++
 modules/elm/models/holidays.py                |  36 ++
 modules/elm/models/leaves.py                  | 121 ++++++
 modules/elm/registry.py                       | 144 +++++++
 modules/elm/selectors/__init__.py             |   1 +
 modules/elm/selectors/leaves.py               |  62 +++
 modules/elm/services/__init__.py              |   1 +
 modules/elm/services/applications.py          | 155 ++++++++
 modules/elm/services/workflows.py             | 353 ++++++++++++++++++
 modules/elm/services/year_end.py              | 101 +++++
 modules/elm/tests/__init__.py                 |   1 +
 modules/elm/tests/test_domain.py              | 111 ++++++
 34 files changed, 2493 insertions(+)
 create mode 100644 client/src/modules/elm/pages/AdminPage.tsx
 create mode 100644 client/src/modules/elm/pages/ApplyLeavePage.tsx
 create mode 100644 client/src/modules/elm/pages/ApprovalsPage.tsx
 create mode 100644 client/src/modules/elm/pages/MyLeavesPage.tsx
 create mode 100644 client/src/modules/elm/pages/SubstitutePage.tsx
 create mode 100644 client/src/modules/elm/routes.tsx
 create mode 100644 modules/elm/__init__.py
 create mode 100644 modules/elm/api/__init__.py
 create mode 100644 modules/elm/api/serializers.py
 create mode 100644 modules/elm/api/urls.py
 create mode 100644 modules/elm/api/views.py
 create mode 100644 modules/elm/apps.py
 create mode 100644 modules/elm/contracts.py
 create mode 100644 modules/elm/domain/__init__.py
 create mode 100644 modules/elm/domain/calculations.py
 create mode 100644 modules/elm/domain/entities.py
 create mode 100644 modules/elm/domain/state_machine.py
 create mode 100644 modules/elm/models/__init__.py
 create mode 100644 modules/elm/models/balances.py
 create mode 100644 modules/elm/models/holidays.py
 create mode 100644 modules/elm/models/leaves.py
 create mode 100644 modules/elm/registry.py
 create mode 100644 modules/elm/selectors/__init__.py
 create mode 100644 modules/elm/selectors/leaves.py
 create mode 100644 modules/elm/services/__init__.py
 create mode 100644 modules/elm/services/applications.py
 create mode 100644 modules/elm/services/workflows.py
 create mode 100644 modules/elm/services/year_end.py
 create mode 100644 modules/elm/tests/__init__.py
 create mode 100644 modules/elm/tests/test_domain.py

diff --git a/.importlinter b/.importlinter
index d964dc3c..ac2796ba 100644
--- a/.importlinter
+++ b/.importlinter
@@ -13,6 +13,7 @@ name = Modules may reach each other ONLY through contracts.py
 type = forbidden
 source_modules =
     modules.placement
+    modules.elm
     modules.directory
     modules.accesscontrol
 forbidden_modules =
@@ -21,6 +22,11 @@ forbidden_modules =
     modules.placement.selectors
     modules.placement.api
     modules.placement.domain
+    modules.elm.models
+    modules.elm.services
+    modules.elm.selectors
+    modules.elm.api
+    modules.elm.domain
     modules.directory.models
     modules.directory.services
     modules.directory.api
@@ -38,6 +44,7 @@ type = forbidden
 source_modules =
 # Every module's domain, not just the first one written.
     modules.placement.domain
+    modules.elm.domain
 forbidden_modules =
     django
     rest_framework
@@ -66,3 +73,13 @@ layers =
     modules.placement.selectors
     modules.placement.models
     modules.placement.domain
+
+[importlinter:contract:elm-layers]
+name = Layering inside elm
+type = layers
+layers =
+    modules.elm.api
+    modules.elm.services
+    modules.elm.selectors
+    modules.elm.models
+    modules.elm.domain
diff --git a/client/src/app/registry.ts b/client/src/app/registry.ts
index e76d32bf..62a76ddf 100644
--- a/client/src/app/registry.ts
+++ b/client/src/app/registry.ts
@@ -17,4 +17,9 @@ export const MODULE_REGISTRY: Record<string, ModuleManifest> = {
     basePath: "/placement",
     load: () => import("../modules/placement/routes"),
   },
+  elm: {
+    code: "elm",
+    basePath: "/elm",
+    load: () => import("../modules/elm/routes"),
+  },
 };
diff --git a/client/src/modules/elm/pages/AdminPage.tsx b/client/src/modules/elm/pages/AdminPage.tsx
new file mode 100644
index 00000000..8e59c34f
--- /dev/null
+++ b/client/src/modules/elm/pages/AdminPage.tsx
@@ -0,0 +1,72 @@
+import React from "react";
+import {
+  Card,
+  Title,
+  Table,
+  Badge,
+  Button,
+  Stack,
+  Text,
+  Group,
+  TextInput,
+  Select,
+} from "@mantine/core";
+
+export default function AdminPage() {
+  const holidays = [
+    { date: "2026-01-26", name: "Republic Day", type: "closed" },
+    { date: "2026-03-25", name: "Holi", type: "closed" },
+    { date: "2026-04-14", name: "Ambedkar Jayanti", type: "restricted" },
+    { date: "2026-08-15", name: "Independence Day", type: "closed" },
+    { date: "2026-10-02", name: "Gandhi Jayanti", type: "closed" },
+  ];
+
+  return (
+    <Stack gap="lg">
+      <Title order={2}>Leave Administration & Calendars</Title>
+      <Text c="dimmed" size="sm">
+        Maintain annual holiday calendars, publish Restricted Holidays (RH), and execute year-end processing.
+      </Text>
+
+      <Card withBorder radius="md" p="md">
+        <Group justify="space-between" mb="md">
+          <Title order={4}>Published Holiday Calendar (2026)</Title>
+          <Button size="xs" color="blue">Add Holiday / RH</Button>
+        </Group>
+
+        <Table striped>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Date</Table.Th>
+              <Table.Th>Holiday Name</Table.Th>
+              <Table.Th>Type</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {holidays.map((h) => (
+              <Table.Tr key={h.date}>
+                <Table.Td>{h.date}</Table.Td>
+                <Table.Td>{h.name}</Table.Td>
+                <Table.Td>
+                  <Badge color={h.type === "closed" ? "red" : "violet"}>
+                    {h.type === "closed" ? "Closed Holiday" : "Restricted Holiday (RH)"}
+                  </Badge>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+
+      <Card withBorder radius="md" p="md">
+        <Title order={4} mb="xs">Year-End Leave Ledger Processing (EVT-01)</Title>
+        <Text size="sm" c="dimmed" mb="md">
+          Lapses unused CL/RH/SCL, converts Faculty VL to EL at 2:1 ratio, and carries forward EL/COL to next calendar year.
+        </Text>
+        <Button color="orange" variant="light">
+          Run Year-End Processing
+        </Button>
+      </Card>
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/pages/ApplyLeavePage.tsx b/client/src/modules/elm/pages/ApplyLeavePage.tsx
new file mode 100644
index 00000000..20819a26
--- /dev/null
+++ b/client/src/modules/elm/pages/ApplyLeavePage.tsx
@@ -0,0 +1,151 @@
+import React, { useState } from "react";
+import {
+  Card,
+  Title,
+  TextInput,
+  Select,
+  Button,
+  Stack,
+  Text,
+  Checkbox,
+  Group,
+  Textarea,
+  Notification,
+} from "@mantine/core";
+
+export default function ApplyLeavePage() {
+  const [category, setCategory] = useState<string | null>("CL");
+  const [startDate, setStartDate] = useState("");
+  const [endDate, setEndDate] = useState("");
+  const [isHalfDay, setIsHalfDay] = useState(false);
+  const [halfDayPeriod, setHalfDayPeriod] = useState<string | null>("first_half");
+  const [reason, setReason] = useState("");
+  const [leavingStation, setLeavingStation] = useState(false);
+  const [stationAddress, setStationAddress] = useState("");
+  const [emergencyPhone, setEmergencyPhone] = useState("");
+  const [substituteId, setSubstituteId] = useState("");
+  const [submitted, setSubmitted] = useState(false);
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    setSubmitted(true);
+  };
+
+  return (
+    <Stack gap="lg" maw={700}>
+      <Title order={2}>Apply for Leave</Title>
+      <Text c="dimmed" size="sm">
+        Submit a new leave application with role-based routing and substitute nomination.
+      </Text>
+
+      {submitted && (
+        <Notification color="teal" title="Application Submitted" onClose={() => setSubmitted(false)}>
+          Your leave application has been submitted for review.
+        </Notification>
+      )}
+
+      <Card withBorder padding="lg" radius="md">
+        <form onSubmit={handleSubmit}>
+          <Stack gap="md">
+            <Select
+              label="Leave Category"
+              placeholder="Select category"
+              data={[
+                { value: "CL", label: "Casual Leave (CL)" },
+                { value: "RH", label: "Restricted Holiday (RH)" },
+                { value: "SCL", label: "Special Casual Leave (SCL)" },
+                { value: "EL", label: "Earned Leave (EL)" },
+                { value: "VL", label: "Vacation Leave (VL)" },
+                { value: "COL", label: "Commuted Leave (COL - Medical)" },
+              ]}
+              value={category}
+              onChange={setCategory}
+              required
+            />
+
+            <Group grow>
+              <TextInput
+                label="Start Date"
+                type="date"
+                value={startDate}
+                onChange={(e) => setStartDate(e.currentTarget.value)}
+                required
+              />
+              <TextInput
+                label="End Date"
+                type="date"
+                value={endDate}
+                onChange={(e) => setEndDate(e.currentTarget.value)}
+                required
+              />
+            </Group>
+
+            {category === "CL" && (
+              <Group>
+                <Checkbox
+                  label="Half Day Leave (0.5 CL)"
+                  checked={isHalfDay}
+                  onChange={(e) => setIsHalfDay(e.currentTarget.checked)}
+                />
+                {isHalfDay && (
+                  <Select
+                    placeholder="Select Half"
+                    data={[
+                      { value: "first_half", label: "First Half" },
+                      { value: "second_half", label: "Second Half" },
+                    ]}
+                    value={halfDayPeriod}
+                    onChange={setHalfDayPeriod}
+                  />
+                )}
+              </Group>
+            )}
+
+            <Textarea
+              label="Purpose / Reason"
+              placeholder="State the reason for leave"
+              value={reason}
+              onChange={(e) => setReason(e.currentTarget.value)}
+              minRows={3}
+              required
+            />
+
+            <TextInput
+              label="Substitute Employee ID (Optional)"
+              placeholder="Enter User ID of nominated colleague"
+              value={substituteId}
+              onChange={(e) => setSubstituteId(e.currentTarget.value)}
+            />
+
+            <Checkbox
+              label="Station Leave Required (Leaving Jabalpur)"
+              checked={leavingStation}
+              onChange={(e) => setLeavingStation(e.currentTarget.checked)}
+            />
+
+            {leavingStation && (
+              <Stack gap="xs">
+                <TextInput
+                  label="Contact Address while on leave"
+                  placeholder="Address outside station"
+                  value={stationAddress}
+                  onChange={(e) => setStationAddress(e.currentTarget.value)}
+                />
+                <TextInput
+                  label="Emergency Phone"
+                  placeholder="Emergency contact number"
+                  value={emergencyPhone}
+                  onChange={(e) => setEmergencyPhone(e.currentTarget.value)}
+                />
+              </Stack>
+            )}
+
+            <Button type="submit" color="blue" mt="md">
+              Submit Leave Application
+            </Button>
+          </Stack>
+        </form>
+      </Card>
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/pages/ApprovalsPage.tsx b/client/src/modules/elm/pages/ApprovalsPage.tsx
new file mode 100644
index 00000000..81bbabbc
--- /dev/null
+++ b/client/src/modules/elm/pages/ApprovalsPage.tsx
@@ -0,0 +1,91 @@
+import React from "react";
+import {
+  Card,
+  Title,
+  Table,
+  Badge,
+  Button,
+  Stack,
+  Text,
+  Group,
+} from "@mantine/core";
+
+interface ApprovalsPageProps {
+  role: "unit_head" | "establishment" | "sanction";
+}
+
+export default function ApprovalsPage({ role }: ApprovalsPageProps) {
+  const titles = {
+    unit_head: "Unit Head Leave Reviews",
+    establishment: "Establishment Verification Queue",
+    sanction: "Competent Authority Sanction Decisions",
+  };
+
+  const pendingList = [
+    {
+      id: 201,
+      employeeName: "Dr. A. Verma",
+      category: "EL",
+      days: 4,
+      period: "2026-11-10 to 2026-11-13",
+      substitute: "Accepted (Dr. K. Patel)",
+      stationLeave: "Yes (Delhi conference)",
+    },
+  ];
+
+  return (
+    <Stack gap="lg">
+      <Title order={2}>{titles[role]}</Title>
+      <Text c="dimmed" size="sm">
+        Process leave applications awaiting your review or sanction decision.
+      </Text>
+
+      <Card withBorder radius="md" p="md">
+        <Table striped>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>ID</Table.Th>
+              <Table.Th>Employee</Table.Th>
+              <Table.Th>Category</Table.Th>
+              <Table.Th>Days</Table.Th>
+              <Table.Th>Period</Table.Th>
+              <Table.Th>Substitute Status</Table.Th>
+              <Table.Th>Station Leave</Table.Th>
+              <Table.Th>Action</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {pendingList.map((p) => (
+              <Table.Tr key={p.id}>
+                <Table.Td>#{p.id}</Table.Td>
+                <Table.Td>{p.employeeName}</Table.Td>
+                <Table.Td><Badge color="blue">{p.category}</Badge></Table.Td>
+                <Table.Td>{p.days}</Table.Td>
+                <Table.Td>{p.period}</Table.Td>
+                <Table.Td><Badge color="teal" variant="light">{p.substitute}</Badge></Table.Td>
+                <Table.Td>{p.stationLeave}</Table.Td>
+                <Table.Td>
+                  {role === "unit_head" && (
+                    <Group gap="xs">
+                      <Button size="xs" color="teal">Recommend</Button>
+                      <Button size="xs" color="orange" variant="light">Not Recommend</Button>
+                    </Group>
+                  )}
+                  {role === "establishment" && (
+                    <Button size="xs" color="blue">Verify & Route</Button>
+                  )}
+                  {role === "sanction" && (
+                    <Group gap="xs">
+                      <Button size="xs" color="teal">Sanction</Button>
+                      <Button size="xs" color="red" variant="subtle">Reject</Button>
+                    </Group>
+                  )}
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/pages/MyLeavesPage.tsx b/client/src/modules/elm/pages/MyLeavesPage.tsx
new file mode 100644
index 00000000..ab91aba2
--- /dev/null
+++ b/client/src/modules/elm/pages/MyLeavesPage.tsx
@@ -0,0 +1,113 @@
+import React from "react";
+import {
+  Card,
+  Title,
+  Table,
+  Badge,
+  Button,
+  Stack,
+  Text,
+  Group,
+  SimpleGrid,
+  Paper,
+} from "@mantine/core";
+
+export default function MyLeavesPage() {
+  const balances = [
+    { category: "CL", label: "Casual Leave", total: 8, availed: 1.5, available: 6.5 },
+    { category: "RH", label: "Restricted Holiday", total: 2, availed: 0, available: 2 },
+    { category: "SCL", label: "Special Casual Leave", total: 15, availed: 0, available: 15 },
+    { category: "EL", label: "Earned Leave", total: 30, availed: 5, available: 25 },
+    { category: "COL", label: "Commuted Leave", total: 20, availed: 0, available: 20 },
+  ];
+
+  const applications = [
+    {
+      id: 101,
+      category: "CL",
+      startDate: "2026-10-20",
+      endDate: "2026-10-20",
+      days: 0.5,
+      reason: "Personal urgent work (First half)",
+      status: "approved",
+    },
+    {
+      id: 102,
+      category: "EL",
+      startDate: "2026-11-02",
+      endDate: "2026-11-06",
+      days: 5.0,
+      reason: "Family function outside Jabalpur",
+      status: "awaiting_unit_head",
+    },
+  ];
+
+  return (
+    <Stack gap="lg">
+      <Title order={2}>My Leaves & Balances</Title>
+
+      {/* Balance Cards */}
+      <SimpleGrid cols={{ base: 1, sm: 3, md: 5 }}>
+        {balances.map((b) => (
+          <Paper key={b.category} withBorder p="md" radius="md">
+            <Text size="xs" c="dimmed" tt="uppercase" fw={700}>
+              {b.label} ({b.category})
+            </Text>
+            <Title order={3} mt="xs">
+              {b.available} <Text span size="sm" c="dimmed">/ {b.total}</Text>
+            </Title>
+            <Text size="xs" c="dimmed" mt={4}>
+              Availed: {b.availed} days
+            </Text>
+          </Paper>
+        ))}
+      </SimpleGrid>
+
+      {/* Applications Table */}
+      <Card withBorder radius="md" p="md">
+        <Title order={4} mb="md">Application History</Title>
+        <Table striped highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>ID</Table.Th>
+              <Table.Th>Category</Table.Th>
+              <Table.Th>Dates</Table.Th>
+              <Table.Th>Days</Table.Th>
+              <Table.Th>Reason</Table.Th>
+              <Table.Th>Status</Table.Th>
+              <Table.Th>Action</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {applications.map((app) => (
+              <Table.Tr key={app.id}>
+                <Table.Td>#{app.id}</Table.Td>
+                <Table.Td><Badge color="blue">{app.category}</Badge></Table.Td>
+                <Table.Td>{app.startDate} to {app.endDate}</Table.Td>
+                <Table.Td>{app.days}</Table.Td>
+                <Table.Td>{app.reason}</Table.Td>
+                <Table.Td>
+                  <Badge color={app.status === "approved" ? "teal" : "yellow"}>
+                    {app.status.replace(/_/g, " ")}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>
+                  {app.status === "awaiting_unit_head" && (
+                    <Button size="xs" color="red" variant="subtle">
+                      Withdraw
+                    </Button>
+                  )}
+                  {app.status === "approved" && (
+                    <Button size="xs" color="gray" variant="subtle">
+                      Cancel
+                    </Button>
+                  )}
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/pages/SubstitutePage.tsx b/client/src/modules/elm/pages/SubstitutePage.tsx
new file mode 100644
index 00000000..b251845f
--- /dev/null
+++ b/client/src/modules/elm/pages/SubstitutePage.tsx
@@ -0,0 +1,66 @@
+import React from "react";
+import {
+  Card,
+  Title,
+  Table,
+  Badge,
+  Button,
+  Stack,
+  Text,
+  Group,
+} from "@mantine/core";
+
+export default function SubstitutePage() {
+  const pendingRequests = [
+    {
+      id: 104,
+      applicantName: "Prof. R. Sharma",
+      category: "EL",
+      period: "2026-11-05 to 2026-11-09",
+      duties: "CS302 Lectures and Lab session",
+    },
+  ];
+
+  return (
+    <Stack gap="lg">
+      <Title order={2}>Substitute Responsibility Requests</Title>
+      <Text c="dimmed" size="sm">
+        Review colleague requests nominating you to cover duties during their absence.
+      </Text>
+
+      <Card withBorder radius="md" p="md">
+        {pendingRequests.length === 0 ? (
+          <Text c="dimmed">No pending substitute requests.</Text>
+        ) : (
+          <Table striped>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Applicant</Table.Th>
+                <Table.Th>Leave Category</Table.Th>
+                <Table.Th>Period</Table.Th>
+                <Table.Th>Coverage Description</Table.Th>
+                <Table.Th>Action</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {pendingRequests.map((r) => (
+                <Table.Tr key={r.id}>
+                  <Table.Td>{r.applicantName}</Table.Td>
+                  <Table.Td><Badge color="blue">{r.category}</Badge></Table.Td>
+                  <Table.Td>{r.period}</Table.Td>
+                  <Table.Td>{r.duties}</Table.Td>
+                  <Table.Td>
+                    <Group gap="xs">
+                      <Button size="xs" color="teal">Accept</Button>
+                      <Button size="xs" color="red" variant="subtle">Decline</Button>
+                    </Group>
+                  </Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        )}
+      </Card>
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/routes.tsx b/client/src/modules/elm/routes.tsx
new file mode 100644
index 00000000..fbf0035f
--- /dev/null
+++ b/client/src/modules/elm/routes.tsx
@@ -0,0 +1,19 @@
+import { lazy } from "react";
+import { Navigate, type RouteObject } from "react-router-dom";
+
+const ApplyLeavePage = lazy(() => import("./pages/ApplyLeavePage"));
+const MyLeavesPage = lazy(() => import("./pages/MyLeavesPage"));
+const SubstitutePage = lazy(() => import("./pages/SubstitutePage"));
+const ApprovalsPage = lazy(() => import("./pages/ApprovalsPage"));
+const AdminPage = lazy(() => import("./pages/AdminPage"));
+
+export const routes: RouteObject[] = [
+  { index: true, element: <Navigate to="mine" replace /> },
+  { path: "apply", element: <ApplyLeavePage /> },
+  { path: "mine", element: <MyLeavesPage /> },
+  { path: "substitute-requests", element: <SubstitutePage /> },
+  { path: "unit-head-reviews", element: <ApprovalsPage role="unit_head" /> },
+  { path: "establishment-routing", element: <ApprovalsPage role="establishment" /> },
+  { path: "sanction-decisions", element: <ApprovalsPage role="sanction" /> },
+  { path: "admin", element: <AdminPage /> },
+];
diff --git a/config/settings/base.py b/config/settings/base.py
index 0dc7ada1..a346a065 100644
--- a/config/settings/base.py
+++ b/config/settings/base.py
@@ -90,6 +90,7 @@ def env_list(name, default=None):
 # See docs/03-platform/module-authoring-guide.md to add one.
 DOMAIN_MODULES = [
     "modules.placement",
+    "modules.elm",
 ]
 
 INSTALLED_APPS = (DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS
diff --git a/config/urls.py b/config/urls.py
index 33f7835b..a9f602e7 100644
--- a/config/urls.py
+++ b/config/urls.py
@@ -16,6 +16,7 @@
     path("api/v1/", include("fusion_auth.urls")),
     path("api/v1/directory/", include("modules.directory.api.urls")),
     path("api/v1/placement/", include("modules.placement.api.urls")),
+    path("api/v1/elm/", include("modules.elm.api.urls")),
     path("api/schema/", SpectacularAPIView.as_view(), name="schema"),
     path("api/docs/", SpectacularSwaggerView.as_view(url_name="schema"), name="docs"),
 ]
diff --git a/modules/elm/__init__.py b/modules/elm/__init__.py
new file mode 100644
index 00000000..8b21a251
--- /dev/null
+++ b/modules/elm/__init__.py
@@ -0,0 +1 @@
+"""Employee Leave Management (ELM) module."""
diff --git a/modules/elm/api/__init__.py b/modules/elm/api/__init__.py
new file mode 100644
index 00000000..d6660144
--- /dev/null
+++ b/modules/elm/api/__init__.py
@@ -0,0 +1 @@
+"""ELM API package."""
diff --git a/modules/elm/api/serializers.py b/modules/elm/api/serializers.py
new file mode 100644
index 00000000..8a0af606
--- /dev/null
+++ b/modules/elm/api/serializers.py
@@ -0,0 +1,83 @@
+"""DRF Serializers for ELM module."""
+from rest_framework import serializers
+
+from modules.elm.models.balances import LeaveBalance
+from modules.elm.models.holidays import HolidayCalendar
+from modules.elm.models.leaves import LeaveRequest, LeaveTransitionHistory
+
+
+class LeaveTransitionHistorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveTransitionHistory
+        fields = ["id", "from_status", "to_status", "actor_user_id", "remarks", "created_at"]
+
+
+class LeaveRequestSerializer(serializers.ModelSerializer):
+    transitions = LeaveTransitionHistorySerializer(many=True, read_only=True)
+
+    class Meta:
+        model = LeaveRequest
+        fields = [
+            "id", "user_id", "category", "start_date", "end_date",
+            "is_half_day", "half_day_period", "days_calculated", "reason",
+            "status", "leaving_station", "station_start_date", "station_end_date",
+            "station_address", "emergency_phone", "substitute_user_id",
+            "substitute_status", "unit_head_user_id", "unit_head_recommendation",
+            "unit_head_remarks", "sanctioning_authority_user_id", "sanctioned_at",
+            "is_offline_sanctioned", "offline_sanction_reference",
+            "created_at", "updated_at", "transitions",
+        ]
+
+
+class LeaveApplicationCreateSerializer(serializers.Serializer):
+    category = serializers.ChoiceField(choices=LeaveRequest.CATEGORY_CHOICES)
+    start_date = serializers.DateField()
+    end_date = serializers.DateField()
+    is_half_day = serializers.BooleanField(default=False)
+    half_day_period = serializers.ChoiceField(
+        choices=LeaveRequest.HALF_DAY_CHOICES, required=False, allow_null=True
+    )
+    reason = serializers.CharField(max_length=1000)
+    leaving_station = serializers.BooleanField(default=False)
+    station_start_date = serializers.DateField(required=False, allow_null=True)
+    station_end_date = serializers.DateField(required=False, allow_null=True)
+    station_address = serializers.CharField(max_length=255, required=False, allow_blank=True)
+    emergency_phone = serializers.CharField(max_length=32, required=False, allow_blank=True)
+    substitute_user_id = serializers.IntegerField(required=False, allow_null=True)
+    unit_head_user_id = serializers.IntegerField(required=False, allow_null=True)
+
+
+class LeaveBalanceSerializer(serializers.ModelSerializer):
+    available_balance = serializers.DecimalField(max_digits=5, decimal_places=2, read_only=True)
+
+    class Meta:
+        model = LeaveBalance
+        fields = [
+            "id", "user_id", "year", "category",
+            "credited_balance", "carried_forward", "availed_balance", "available_balance",
+        ]
+
+
+class HolidayCalendarSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HolidayCalendar
+        fields = ["id", "date", "end_date", "name", "holiday_type", "year", "is_published"]
+
+
+class SubstituteResponseSerializer(serializers.Serializer):
+    accepted = serializers.BooleanField()
+
+
+class UnitHeadReviewSerializer(serializers.Serializer):
+    decision = serializers.ChoiceField(choices=["approve", "reject", "recommend", "not_recommend"])
+    remarks = serializers.CharField(max_length=500, required=False, allow_blank=True)
+
+
+class SanctionDecisionSerializer(serializers.Serializer):
+    approve = serializers.BooleanField()
+    remarks = serializers.CharField(max_length=500, required=False, allow_blank=True)
+
+
+class ResumptionSubmitSerializer(serializers.Serializer):
+    actual_date = serializers.DateField()
+    remarks = serializers.CharField(max_length=500, required=False, allow_blank=True)
diff --git a/modules/elm/api/urls.py b/modules/elm/api/urls.py
new file mode 100644
index 00000000..01d9ed97
--- /dev/null
+++ b/modules/elm/api/urls.py
@@ -0,0 +1,19 @@
+"""URL configuration for ELM API endpoints."""
+from django.urls import path
+
+from modules.elm.api import views
+
+urlpatterns = [
+    path("leaves/", views.MyLeavesView.as_view(), name="elm-my-leaves"),
+    path("leaves/<int:pk>/", views.LeaveDetailWithdrawView.as_view(), name="elm-leave-detail-withdraw"),
+    path("leaves/<int:pk>/cancel/", views.LeaveCancellationView.as_view(), name="elm-leave-cancel"),
+    path("leaves/<int:pk>/resume/", views.LeaveResumptionView.as_view(), name="elm-leave-resume"),
+    path("balances/", views.MyBalancesView.as_view(), name="elm-my-balances"),
+    path("substitute/", views.SubstituteQueueView.as_view(), name="elm-substitute-queue"),
+    path("substitute/<int:pk>/", views.SubstituteQueueView.as_view(), name="elm-substitute-respond"),
+    path("unit-head/", views.UnitHeadReviewView.as_view(), name="elm-unit-head-queue"),
+    path("unit-head/<int:pk>/", views.UnitHeadReviewView.as_view(), name="elm-unit-head-review"),
+    path("sanctions/", views.SanctionDecisionView.as_view(), name="elm-sanctions-queue"),
+    path("sanctions/<int:pk>/", views.SanctionDecisionView.as_view(), name="elm-sanctions-decide"),
+    path("holidays/", views.HolidayCalendarView.as_view(), name="elm-holidays"),
+]
diff --git a/modules/elm/api/views.py b/modules/elm/api/views.py
new file mode 100644
index 00000000..75d5d9fe
--- /dev/null
+++ b/modules/elm/api/views.py
@@ -0,0 +1,199 @@
+"""REST API endpoints for ELM module."""
+from datetime import date
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from fusion_auth.permissions import HasModuleGrant, HasPermission, IsAuthenticatedPrincipal
+from modules.elm.api.serializers import (
+    HolidayCalendarSerializer,
+    LeaveApplicationCreateSerializer,
+    LeaveBalanceSerializer,
+    LeaveRequestSerializer,
+    ResumptionSubmitSerializer,
+    SanctionDecisionSerializer,
+    SubstituteResponseSerializer,
+    UnitHeadReviewSerializer,
+)
+from modules.elm.models.holidays import HolidayCalendar
+from modules.elm.selectors import leaves as selectors
+from modules.elm.services import applications as app_service
+from modules.elm.services import workflows as wf_service
+
+
+def _get_current_user_id(request) -> int:
+    principal = getattr(request, "principal", None)
+    if principal and getattr(principal, "user_id", None):
+        return int(principal.user_id)
+    if getattr(request.user, "id", None):
+        return int(request.user.id)
+    return 1  # Fallback for dev/unauthenticated local testing
+
+
+class MyLeavesView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.view_self")]
+
+    def get(self, request):
+        uid = _get_current_user_id(request)
+        leaves = selectors.get_user_leaves(uid)
+        return Response(LeaveRequestSerializer(leaves, many=True).data)
+
+    def post(self, request):
+        uid = _get_current_user_id(request)
+        serializer = LeaveApplicationCreateSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            req = app_service.apply_for_leave(
+                user_id=uid,
+                **serializer.validated_data,
+            )
+            return Response(LeaveRequestSerializer(req).data, status=status.HTTP_201_CREATED)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class LeaveDetailWithdrawView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.view_self")]
+
+    def get(self, request, pk: int):
+        uid = _get_current_user_id(request)
+        leave = selectors.get_user_leave_detail(uid, pk)
+        if not leave:
+            return Response({"error": "Leave not found."}, status=status.HTTP_404_NOT_FOUND)
+        return Response(LeaveRequestSerializer(leave).data)
+
+    def delete(self, request, pk: int):
+        """Immediate withdrawal (EL-UC-007, BR-EL-022)."""
+        uid = _get_current_user_id(request)
+        try:
+            req = app_service.withdraw_leave_application(uid, pk)
+            return Response(LeaveRequestSerializer(req).data)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class LeaveCancellationView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.cancel")]
+
+    def post(self, request, pk: int):
+        uid = _get_current_user_id(request)
+        try:
+            req = wf_service.request_cancellation(uid, pk)
+            return Response(LeaveRequestSerializer(req).data)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class LeaveResumptionView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.resume")]
+
+    def post(self, request, pk: int):
+        uid = _get_current_user_id(request)
+        serializer = ResumptionSubmitSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            req = wf_service.submit_resumption(
+                user_id=uid,
+                leave_id=pk,
+                actual_date=serializer.validated_data["actual_date"],
+                remarks=serializer.validated_data.get("remarks", ""),
+            )
+            return Response(LeaveRequestSerializer(req).data)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class MyBalancesView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.view_self")]
+
+    def get(self, request):
+        uid = _get_current_user_id(request)
+        year = int(request.query_params.get("year", date.today().year))
+        balances = selectors.get_user_balances(uid, year)
+        return Response(LeaveBalanceSerializer(balances, many=True).data)
+
+
+class SubstituteQueueView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.substitute")]
+
+    def get(self, request):
+        uid = _get_current_user_id(request)
+        pending = selectors.get_substitute_pending_requests(uid)
+        return Response(LeaveRequestSerializer(pending, many=True).data)
+
+    def post(self, request, pk: int):
+        uid = _get_current_user_id(request)
+        serializer = SubstituteResponseSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            req = wf_service.respond_substitute(
+                substitute_user_id=uid,
+                leave_id=pk,
+                accepted=serializer.validated_data["accepted"],
+            )
+            return Response(LeaveRequestSerializer(req).data)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class UnitHeadReviewView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.review")]
+
+    def get(self, request):
+        uid = _get_current_user_id(request)
+        pending = selectors.get_unit_head_pending_requests(uid)
+        return Response(LeaveRequestSerializer(pending, many=True).data)
+
+    def post(self, request, pk: int):
+        uid = _get_current_user_id(request)
+        serializer = UnitHeadReviewSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            req = wf_service.review_unit_head(
+                unit_head_user_id=uid,
+                leave_id=pk,
+                decision=serializer.validated_data["decision"],
+                remarks=serializer.validated_data.get("remarks", ""),
+            )
+            return Response(LeaveRequestSerializer(req).data)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class SanctionDecisionView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm"), HasPermission("elm.leave.sanction")]
+
+    def get(self, request):
+        uid = _get_current_user_id(request)
+        pending = selectors.get_sanctioning_authority_pending_requests(uid)
+        return Response(LeaveRequestSerializer(pending, many=True).data)
+
+    def post(self, request, pk: int):
+        uid = _get_current_user_id(request)
+        serializer = SanctionDecisionSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            req = wf_service.make_sanction_decision(
+                authority_user_id=uid,
+                leave_id=pk,
+                approve=serializer.validated_data["approve"],
+                remarks=serializer.validated_data.get("remarks", ""),
+            )
+            return Response(LeaveRequestSerializer(req).data)
+        except ValueError as err:
+            return Response({"error": str(err)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class HolidayCalendarView(APIView):
+    permission_classes = [IsAuthenticatedPrincipal, HasModuleGrant("elm")]
+
+    def get(self, request):
+        year = int(request.query_params.get("year", date.today().year))
+        holidays = HolidayCalendar.objects.filter(year=year, is_published=True).order_by("date")
+        return Response(HolidayCalendarSerializer(holidays, many=True).data)
diff --git a/modules/elm/apps.py b/modules/elm/apps.py
new file mode 100644
index 00000000..c8c2a1b7
--- /dev/null
+++ b/modules/elm/apps.py
@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class ElmConfig(AppConfig):
+    name = "modules.elm"
+    label = "elm"
+    verbose_name = "Employee Leave Management"
diff --git a/modules/elm/contracts.py b/modules/elm/contracts.py
new file mode 100644
index 00000000..638f7d29
--- /dev/null
+++ b/modules/elm/contracts.py
@@ -0,0 +1,78 @@
+"""ELM's public surface for other modules. Plural by signature."""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import date
+
+
+@dataclass(frozen=True)
+class ActiveLeaveDTO:
+    user_id: int
+    has_active_leave: bool
+    leave_category: str | None
+    start_date: str | None
+    end_date: str | None
+
+
+@dataclass(frozen=True)
+class UserBalancesDTO:
+    user_id: int
+    year: int
+    balances: dict[str, float]
+
+
+def get_active_leaves(user_ids: Sequence[int],
+                      on_date: date | None = None) -> dict[int, ActiveLeaveDTO]:
+    """Check active approved leaves for multiple users on a given date (plural contract)."""
+    from modules.elm.models.leaves import LeaveRequest
+
+    ids = {int(i) for i in user_ids if i is not None}
+    if not ids:
+        return {}
+
+    target_date = on_date or date.today()
+    rows = LeaveRequest.objects.filter(
+        user_id__in=ids,
+        status="approved",
+        start_date__lte=target_date,
+        end_date__gte=target_date,
+    )
+
+    result = {
+        uid: ActiveLeaveDTO(user_id=uid, has_active_leave=False, leave_category=None,
+                            start_date=None, end_date=None)
+        for uid in ids
+    }
+
+    for req in rows:
+        result[req.user_id] = ActiveLeaveDTO(
+            user_id=req.user_id,
+            has_active_leave=True,
+            leave_category=req.category,
+            start_date=req.start_date.isoformat(),
+            end_date=req.end_date.isoformat(),
+        )
+
+    return result
+
+
+def get_leave_balances(user_ids: Sequence[int],
+                       year: int) -> dict[int, UserBalancesDTO]:
+    """Retrieve leave balances for multiple users for a specific year (plural contract)."""
+    from modules.elm.models.balances import LeaveBalance
+
+    ids = {int(i) for i in user_ids if i is not None}
+    if not ids:
+        return {}
+
+    balances = LeaveBalance.objects.filter(user_id__in=ids, year=year)
+    result = {
+        uid: UserBalancesDTO(user_id=uid, year=year, balances={})
+        for uid in ids
+    }
+
+    for b in balances:
+        result[b.user_id].balances[b.category] = float(b.available_balance)
+
+    return result
diff --git a/modules/elm/domain/__init__.py b/modules/elm/domain/__init__.py
new file mode 100644
index 00000000..b7686842
--- /dev/null
+++ b/modules/elm/domain/__init__.py
@@ -0,0 +1 @@
+"""ELM pure Python domain layer. No Django, DRF, or external framework imports."""
diff --git a/modules/elm/domain/calculations.py b/modules/elm/domain/calculations.py
new file mode 100644
index 00000000..8d416bc9
--- /dev/null
+++ b/modules/elm/domain/calculations.py
@@ -0,0 +1,159 @@
+"""Pure Python business calculations for ELM.
+
+Encapsulates leave-day counting rules, half-day CL calculations,
+VL-to-EL conversions, and overlap validations.
+Zero framework dependencies.
+"""
+from __future__ import annotations
+
+from collections.abc import Set
+from datetime import date, timedelta
+
+from modules.elm.domain.entities import LeaveCategory, LeaveValidationResult
+
+
+def calculate_leave_days(
+    category: str | LeaveCategory,
+    start_date: date,
+    end_date: date,
+    is_half_day: bool = False,
+    half_day_period: str | None = None,
+    closed_holidays: Set[date] | None = None,
+) -> float:
+    """Calculate the net leave days consumed by an application.
+
+    Rules implemented:
+    - BR-EL-010: Half-day CL consumes exactly 0.5 days.
+    - BR-EL-011: Continuous counting for EL, VL, COL includes weekends & holidays.
+    - BR-EL-011: CL, SCL, RH exclude weekends (Saturday, Sunday) and closed holidays.
+    """
+    if start_date > end_date:
+        raise ValueError("start_date cannot be after end_date.")
+
+    cat_str = category.value if isinstance(category, LeaveCategory) else str(category)
+
+    # Half-day Casual Leave rule (BR-EL-010)
+    if cat_str == LeaveCategory.CL.value and is_half_day:
+        if start_date != end_date:
+            raise ValueError("Half-day CL must have identical start and end dates.")
+        return 0.5
+
+    # Continuous counting for EL, VL, COL (BR-EL-011)
+    if cat_str in (LeaveCategory.EL.value, LeaveCategory.VL.value, LeaveCategory.COL.value):
+        total_calendar_days = (end_date - start_date).days + 1
+        return float(total_calendar_days)
+
+    # Working-day counting for CL, SCL, RH (exclude weekends and closed holidays)
+    holidays = closed_holidays or set()
+    current = start_date
+    working_days = 0
+
+    while current <= end_date:
+        # 5 is Saturday, 6 is Sunday
+        if current.weekday() < 5 and current not in holidays:
+            working_days += 1
+        current += timedelta(days=1)
+
+    return float(working_days)
+
+
+def calculate_vl_to_el_conversion(unused_vl: float) -> float:
+    """Calculate year-end conversion of Faculty Vacation Leave to Earned Leave.
+
+    Rule BR-EL-007: All unused VL converts to EL at 2 VL : 1 EL.
+    Fractional conversion is supported (e.g. 15 VL -> 7.5 EL).
+    """
+    if unused_vl < 0:
+        return 0.0
+    return round(unused_vl / 2.0, 2)
+
+
+def check_date_overlap(
+    start1: date,
+    end1: date,
+    is_half1: bool,
+    period1: str | None,
+    start2: date,
+    end2: date,
+    is_half2: bool,
+    period2: str | None,
+) -> bool:
+    """Check if two leave periods conflict.
+
+    Rule BR-EL-012: First-half and second-half CL on the same date do not overlap.
+    """
+    # If entirely distinct dates, no overlap
+    if end1 < start2 or end2 < start1:
+        return False
+
+    # Single-date half-day exception
+    if start1 == end1 == start2 == end2:
+        if is_half1 and is_half2:
+            # Different half-days (first_half vs second_half) do NOT overlap
+            if period1 and period2 and period1 != period2:
+                return False
+
+    return True
+
+
+def validate_leave_application(
+    category: str,
+    start_date: date,
+    end_date: date,
+    available_balance: float,
+    is_half_day: bool = False,
+    half_day_period: str | None = None,
+    closed_holidays: Set[date] | None = None,
+    is_faculty: bool = True,
+    vacation_periods: list[tuple[date, date]] | None = None,
+    published_rh_dates: Set[date] | None = None,
+) -> LeaveValidationResult:
+    """Validate leave eligibility, calendar constraints, and balance (BR-EL-001 - BR-EL-006)."""
+    if start_date > end_date:
+        return LeaveValidationResult(False, 0.0, "Start date cannot be after end date.")
+
+    # Faculty Vacation Leave constraint (BR-EL-006)
+    if category == LeaveCategory.VL.value:
+        if not is_faculty:
+            return LeaveValidationResult(False, 0.0, "Vacation Leave is only available to faculty.")
+        # Must fall within published academic vacation period
+        vac_periods = vacation_periods or []
+        falls_in_vacation = any(v_start <= start_date and end_date <= v_end
+                                for v_start, v_end in vac_periods)
+        if not falls_in_vacation:
+            return LeaveValidationResult(
+                False, 0.0, "Vacation Leave must fall entirely within a published vacation period."
+            )
+
+    # Restricted Holiday calendar constraint (BR-EL-003)
+    if category == LeaveCategory.RH.value:
+        rh_dates = published_rh_dates or set()
+        if start_date not in rh_dates or end_date not in rh_dates:
+            return LeaveValidationResult(
+                False, 0.0, "Restricted Holiday request must match published RH calendar dates."
+            )
+
+    # Calculate net days
+    try:
+        needed_days = calculate_leave_days(
+            category=category,
+            start_date=start_date,
+            end_date=end_date,
+            is_half_day=is_half_day,
+            half_day_period=half_day_period,
+            closed_holidays=closed_holidays,
+        )
+    except ValueError as e:
+        return LeaveValidationResult(False, 0.0, str(e))
+
+    if needed_days <= 0:
+        return LeaveValidationResult(False, 0.0, "Requested leave period results in 0 valid leave days.")
+
+    # Balance check
+    if needed_days > available_balance:
+        return LeaveValidationResult(
+            False, needed_days,
+            f"Insufficient leave balance. Requested: {needed_days}, Available: {available_balance}."
+        )
+
+    return LeaveValidationResult(True, needed_days)
diff --git a/modules/elm/domain/entities.py b/modules/elm/domain/entities.py
new file mode 100644
index 00000000..240c5eb1
--- /dev/null
+++ b/modules/elm/domain/entities.py
@@ -0,0 +1,54 @@
+"""Pure domain entities and types for ELM."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from enum import Enum
+
+
+class LeaveCategory(str, Enum):
+    CL = "CL"        # Casual Leave
+    RH = "RH"        # Restricted Holiday
+    SCL = "SCL"      # Special Casual Leave
+    EL = "EL"        # Earned Leave
+    VL = "VL"        # Vacation Leave
+    COL = "COL"      # Commuted Leave (Medical)
+
+
+class LeaveStatus(str, Enum):
+    DRAFT = "draft"
+    AWAITING_SUBSTITUTE = "awaiting_substitute"
+    SUBSTITUTE_DECLINED = "substitute_declined"
+    AWAITING_UNIT_HEAD = "awaiting_unit_head"
+    AWAITING_DIRECTOR_SELF_SANCTION = "awaiting_director_self_sanction"
+    AWAITING_ESTABLISHMENT = "awaiting_establishment"
+    AWAITING_FINAL_SANCTION = "awaiting_final_sanction"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+    WITHDRAWN = "withdrawn"
+    CANCELLATION_PENDING_UNIT_HEAD = "cancellation_pending_unit_head"
+    CANCELLATION_PENDING_ESTABLISHMENT = "cancellation_pending_establishment"
+    CANCELLATION_PENDING_FINAL = "cancellation_pending_final"
+    CANCELLED = "cancelled"
+    EXTENSION_PENDING_SUBSTITUTE = "extension_pending_substitute"
+    EXTENSION_PENDING_UNIT_HEAD = "extension_pending_unit_head"
+    EXTENSION_PENDING_FINAL = "extension_pending_final"
+    EXTENDED = "extended"
+    RESUMPTION_PENDING = "resumption_pending"
+    RESUMED = "resumed"
+
+
+@dataclass(frozen=True)
+class LeaveValidationResult:
+    is_valid: bool
+    calculated_days: float
+    error_message: str | None = None
+
+
+@dataclass(frozen=True)
+class StateTransitionResult:
+    success: bool
+    new_status: LeaveStatus
+    message: str
+    balance_deduction: float = 0.0
+    balance_refund: float = 0.0
diff --git a/modules/elm/domain/state_machine.py b/modules/elm/domain/state_machine.py
new file mode 100644
index 00000000..6ac0e258
--- /dev/null
+++ b/modules/elm/domain/state_machine.py
@@ -0,0 +1,183 @@
+"""Pure Python State Machine for ELM Workflows.
+
+Implements Authoritative State Transition Tables:
+- CW-EL-01: New Leave Processing & Immediate Withdrawal
+- CW-EL-02: Pre-Start Approved Leave Cancellation
+- CW-EL-03: Ongoing Leave Extension
+- CW-EL-04: Resumption Review & Balance Adjustments
+Zero framework dependencies.
+"""
+from __future__ import annotations
+
+from modules.elm.domain.entities import LeaveCategory, LeaveStatus, StateTransitionResult
+
+
+class LeaveStateMachine:
+    """Encapsulates valid state transitions and guard rules for ELM."""
+
+    PENDING_STATUSES = {
+        LeaveStatus.AWAITING_SUBSTITUTE,
+        LeaveStatus.SUBSTITUTE_DECLINED,
+        LeaveStatus.AWAITING_UNIT_HEAD,
+        LeaveStatus.AWAITING_DIRECTOR_SELF_SANCTION,
+        LeaveStatus.AWAITING_ESTABLISHMENT,
+        LeaveStatus.AWAITING_FINAL_SANCTION,
+    }
+
+    # -------------------------------------------------------------------------
+    # CW-EL-01: New Leave Transitions
+    # -------------------------------------------------------------------------
+    @staticmethod
+    def submit_application(
+        requires_substitute: bool,
+        is_director: bool,
+    ) -> LeaveStatus:
+        """STT Row 1-3: Draft -> Pending progression."""
+        if requires_substitute:
+            return LeaveStatus.AWAITING_SUBSTITUTE
+        if is_director:
+            return LeaveStatus.AWAITING_DIRECTOR_SELF_SANCTION
+        return LeaveStatus.AWAITING_UNIT_HEAD
+
+    @staticmethod
+    def process_substitute_response(
+        current_status: LeaveStatus,
+        accepted: bool,
+        is_director: bool,
+    ) -> StateTransitionResult:
+        """STT Row 4-6: Substitute response handling."""
+        if current_status != LeaveStatus.AWAITING_SUBSTITUTE:
+            return StateTransitionResult(False, current_status, "Request is not awaiting substitute.")
+
+        if not accepted:
+            return StateTransitionResult(
+                True, LeaveStatus.SUBSTITUTE_DECLINED,
+                "Substitute declined responsibility coverage."
+            )
+
+        next_status = (LeaveStatus.AWAITING_DIRECTOR_SELF_SANCTION
+                       if is_director else LeaveStatus.AWAITING_UNIT_HEAD)
+        return StateTransitionResult(True, next_status, "Substitute accepted responsibility.")
+
+    @staticmethod
+    def replace_substitute(current_status: LeaveStatus) -> StateTransitionResult:
+        """STT Row 7: Replace substitute after decline."""
+        if current_status != LeaveStatus.SUBSTITUTE_DECLINED:
+            return StateTransitionResult(False, current_status, "No substitute decline to recover from.")
+        return StateTransitionResult(
+            True, LeaveStatus.AWAITING_SUBSTITUTE, "Replacement substitute nominated."
+        )
+
+    @staticmethod
+    def unit_head_review(
+        category: str,
+        decision: str,  # "approve", "reject", "recommend", "not_recommend"
+        has_establishment_step: bool = True,
+    ) -> StateTransitionResult:
+        """STT Row 8-11: Unit Head review outcome."""
+        cat = category.upper()
+        # Direct final decision for CL and RH (BR-EL-016)
+        if cat in (LeaveCategory.CL.value, LeaveCategory.RH.value):
+            if decision == "approve":
+                return StateTransitionResult(True, LeaveStatus.APPROVED, "Approved by Unit Head.")
+            if decision == "reject":
+                return StateTransitionResult(True, LeaveStatus.REJECTED, "Rejected by Unit Head.")
+            return StateTransitionResult(False, LeaveStatus.AWAITING_UNIT_HEAD,
+                                         "CL/RH requires final approve or reject.")
+
+        # Higher sanction leaves (SCL, EL, VL, COL) - BR-EL-017, BR-EL-018
+        if decision not in ("recommend", "not_recommend"):
+            return StateTransitionResult(
+                False, LeaveStatus.AWAITING_UNIT_HEAD,
+                "Higher sanction leaves require Recommended or Not Recommended."
+            )
+
+        if has_establishment_step:
+            return StateTransitionResult(
+                True, LeaveStatus.AWAITING_ESTABLISHMENT,
+                f"Unit Head recorded {decision}; routed to Establishment."
+            )
+        return StateTransitionResult(
+            True, LeaveStatus.AWAITING_FINAL_SANCTION,
+            f"Unit Head recorded {decision}; routed to Sanctioning Authority."
+        )
+
+    @staticmethod
+    def establishment_route() -> StateTransitionResult:
+        """STT Row 12: Establishment verification and routing."""
+        return StateTransitionResult(
+            True, LeaveStatus.AWAITING_FINAL_SANCTION,
+            "Establishment record check complete; forwarded to Competent Authority."
+        )
+
+    @staticmethod
+    def final_sanction(approved: bool) -> StateTransitionResult:
+        """STT Row 13-16: Final Sanction decision."""
+        if approved:
+            return StateTransitionResult(True, LeaveStatus.APPROVED, "Leave sanctioned.")
+        return StateTransitionResult(True, LeaveStatus.REJECTED, "Leave rejected.")
+
+    @staticmethod
+    def withdraw_pending(current_status: LeaveStatus) -> StateTransitionResult:
+        """STT Row 17: Immediate withdrawal of pending request (BR-EL-022)."""
+        if current_status not in LeaveStateMachine.PENDING_STATUSES:
+            return StateTransitionResult(
+                False, current_status, "Only pending requests may be withdrawn."
+            )
+        return StateTransitionResult(
+            True, LeaveStatus.WITHDRAWN, "Request successfully withdrawn immediately."
+        )
+
+    # -------------------------------------------------------------------------
+    # CW-EL-02: Pre-Start Cancellation Transitions
+    # -------------------------------------------------------------------------
+    @staticmethod
+    def request_cancellation(current_status: LeaveStatus) -> StateTransitionResult:
+        """CW-EL-02 Row 1: Initiate cancellation on approved leave."""
+        if current_status != LeaveStatus.APPROVED:
+            return StateTransitionResult(
+                False, current_status, "Only approved leave may be cancelled."
+            )
+        return StateTransitionResult(
+            True, LeaveStatus.CANCELLATION_PENDING_UNIT_HEAD, "Cancellation request submitted."
+        )
+
+    @staticmethod
+    def review_cancellation(
+        category: str,
+        approved: bool,
+        current_status: LeaveStatus,
+        has_establishment_step: bool = True,
+    ) -> StateTransitionResult:
+        """CW-EL-02 Row 2-8: Review cancellation."""
+        cat = category.upper()
+        if cat in (LeaveCategory.CL.value, LeaveCategory.RH.value):
+            if approved:
+                return StateTransitionResult(
+                    True, LeaveStatus.CANCELLED, "Cancellation approved; balance restored."
+                )
+            return StateTransitionResult(
+                True, LeaveStatus.APPROVED, "Cancellation rejected; original leave retained."
+            )
+
+        # Higher sanction path
+        if current_status == LeaveStatus.CANCELLATION_PENDING_UNIT_HEAD:
+            next_step = (LeaveStatus.CANCELLATION_PENDING_ESTABLISHMENT
+                         if has_establishment_step else LeaveStatus.CANCELLATION_PENDING_FINAL)
+            return StateTransitionResult(True, next_step, "Cancellation recommendation recorded.")
+
+        if current_status == LeaveStatus.CANCELLATION_PENDING_ESTABLISHMENT:
+            return StateTransitionResult(
+                True, LeaveStatus.CANCELLATION_PENDING_FINAL, "Forwarded to Sanctioning Authority."
+            )
+
+        if current_status == LeaveStatus.CANCELLATION_PENDING_FINAL:
+            if approved:
+                return StateTransitionResult(
+                    True, LeaveStatus.CANCELLED, "Cancellation approved; balance restored."
+                )
+            return StateTransitionResult(
+                True, LeaveStatus.APPROVED, "Cancellation rejected; original leave retained."
+            )
+
+        return StateTransitionResult(False, current_status, "Invalid cancellation state.")
diff --git a/modules/elm/models/__init__.py b/modules/elm/models/__init__.py
new file mode 100644
index 00000000..a0e410db
--- /dev/null
+++ b/modules/elm/models/__init__.py
@@ -0,0 +1,12 @@
+"""ELM database models package."""
+from modules.elm.models.balances import LeaveAccountTransaction, LeaveBalance
+from modules.elm.models.holidays import HolidayCalendar
+from modules.elm.models.leaves import LeaveRequest, LeaveTransitionHistory
+
+__all__ = [
+    "LeaveRequest",
+    "LeaveTransitionHistory",
+    "LeaveBalance",
+    "LeaveAccountTransaction",
+    "HolidayCalendar",
+]
diff --git a/modules/elm/models/balances.py b/modules/elm/models/balances.py
new file mode 100644
index 00000000..0707c177
--- /dev/null
+++ b/modules/elm/models/balances.py
@@ -0,0 +1,74 @@
+"""Leave Balance and Ledger Transaction Models."""
+from decimal import Decimal
+
+from django.db import models
+
+from core.db.mixins import TimeStampedModel, UserScopedModel
+
+
+class LeaveBalance(TimeStampedModel, UserScopedModel):
+    """Annual leave entitlement and balance ledger per employee."""
+
+    CATEGORY_CHOICES = [
+        ("CL", "Casual Leave"),
+        ("RH", "Restricted Holiday"),
+        ("SCL", "Special Casual Leave"),
+        ("EL", "Earned Leave"),
+        ("VL", "Vacation Leave"),
+        ("COL", "Commuted Leave"),
+    ]
+
+    year = models.IntegerField(db_index=True)
+    category = models.CharField(max_length=8, choices=CATEGORY_CHOICES)
+    credited_balance = models.DecimalField(max_digits=5, decimal_places=2, default=Decimal("0.00"))
+    carried_forward = models.DecimalField(max_digits=5, decimal_places=2, default=Decimal("0.00"))
+    availed_balance = models.DecimalField(max_digits=5, decimal_places=2, default=Decimal("0.00"))
+
+    class Meta:
+        db_table = "elm_leave_balance"
+        constraints = [
+            models.UniqueConstraint(
+                fields=["user_id", "year", "category"],
+                name="elm_unique_user_year_category",
+            )
+        ]
+        indexes = [
+            models.Index(fields=["user_id", "year"], name="elm_balance_user_year_idx"),
+        ]
+
+    @property
+    def available_balance(self) -> Decimal:
+        return self.credited_balance + self.carried_forward - self.availed_balance
+
+    def __str__(self) -> str:
+        return f"User {self.user_id} - {self.category} ({self.year}): Avail {self.available_balance}"
+
+
+class LeaveAccountTransaction(TimeStampedModel, UserScopedModel):
+    """Audit log of all balance changes (credits, deductions, refunds, conversions, lapses)."""
+
+    TRANSACTION_TYPES = [
+        ("credit", "Annual Credit"),
+        ("carry_forward", "Carried Forward"),
+        ("deduction", "Leave Sanction Deduction"),
+        ("refund", "Cancellation / Early Return Refund"),
+        ("conversion", "VL to EL Year-End Conversion"),
+        ("lapse", "Year-End Lapse"),
+        ("admin_adjust", "Administrative Adjustment"),
+    ]
+
+    year = models.IntegerField(db_index=True)
+    category = models.CharField(max_length=8)
+    transaction_type = models.CharField(max_length=24, choices=TRANSACTION_TYPES)
+    days = models.DecimalField(max_digits=5, decimal_places=2)
+    reference_leave_id = models.IntegerField(null=True, blank=True)
+    description = models.CharField(max_length=255, blank=True)
+
+    class Meta:
+        db_table = "elm_account_transaction"
+        indexes = [
+            models.Index(fields=["user_id", "year", "category"], name="elm_tx_user_year_idx"),
+        ]
+
+    def __str__(self) -> str:
+        return f"User {self.user_id} - {self.transaction_type} {self.days} {self.category}"
diff --git a/modules/elm/models/holidays.py b/modules/elm/models/holidays.py
new file mode 100644
index 00000000..fa6a3cf9
--- /dev/null
+++ b/modules/elm/models/holidays.py
@@ -0,0 +1,36 @@
+"""Holiday Calendar and Vacation Period Models for ELM."""
+from django.db import models
+
+from core.db.mixins import TimeStampedModel
+
+
+class HolidayCalendar(TimeStampedModel):
+    """Institute Holiday Calendar supporting Closed Holidays and Restricted Holidays."""
+
+    HOLIDAY_TYPES = [
+        ("closed", "Closed Institute Holiday"),
+        ("restricted", "Restricted Holiday (RH)"),
+        ("vacation", "Faculty Vacation Period"),
+    ]
+
+    date = models.DateField(db_index=True)
+    end_date = models.DateField(null=True, blank=True, help_text="Used for vacation ranges")
+    name = models.CharField(max_length=120)
+    holiday_type = models.CharField(max_length=16, choices=HOLIDAY_TYPES)
+    year = models.IntegerField(db_index=True)
+    is_published = models.BooleanField(default=True)
+
+    class Meta:
+        db_table = "elm_holiday_calendar"
+        constraints = [
+            models.UniqueConstraint(
+                fields=["date", "holiday_type"],
+                name="elm_unique_date_holiday_type",
+            )
+        ]
+        indexes = [
+            models.Index(fields=["year", "holiday_type"], name="elm_holiday_year_type_idx"),
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.date}: {self.name} ({self.holiday_type})"
diff --git a/modules/elm/models/leaves.py b/modules/elm/models/leaves.py
new file mode 100644
index 00000000..3e5a353c
--- /dev/null
+++ b/modules/elm/models/leaves.py
@@ -0,0 +1,121 @@
+"""Leave Request and Workflow Lifecycle Models."""
+from decimal import Decimal
+
+from django.db import models
+
+from core.db.mixins import TimeStampedModel, UserScopedModel
+
+
+class LeaveRequest(TimeStampedModel, UserScopedModel):
+    """The central leave application record in ELM."""
+
+    CATEGORY_CHOICES = [
+        ("CL", "Casual Leave"),
+        ("RH", "Restricted Holiday"),
+        ("SCL", "Special Casual Leave"),
+        ("EL", "Earned Leave"),
+        ("VL", "Vacation Leave"),
+        ("COL", "Commuted Leave"),
+    ]
+
+    STATUS_CHOICES = [
+        ("draft", "Draft"),
+        ("awaiting_substitute", "Awaiting Substitute Response"),
+        ("substitute_declined", "Substitute Declined"),
+        ("awaiting_unit_head", "Awaiting Unit Head Review"),
+        ("awaiting_director_self_sanction", "Awaiting Director Self-Sanction"),
+        ("awaiting_establishment", "Awaiting Establishment Verification"),
+        ("awaiting_final_sanction", "Awaiting Final Sanction Decision"),
+        ("approved", "Approved"),
+        ("rejected", "Rejected"),
+        ("withdrawn", "Withdrawn"),
+        ("cancellation_pending_unit_head", "Cancellation Pending - Unit Head Review"),
+        ("cancellation_pending_establishment", "Cancellation Pending - Establishment"),
+        ("cancellation_pending_final", "Cancellation Pending - Final Decision"),
+        ("cancelled", "Cancelled"),
+        ("extension_pending_substitute", "Extension Pending - Substitute"),
+        ("extension_pending_unit_head", "Extension Pending - Unit Head"),
+        ("extension_pending_final", "Extension Pending - Final Decision"),
+        ("extended", "Extended"),
+        ("resumption_pending", "Resumption Review Pending"),
+        ("resumed", "Resumed"),
+    ]
+
+    HALF_DAY_CHOICES = [
+        ("first_half", "First Half"),
+        ("second_half", "Second Half"),
+    ]
+
+    category = models.CharField(max_length=8, choices=CATEGORY_CHOICES, db_index=True)
+    start_date = models.DateField(db_index=True)
+    end_date = models.DateField(db_index=True)
+    is_half_day = models.BooleanField(default=False)
+    half_day_period = models.CharField(max_length=16, choices=HALF_DAY_CHOICES, null=True, blank=True)
+    days_calculated = models.DecimalField(max_digits=5, decimal_places=2, default=Decimal("1.00"))
+    reason = models.TextField()
+    status = models.CharField(max_length=40, choices=STATUS_CHOICES, default="draft", db_index=True)
+
+    # Station Leave fields (BR-EL-013: coupled in same application)
+    leaving_station = models.BooleanField(default=False)
+    station_start_date = models.DateField(null=True, blank=True)
+    station_end_date = models.DateField(null=True, blank=True)
+    station_address = models.CharField(max_length=255, blank=True)
+    emergency_phone = models.CharField(max_length=32, blank=True)
+
+    # Substitute fields (BR-EL-014, BR-EL-015)
+    substitute_user_id = models.IntegerField(null=True, blank=True, db_index=True)
+    substitute_status = models.CharField(max_length=24, default="none")  # none, pending, accepted, declined
+    substitute_remarks = models.CharField(max_length=255, blank=True)
+
+    # Review & Sanction hierarchy fields (BR-EL-016 - BR-EL-020)
+    unit_head_user_id = models.IntegerField(null=True, blank=True, db_index=True)
+    unit_head_recommendation = models.CharField(max_length=24, default="pending")  # pending, recommended, not_recommended, approved, rejected
+    unit_head_remarks = models.TextField(blank=True)
+    establishment_user_id = models.IntegerField(null=True, blank=True)
+    sanctioning_authority_user_id = models.IntegerField(null=True, blank=True, db_index=True)
+    final_decision_remarks = models.TextField(blank=True)
+    sanctioned_at = models.DateTimeField(null=True, blank=True)
+
+    # Extension support (CW-EL-03, BR-EL-025)
+    is_extension = models.BooleanField(default=False)
+    original_leave_id = models.IntegerField(null=True, blank=True, db_index=True)
+
+    # Resumption support (CW-EL-04, BR-EL-027, BR-EL-028)
+    actual_resumption_date = models.DateField(null=True, blank=True)
+    resumption_remarks = models.TextField(blank=True)
+
+    # Offline-sanctioned leave support (BR-EL-029, EL-UC-016)
+    is_offline_sanctioned = models.BooleanField(default=False)
+    offline_sanction_reference = models.CharField(max_length=120, blank=True)
+
+    class Meta:
+        db_table = "elm_leave_request"
+        indexes = [
+            models.Index(fields=["user_id", "status"], name="elm_req_user_status_idx"),
+            models.Index(fields=["status", "category"], name="elm_req_status_cat_idx"),
+            models.Index(fields=["start_date", "end_date"], name="elm_req_dates_idx"),
+        ]
+
+    def __str__(self) -> str:
+        return f"Leave #{self.pk} (User {self.user_id}) - {self.category} [{self.status}]"
+
+
+class LeaveTransitionHistory(TimeStampedModel):
+    """Append-only audit trail of every status transition."""
+
+    leave_request = models.ForeignKey(
+        LeaveRequest,
+        on_delete=models.CASCADE,
+        related_name="transitions",
+    )
+    from_status = models.CharField(max_length=40)
+    to_status = models.CharField(max_length=40)
+    actor_user_id = models.IntegerField(db_index=True)
+    remarks = models.TextField(blank=True)
+
+    class Meta:
+        db_table = "elm_transition_history"
+        ordering = ["-created_at"]
+
+    def __str__(self) -> str:
+        return f"Req #{self.leave_request_id}: {self.from_status} -> {self.to_status} by User {self.actor_user_id}"
diff --git a/modules/elm/registry.py b/modules/elm/registry.py
new file mode 100644
index 00000000..ee29e1af
--- /dev/null
+++ b/modules/elm/registry.py
@@ -0,0 +1,144 @@
+"""What the server tells the shell about Employee Leave Management (ELM).
+
+Server-driven navigation and RBAC configuration for ELM module.
+"""
+
+MODULE = {
+    "code": "elm",
+    "label": "Leave Management",
+    "icon": "CalendarBlank",
+    "base_path": "/elm",
+    "nav_section": "HR & Admin",
+    "sort_order": 25,
+    "status": "active",
+}
+
+NAV_ITEMS = [
+    # -- Self-service leave actions for employees (faculty/staff) -----------
+    {
+        "code": "elm.apply",
+        "label": "Apply for Leave",
+        "icon": "PlusCircle",
+        "to": "/elm/apply",
+        "required_permission": "elm.leave.apply",
+        "sort_order": 10,
+    },
+    {
+        "code": "elm.mine",
+        "label": "My Leaves & Balances",
+        "icon": "ClockCounterClockwise",
+        "to": "/elm/mine",
+        "required_permission": "elm.leave.view_self",
+        "sort_order": 20,
+    },
+    {
+        "code": "elm.substitute",
+        "label": "Substitute Requests",
+        "icon": "Users",
+        "to": "/elm/substitute-requests",
+        "required_permission": "elm.leave.substitute",
+        "sort_order": 30,
+    },
+
+    # -- Reviewers & sanctioning authorities -------------------------------
+    {
+        "code": "elm.unit_head_reviews",
+        "label": "Unit Head Reviews",
+        "icon": "ClipboardText",
+        "to": "/elm/unit-head-reviews",
+        "required_permission": "elm.leave.review",
+        "sort_order": 40,
+    },
+    {
+        "code": "elm.establishment_routing",
+        "label": "Establishment Verification",
+        "icon": "ArrowsSplit",
+        "to": "/elm/establishment-routing",
+        "required_permission": "elm.leave.route",
+        "sort_order": 50,
+    },
+    {
+        "code": "elm.sanctions",
+        "label": "Sanctioning Decisions",
+        "icon": "CheckSquareOffset",
+        "to": "/elm/sanction-decisions",
+        "required_permission": "elm.leave.sanction",
+        "sort_order": 60,
+    },
+
+    # -- Administrative maintenance & calendars ---------------------------
+    {
+        "code": "elm.admin_calendars",
+        "label": "Holiday Calendars & Policies",
+        "icon": "GearSix",
+        "to": "/elm/admin",
+        "required_permission": "elm.leave.admin",
+        "sort_order": 70,
+    },
+]
+
+PERMISSIONS = [
+    ("elm.leave.apply", "Apply for leave and submit station details"),
+    ("elm.leave.view_self", "View own leave balances, applications, and history"),
+    ("elm.leave.withdraw", "Withdraw pending leave requests before final decision"),
+    ("elm.leave.cancel", "Request pre-start cancellation of approved leave"),
+    ("elm.leave.extend", "Request extension of ongoing EL, COL, or VL"),
+    ("elm.leave.resume", "Submit resumption of duty after leave"),
+    ("elm.leave.substitute", "Respond to substitute responsibility requests"),
+    ("elm.leave.review", "Review and decide/recommend leave as Unit Head"),
+    ("elm.leave.route", "Verify records and route leave in Establishment"),
+    ("elm.leave.sanction", "Sanction or reject leave as Competent Authority"),
+    ("elm.leave.admin", "Maintain leave quotas, holiday calendars, and offline records"),
+]
+
+SYSTEM_PERMISSIONS = [
+    "elm.leave.year_end_process",
+    "elm.leave.sla_escalate",
+]
+
+_EMPLOYEE_BASE = [
+    "elm.leave.apply",
+    "elm.leave.view_self",
+    "elm.leave.withdraw",
+    "elm.leave.cancel",
+    "elm.leave.extend",
+    "elm.leave.resume",
+    "elm.leave.substitute",
+]
+
+_UNIT_HEAD = [
+    *_EMPLOYEE_BASE,
+    "elm.leave.review",
+]
+
+_ESTABLISHMENT = [
+    *_EMPLOYEE_BASE,
+    "elm.leave.route",
+]
+
+_SANCTIONING_AUTHORITY = [
+    *_EMPLOYEE_BASE,
+    "elm.leave.sanction",
+]
+
+_LEAVE_ADMIN = [
+    *_EMPLOYEE_BASE,
+    "elm.leave.admin",
+    "elm.leave.review",
+    "elm.leave.route",
+    "elm.leave.sanction",
+]
+
+ROLE_GRANTS = {
+    "faculty": _EMPLOYEE_BASE,
+    "staff": _EMPLOYEE_BASE,
+    "hod": _UNIT_HEAD,
+    "unit_head": _UNIT_HEAD,
+    "establishment": _ESTABLISHMENT,
+    "dr_establishment": _ESTABLISHMENT,
+    "dean": _SANCTIONING_AUTHORITY,
+    "registrar": _SANCTIONING_AUTHORITY,
+    "director": _SANCTIONING_AUTHORITY,
+    "leave_admin": _LEAVE_ADMIN,
+    "admin": _LEAVE_ADMIN,
+}
diff --git a/modules/elm/selectors/__init__.py b/modules/elm/selectors/__init__.py
new file mode 100644
index 00000000..99f636d0
--- /dev/null
+++ b/modules/elm/selectors/__init__.py
@@ -0,0 +1 @@
+"""ELM query selectors package."""
diff --git a/modules/elm/selectors/leaves.py b/modules/elm/selectors/leaves.py
new file mode 100644
index 00000000..7183db44
--- /dev/null
+++ b/modules/elm/selectors/leaves.py
@@ -0,0 +1,62 @@
+"""Read selectors for ELM. Ownership filtering lives here."""
+from django.db.models import QuerySet
+
+from modules.elm.models.balances import LeaveBalance
+from modules.elm.models.leaves import LeaveRequest
+
+
+def get_user_leaves(user_id: int) -> QuerySet[LeaveRequest]:
+    """Retrieve all leave applications for the current user."""
+    return LeaveRequest.objects.filter(user_id=user_id).order_by("-created_at")
+
+
+def get_user_leave_detail(user_id: int, leave_id: int) -> LeaveRequest | None:
+    """Retrieve a specific leave request owned by user."""
+    return LeaveRequest.objects.filter(user_id=user_id, pk=leave_id).first()
+
+
+def get_user_balances(user_id: int, year: int) -> QuerySet[LeaveBalance]:
+    """Retrieve all leave balance quotas for a user in a specific year."""
+    return LeaveBalance.objects.filter(user_id=user_id, year=year)
+
+
+def get_substitute_pending_requests(substitute_user_id: int) -> QuerySet[LeaveRequest]:
+    """Retrieve all pending requests where user is nominated as substitute."""
+    return LeaveRequest.objects.filter(
+        substitute_user_id=substitute_user_id,
+        status="awaiting_substitute",
+    ).order_by("created_at")
+
+
+def get_unit_head_pending_requests(unit_head_user_id: int | None = None) -> QuerySet[LeaveRequest]:
+    """Retrieve requests awaiting Unit Head review."""
+    qs = LeaveRequest.objects.filter(status__in=[
+        "awaiting_unit_head",
+        "cancellation_pending_unit_head",
+        "extension_pending_unit_head",
+    ])
+    if unit_head_user_id:
+        qs = qs.filter(unit_head_user_id=unit_head_user_id)
+    return qs.order_by("created_at")
+
+
+def get_establishment_pending_requests() -> QuerySet[LeaveRequest]:
+    """Retrieve requests awaiting Establishment verification."""
+    return LeaveRequest.objects.filter(status__in=[
+        "awaiting_establishment",
+        "cancellation_pending_establishment",
+    ]).order_by("created_at")
+
+
+def get_sanctioning_authority_pending_requests(authority_user_id: int | None = None) -> QuerySet[LeaveRequest]:
+    """Retrieve requests awaiting final sanction."""
+    qs = LeaveRequest.objects.filter(status__in=[
+        "awaiting_final_sanction",
+        "awaiting_director_self_sanction",
+        "cancellation_pending_final",
+        "extension_pending_final",
+        "resumption_pending",
+    ])
+    if authority_user_id:
+        qs = qs.filter(sanctioning_authority_user_id=authority_user_id)
+    return qs.order_by("created_at")
diff --git a/modules/elm/services/__init__.py b/modules/elm/services/__init__.py
new file mode 100644
index 00000000..609852d4
--- /dev/null
+++ b/modules/elm/services/__init__.py
@@ -0,0 +1 @@
+"""ELM services package."""
diff --git a/modules/elm/services/applications.py b/modules/elm/services/applications.py
new file mode 100644
index 00000000..493d0798
--- /dev/null
+++ b/modules/elm/services/applications.py
@@ -0,0 +1,155 @@
+"""Leave Application submission and withdrawal services."""
+from datetime import date
+from decimal import Decimal
+
+from django.db import transaction
+
+from modules.elm.domain.calculations import calculate_leave_days, check_date_overlap
+from modules.elm.domain.state_machine import LeaveStateMachine
+from modules.elm.models.balances import LeaveBalance
+from modules.elm.models.holidays import HolidayCalendar
+from modules.elm.models.leaves import LeaveRequest, LeaveTransitionHistory
+
+
+@transaction.atomic
+def apply_for_leave(
+    user_id: int,
+    category: str,
+    start_date: date,
+    end_date: date,
+    reason: str,
+    is_half_day: bool = False,
+    half_day_period: str | None = None,
+    leaving_station: bool = False,
+    station_start_date: date | None = None,
+    station_end_date: date | None = None,
+    station_address: str = "",
+    emergency_phone: str = "",
+    substitute_user_id: int | None = None,
+    unit_head_user_id: int | None = None,
+    is_director: bool = False,
+) -> LeaveRequest:
+    """Submit a new leave application (CW-EL-01, EL-UC-001)."""
+    if start_date > end_date:
+        raise ValueError("Start date cannot be after end date.")
+
+    # 1. Check for overlapping pending or approved leave (BR-EL-012)
+    existing_leaves = LeaveRequest.objects.filter(
+        user_id=user_id,
+        status__in=[
+            "awaiting_substitute", "awaiting_unit_head", "awaiting_establishment",
+            "awaiting_final_sanction", "approved",
+        ],
+    )
+    for existing in existing_leaves:
+        if check_date_overlap(
+            start1=start_date, end1=end_date,
+            is_half1=is_half_day, period1=half_day_period,
+            start2=existing.start_date, end2=existing.end_date,
+            is_half2=existing.is_half_day, period2=existing.half_day_period,
+        ):
+            raise ValueError(f"Requested leave conflicts with existing {existing.category} leave (#{existing.id}).")
+
+    # 2. Check substitute eligibility (BR-EL-014)
+    if substitute_user_id:
+        if substitute_user_id == user_id:
+            raise ValueError("Applicant cannot nominate themselves as substitute.")
+        # Check if substitute has conflicting leave
+        sub_conflict = LeaveRequest.objects.filter(
+            user_id=substitute_user_id,
+            status="approved",
+            start_date__lte=end_date,
+            end_date__gte=start_date,
+        ).exists()
+        if sub_conflict:
+            raise ValueError("Nominated substitute has approved leave during this period.")
+
+    # 3. Calculate leave days
+    closed_holidays = set(HolidayCalendar.objects.filter(
+        holiday_type="closed",
+        year=start_date.year,
+        is_published=True,
+    ).values_list("date", flat=True))
+
+    days = calculate_leave_days(
+        category=category,
+        start_date=start_date,
+        end_date=end_date,
+        is_half_day=is_half_day,
+        half_day_period=half_day_period,
+        closed_holidays=closed_holidays,
+    )
+
+    # 4. Check available balance (BR-EL-002 - BR-EL-009)
+    balance_record = LeaveBalance.objects.filter(
+        user_id=user_id,
+        year=start_date.year,
+        category=category,
+    ).first()
+
+    available = balance_record.available_balance if balance_record else Decimal("0.00")
+    if Decimal(str(days)) > available:
+        raise ValueError(f"Insufficient {category} balance. Required: {days}, Available: {available}.")
+
+    # 5. Determine initial state via state machine
+    requires_sub = bool(substitute_user_id)
+    initial_status = LeaveStateMachine.submit_application(
+        requires_substitute=requires_sub,
+        is_director=is_director,
+    )
+
+    req = LeaveRequest.objects.create(
+        user_id=user_id,
+        category=category,
+        start_date=start_date,
+        end_date=end_date,
+        is_half_day=is_half_day,
+        half_day_period=half_day_period,
+        days_calculated=Decimal(str(days)),
+        reason=reason,
+        status=initial_status.value,
+        leaving_station=leaving_station,
+        station_start_date=station_start_date,
+        station_end_date=station_end_date,
+        station_address=station_address,
+        emergency_phone=emergency_phone,
+        substitute_user_id=substitute_user_id,
+        substitute_status="pending" if requires_sub else "none",
+        unit_head_user_id=unit_head_user_id,
+    )
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status="draft",
+        to_status=initial_status.value,
+        actor_user_id=user_id,
+        remarks="Application submitted.",
+    )
+
+    return req
+
+
+@transaction.atomic
+def withdraw_leave_application(user_id: int, leave_id: int) -> LeaveRequest:
+    """Immediately withdraw a pending leave request (CW-EL-01, EL-UC-007, BR-EL-022)."""
+    req = LeaveRequest.objects.select_for_update().filter(user_id=user_id, pk=leave_id).first()
+    if not req:
+        raise ValueError("Leave application not found.")
+
+    res = LeaveStateMachine.withdraw_pending(req.status)
+    if not res.success:
+        raise ValueError(res.message)
+
+    old_status = req.status
+    req.status = res.new_status.value
+    req.save(update_fields=["status", "updated_at"])
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=user_id,
+        remarks="Withdrawn by applicant.",
+    )
+
+    return req
diff --git a/modules/elm/services/workflows.py b/modules/elm/services/workflows.py
new file mode 100644
index 00000000..f9c07024
--- /dev/null
+++ b/modules/elm/services/workflows.py
@@ -0,0 +1,353 @@
+"""Workflow lifecycle actions: Substitute, Unit Head, Sanction, Cancellation, Extension, Resumption."""
+from datetime import date
+from decimal import Decimal
+
+from django.db import transaction
+from django.utils import timezone
+
+from modules.elm.domain.state_machine import LeaveStateMachine
+from modules.elm.models.balances import LeaveAccountTransaction, LeaveBalance
+from modules.elm.models.leaves import LeaveRequest, LeaveTransitionHistory
+
+
+@transaction.atomic
+def respond_substitute(substitute_user_id: int, leave_id: int, accepted: bool) -> LeaveRequest:
+    """Substitute accepts or declines responsibility coverage (CW-EL-01, EL-UC-002, BR-EL-015)."""
+    req = LeaveRequest.objects.select_for_update().filter(pk=leave_id, substitute_user_id=substitute_user_id).first()
+    if not req:
+        raise ValueError("Substitute request not found.")
+
+    res = LeaveStateMachine.process_substitute_response(
+        current_status=req.status,
+        accepted=accepted,
+        is_director=False,
+    )
+    if not res.success:
+        raise ValueError(res.message)
+
+    old_status = req.status
+    req.status = res.new_status.value
+    req.substitute_status = "accepted" if accepted else "declined"
+    req.save(update_fields=["status", "substitute_status", "updated_at"])
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=substitute_user_id,
+        remarks=f"Substitute {'accepted' if accepted else 'declined'} coverage.",
+    )
+    return req
+
+
+@transaction.atomic
+def review_unit_head(
+    unit_head_user_id: int,
+    leave_id: int,
+    decision: str,  # approve, reject, recommend, not_recommend
+    remarks: str = "",
+) -> LeaveRequest:
+    """Unit Head review (CW-EL-01, EL-UC-003, BR-EL-016, BR-EL-017)."""
+    req = LeaveRequest.objects.select_for_update().filter(pk=leave_id).first()
+    if not req:
+        raise ValueError("Leave request not found.")
+
+    res = LeaveStateMachine.unit_head_review(
+        category=req.category,
+        decision=decision.lower(),
+        has_establishment_step=True,
+    )
+    if not res.success:
+        raise ValueError(res.message)
+
+    old_status = req.status
+    req.status = res.new_status.value
+    req.unit_head_user_id = unit_head_user_id
+    req.unit_head_recommendation = decision.lower()
+    req.unit_head_remarks = remarks
+
+    # If CL/RH and approved, deduct balance immediately
+    if req.status == "approved":
+        req.sanctioned_at = timezone.now()
+        _deduct_leave_balance(req)
+
+    req.save()
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=unit_head_user_id,
+        remarks=f"Unit Head decided: {decision}. {remarks}".strip(),
+    )
+    return req
+
+
+@transaction.atomic
+def route_establishment(establishment_user_id: int, leave_id: int, remarks: str = "") -> LeaveRequest:
+    """Establishment verifies and routes higher-sanction request (CW-EL-01, EL-UC-004, BR-EL-018)."""
+    req = LeaveRequest.objects.select_for_update().filter(pk=leave_id).first()
+    if not req:
+        raise ValueError("Leave request not found.")
+
+    res = LeaveStateMachine.establishment_route()
+    old_status = req.status
+    req.status = res.new_status.value
+    req.establishment_user_id = establishment_user_id
+    req.save(update_fields=["status", "establishment_user_id", "updated_at"])
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=establishment_user_id,
+        remarks=f"Establishment routed: {remarks}".strip(),
+    )
+    return req
+
+
+@transaction.atomic
+def make_sanction_decision(
+    authority_user_id: int,
+    leave_id: int,
+    approve: bool,
+    remarks: str = "",
+) -> LeaveRequest:
+    """Final sanction decision (CW-EL-01, EL-UC-005, BR-EL-019)."""
+    req = LeaveRequest.objects.select_for_update().filter(pk=leave_id).first()
+    if not req:
+        raise ValueError("Leave request not found.")
+
+    res = LeaveStateMachine.final_sanction(approve)
+    old_status = req.status
+    req.status = res.new_status.value
+    req.sanctioning_authority_user_id = authority_user_id
+    req.final_decision_remarks = remarks
+
+    if approve:
+        req.sanctioned_at = timezone.now()
+        _deduct_leave_balance(req)
+
+    req.save()
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=authority_user_id,
+        remarks=f"Final decision: {'Approved' if approve else 'Rejected'}. {remarks}".strip(),
+    )
+    return req
+
+
+@transaction.atomic
+def request_cancellation(user_id: int, leave_id: int) -> LeaveRequest:
+    """Request pre-start cancellation of approved leave (CW-EL-02, EL-UC-008, BR-EL-023)."""
+    req = LeaveRequest.objects.select_for_update().filter(user_id=user_id, pk=leave_id).first()
+    if not req:
+        raise ValueError("Leave application not found.")
+
+    if date.today() >= req.start_date:
+        raise ValueError("Cancellation only allowed before leave start date. Use Resumption instead.")
+
+    res = LeaveStateMachine.request_cancellation(req.status)
+    if not res.success:
+        raise ValueError(res.message)
+
+    old_status = req.status
+    req.status = res.new_status.value
+    req.save(update_fields=["status", "updated_at"])
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=user_id,
+        remarks="Cancellation requested by employee.",
+    )
+    return req
+
+
+@transaction.atomic
+def review_cancellation(actor_user_id: int, leave_id: int, approve: bool) -> LeaveRequest:
+    """Review and decide on cancellation request. Restores balance on approval (CW-EL-02)."""
+    req = LeaveRequest.objects.select_for_update().filter(pk=leave_id).first()
+    if not req:
+        raise ValueError("Leave request not found.")
+
+    res = LeaveStateMachine.review_cancellation(
+        category=req.category,
+        approved=approve,
+        current_status=req.status,
+    )
+    if not res.success:
+        raise ValueError(res.message)
+
+    old_status = req.status
+    req.status = res.new_status.value
+
+    # On approved cancellation, restore deducted balance (BR-EL-023)
+    if req.status == "cancelled":
+        _refund_leave_balance(req, req.days_calculated, "Cancellation approved - balance restored")
+
+    req.save()
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=actor_user_id,
+        remarks=f"Cancellation {'Approved' if approve else 'Rejected'}.",
+    )
+    return req
+
+
+@transaction.atomic
+def submit_resumption(user_id: int, leave_id: int, actual_date: date, remarks: str = "") -> LeaveRequest:
+    """Submit resumption of duty after leave (CW-EL-04, EL-UC-010, BR-EL-027)."""
+    req = LeaveRequest.objects.select_for_update().filter(user_id=user_id, pk=leave_id, status="approved").first()
+    if not req:
+        raise ValueError("Approved leave request not found.")
+
+    req.actual_resumption_date = actual_date
+    req.resumption_remarks = remarks
+    req.status = "resumption_pending"
+    req.save(update_fields=["actual_resumption_date", "resumption_remarks", "status", "updated_at"])
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status="approved",
+        to_status="resumption_pending",
+        actor_user_id=user_id,
+        remarks=f"Resumed on {actual_date}. {remarks}".strip(),
+    )
+    return req
+
+
+@transaction.atomic
+def review_resumption(authority_user_id: int, leave_id: int) -> LeaveRequest:
+    """Review resumption and adjust balance for early or late return (CW-EL-04, BR-EL-028)."""
+    req = LeaveRequest.objects.select_for_update().filter(pk=leave_id, status="resumption_pending").first()
+    if not req:
+        raise ValueError("Resumption request not found.")
+
+    # Calculate difference
+    if req.actual_resumption_date and req.actual_resumption_date < req.end_date:
+        # Early return: refund excess days
+        excess = Decimal(str((req.end_date - req.actual_resumption_date).days))
+        _refund_leave_balance(req, excess, "Early resumption balance refund")
+    elif req.actual_resumption_date and req.actual_resumption_date > req.end_date:
+        # Late return: deduct extra days
+        extra = Decimal(str((req.actual_resumption_date - req.end_date).days))
+        _deduct_additional_balance(req, extra, "Late resumption extra deduction")
+
+    old_status = req.status
+    req.status = "resumed"
+    req.save(update_fields=["status", "updated_at"])
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status=old_status,
+        to_status=req.status,
+        actor_user_id=authority_user_id,
+        remarks="Resumption verified and leave record closed.",
+    )
+    return req
+
+
+@transaction.atomic
+def record_offline_leave(
+    admin_user_id: int,
+    target_user_id: int,
+    category: str,
+    start_date: date,
+    end_date: date,
+    days: Decimal,
+    reference_no: str,
+    reason: str,
+) -> LeaveRequest:
+    """Record already-sanctioned offline paper leave (BR-EL-029, EL-UC-016)."""
+    req = LeaveRequest.objects.create(
+        user_id=target_user_id,
+        category=category,
+        start_date=start_date,
+        end_date=end_date,
+        days_calculated=days,
+        reason=reason,
+        status="approved",
+        is_offline_sanctioned=True,
+        offline_sanction_reference=reference_no,
+        sanctioning_authority_user_id=admin_user_id,
+        sanctioned_at=timezone.now(),
+    )
+
+    _deduct_leave_balance(req)
+
+    LeaveTransitionHistory.objects.create(
+        leave_request=req,
+        from_status="draft",
+        to_status="approved",
+        actor_user_id=admin_user_id,
+        remarks=f"Offline sanctioned leave recorded. Ref: {reference_no}",
+    )
+    return req
+
+
+# -----------------------------------------------------------------------------
+# Internal Balance Adjustment Helpers
+# -----------------------------------------------------------------------------
+def _deduct_leave_balance(req: LeaveRequest) -> None:
+    bal = LeaveBalance.objects.select_for_update().filter(
+        user_id=req.user_id, year=req.start_date.year, category=req.category
+    ).first()
+    if bal:
+        bal.availed_balance += req.days_calculated
+        bal.save(update_fields=["availed_balance", "updated_at"])
+
+    LeaveAccountTransaction.objects.create(
+        user_id=req.user_id,
+        year=req.start_date.year,
+        category=req.category,
+        transaction_type="deduction",
+        days=req.days_calculated,
+        reference_leave_id=req.id,
+        description=f"Approved leave deduction for #{req.id}",
+    )
+
+
+def _refund_leave_balance(req: LeaveRequest, refund_days: Decimal, desc: str) -> None:
+    bal = LeaveBalance.objects.select_for_update().filter(
+        user_id=req.user_id, year=req.start_date.year, category=req.category
+    ).first()
+    if bal:
+        bal.availed_balance = max(Decimal("0.00"), bal.availed_balance - refund_days)
+        bal.save(update_fields=["availed_balance", "updated_at"])
+
+    LeaveAccountTransaction.objects.create(
+        user_id=req.user_id,
+        year=req.start_date.year,
+        category=req.category,
+        transaction_type="refund",
+        days=refund_days,
+        reference_leave_id=req.id,
+        description=desc,
+    )
+
+
+def _deduct_additional_balance(req: LeaveRequest, extra_days: Decimal, desc: str) -> None:
+    bal = LeaveBalance.objects.select_for_update().filter(
+        user_id=req.user_id, year=req.start_date.year, category=req.category
+    ).first()
+    if bal:
+        bal.availed_balance += extra_days
+        bal.save(update_fields=["availed_balance", "updated_at"])
+
+    LeaveAccountTransaction.objects.create(
+        user_id=req.user_id,
+        year=req.start_date.year,
+        category=req.category,
+        transaction_type="deduction",
+        days=extra_days,
+        reference_leave_id=req.id,
+        description=desc,
+    )
diff --git a/modules/elm/services/year_end.py b/modules/elm/services/year_end.py
new file mode 100644
index 00000000..f7efd1eb
--- /dev/null
+++ b/modules/elm/services/year_end.py
@@ -0,0 +1,101 @@
+"""Automated Year-End Leave Processing Service (EL-UC-020, EVT-01).
+
+Implements:
+- BR-EL-002: Unused Casual Leave lapses.
+- BR-EL-003: Unused Restricted Holiday lapses.
+- BR-EL-004: Unused Special Casual Leave lapses.
+- BR-EL-007: Faculty VL converts to EL at 2 VL : 1 EL.
+- BR-EL-008: Converted EL credited to employee's EL account and carries forward.
+- BR-EL-005: Staff EL carries forward.
+- BR-EL-009: Commuted Leave carries forward.
+"""
+from decimal import Decimal
+
+from django.db import transaction
+
+from modules.elm.domain.calculations import calculate_vl_to_el_conversion
+from modules.elm.models.balances import LeaveAccountTransaction, LeaveBalance
+
+
+@transaction.atomic
+def execute_year_end_processing(current_year: int) -> dict[str, int]:
+    """Execute annual boundary processing for all employees."""
+    next_year = current_year + 1
+    stats = {"lapsed": 0, "converted_vl": 0, "carried_forward": 0}
+
+    balances = LeaveBalance.objects.select_for_update().filter(year=current_year)
+
+    for bal in balances:
+        available = bal.available_balance
+
+        # 1. CL, RH, SCL lapse at year-end
+        if bal.category in ("CL", "RH", "SCL"):
+            if available > 0:
+                LeaveAccountTransaction.objects.create(
+                    user_id=bal.user_id,
+                    year=current_year,
+                    category=bal.category,
+                    transaction_type="lapse",
+                    days=available,
+                    description=f"{bal.category} year-end lapse for {current_year}",
+                )
+                stats["lapsed"] += 1
+
+        # 2. Faculty Vacation Leave (VL) converts to EL at 2:1 (BR-EL-007)
+        elif bal.category == "VL":
+            if available > 0:
+                el_converted = Decimal(str(calculate_vl_to_el_conversion(float(available))))
+
+                # Log VL lapse/conversion transaction
+                LeaveAccountTransaction.objects.create(
+                    user_id=bal.user_id,
+                    year=current_year,
+                    category="VL",
+                    transaction_type="conversion",
+                    days=available,
+                    description=f"VL converted to {el_converted} EL at 2:1",
+                )
+
+                # Credit converted EL in next year
+                el_next, _ = LeaveBalance.objects.get_or_create(
+                    user_id=bal.user_id,
+                    year=next_year,
+                    category="EL",
+                    defaults={"credited_balance": Decimal("0.00"), "carried_forward": Decimal("0.00")},
+                )
+                el_next.carried_forward += el_converted
+                el_next.save(update_fields=["carried_forward", "updated_at"])
+
+                LeaveAccountTransaction.objects.create(
+                    user_id=bal.user_id,
+                    year=next_year,
+                    category="EL",
+                    transaction_type="credit",
+                    days=el_converted,
+                    description=f"Converted from {current_year} VL",
+                )
+                stats["converted_vl"] += 1
+
+        # 3. EL and COL carry forward directly
+        elif bal.category in ("EL", "COL"):
+            if available > 0:
+                next_bal, _ = LeaveBalance.objects.get_or_create(
+                    user_id=bal.user_id,
+                    year=next_year,
+                    category=bal.category,
+                    defaults={"credited_balance": Decimal("0.00"), "carried_forward": Decimal("0.00")},
+                )
+                next_bal.carried_forward += available
+                next_bal.save(update_fields=["carried_forward", "updated_at"])
+
+                LeaveAccountTransaction.objects.create(
+                    user_id=bal.user_id,
+                    year=next_year,
+                    category=bal.category,
+                    transaction_type="carry_forward",
+                    days=available,
+                    description=f"{bal.category} carry forward from {current_year}",
+                )
+                stats["carried_forward"] += 1
+
+    return stats
diff --git a/modules/elm/tests/__init__.py b/modules/elm/tests/__init__.py
new file mode 100644
index 00000000..33e185ee
--- /dev/null
+++ b/modules/elm/tests/__init__.py
@@ -0,0 +1 @@
+"""ELM test suite package."""
diff --git a/modules/elm/tests/test_domain.py b/modules/elm/tests/test_domain.py
new file mode 100644
index 00000000..b6d9c928
--- /dev/null
+++ b/modules/elm/tests/test_domain.py
@@ -0,0 +1,111 @@
+"""Pure Python Domain Unit Tests for ELM.
+
+Runs in milliseconds without a database or network connection.
+Verifies all core calculation rules and workflow state machines.
+"""
+from datetime import date
+
+from modules.elm.domain.calculations import (
+    calculate_leave_days,
+    calculate_vl_to_el_conversion,
+    check_date_overlap,
+)
+from modules.elm.domain.entities import LeaveCategory, LeaveStatus
+from modules.elm.domain.state_machine import LeaveStateMachine
+
+
+def test_half_day_cl_calculation():
+    """BR-EL-010: Half-day CL consumes exactly 0.5 days."""
+    days = calculate_leave_days(
+        category=LeaveCategory.CL,
+        start_date=date(2026, 10, 15),
+        end_date=date(2026, 10, 15),
+        is_half_day=True,
+        half_day_period="first_half",
+    )
+    assert days == 0.5
+
+
+def test_continuous_counting_for_earned_leave():
+    """BR-EL-011: EL includes intervening weekends and holidays continuously."""
+    # From Friday to Monday = 4 calendar days (Friday, Saturday, Sunday, Monday)
+    start = date(2026, 10, 16)  # Friday
+    end = date(2026, 10, 19)    # Monday
+    days = calculate_leave_days(category=LeaveCategory.EL, start_date=start, end_date=end)
+    assert days == 4.0
+
+
+def test_working_days_counting_for_casual_leave():
+    """BR-EL-011: CL excludes intervening weekends."""
+    start = date(2026, 10, 16)  # Friday
+    end = date(2026, 10, 19)    # Monday
+    days = calculate_leave_days(category=LeaveCategory.CL, start_date=start, end_date=end)
+    # Friday and Monday are working days; Saturday and Sunday are excluded -> 2 days
+    assert days == 2.0
+
+
+def test_faculty_vl_to_el_conversion():
+    """BR-EL-007: All unused Faculty VL converts to EL at 2:1."""
+    assert calculate_vl_to_el_conversion(30.0) == 15.0
+    assert calculate_vl_to_el_conversion(15.0) == 7.5
+    assert calculate_vl_to_el_conversion(0.0) == 0.0
+
+
+def test_half_day_cl_non_overlap():
+    """BR-EL-012: First-half and second-half CL on same date do not overlap."""
+    d = date(2026, 10, 20)
+    overlap = check_date_overlap(
+        start1=d, end1=d, is_half1=True, period1="first_half",
+        start2=d, end2=d, is_half2=True, period2="second_half",
+    )
+    assert overlap is False
+
+
+def test_date_overlap_detection():
+    """Regular dates overlap correctly."""
+    overlap = check_date_overlap(
+        start1=date(2026, 10, 10), end1=date(2026, 10, 15), is_half1=False, period1=None,
+        start2=date(2026, 10, 14), end2=date(2026, 10, 20), is_half2=False, period2=None,
+    )
+    assert overlap is True
+
+
+def test_state_machine_cl_progression():
+    """CW-EL-01: CL approval directly at Unit Head."""
+    # Submission without substitute
+    st = LeaveStateMachine.submit_application(requires_substitute=False, is_director=False)
+    assert st == LeaveStatus.AWAITING_UNIT_HEAD
+
+    # Unit Head Approves CL
+    res = LeaveStateMachine.unit_head_review("CL", "approve")
+    assert res.success is True
+    assert res.new_status == LeaveStatus.APPROVED
+
+
+def test_state_machine_higher_sanction_progression():
+    """CW-EL-01: Higher sanction leave progression."""
+    # Unit Head recommends
+    res = LeaveStateMachine.unit_head_review("EL", "recommend", has_establishment_step=True)
+    assert res.success is True
+    assert res.new_status == LeaveStatus.AWAITING_ESTABLISHMENT
+
+    # Establishment routes
+    res = LeaveStateMachine.establishment_route()
+    assert res.success is True
+    assert res.new_status == LeaveStatus.AWAITING_FINAL_SANCTION
+
+    # Final sanction approves
+    res = LeaveStateMachine.final_sanction(approved=True)
+    assert res.success is True
+    assert res.new_status == LeaveStatus.APPROVED
+
+
+def test_immediate_withdrawal():
+    """CW-EL-01, BR-EL-022: Immediate withdrawal on pending requests."""
+    res = LeaveStateMachine.withdraw_pending(LeaveStatus.AWAITING_UNIT_HEAD)
+    assert res.success is True
+    assert res.new_status == LeaveStatus.WITHDRAWN
+
+    # Cannot withdraw approved leave
+    res_invalid = LeaveStateMachine.withdraw_pending(LeaveStatus.APPROVED)
+    assert res_invalid.success is False