diff --git a/client/src/app/registry.ts b/client/src/app/registry.ts
index e76d32bf..1fcdac8f 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"),
   },
+  leave_management: {
+    code: "leave_management",
+    basePath: "/leave",
+    load: () => import("../modules/leave/routes"),
+  },
 };
diff --git a/client/src/modules/leave/api.ts b/client/src/modules/leave/api.ts
new file mode 100644
index 00000000..d7c0e78f
--- /dev/null
+++ b/client/src/modules/leave/api.ts
@@ -0,0 +1,83 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { http } from "../../lib/http";
+
+type Page<T> = { results: T[] };
+export type LeaveCategory = { code: string; label: string; description: string };
+export type LeaveRequest = {
+  id: number; category_code: string; request_type: string; status: string;
+  start_date: string; end_date: string; duration_days: string; reason: string;
+};
+export type LeaveBalance = {
+  id: number; category_code: string; year: number; entitlement: string;
+  carried_over: string; available: string;
+};
+
+const key = ["leave"] as const;
+export function useMyLeave() {
+  const categories = useQuery({ queryKey: [...key, "categories"], queryFn: async () =>
+    (await http.get<Page<LeaveCategory>>("/leave/categories")).data });
+  const requests = useQuery({ queryKey: [...key, "requests"], queryFn: async () =>
+    (await http.get<Page<LeaveRequest>>("/leave/requests")).data });
+  const balances = useQuery({ queryKey: [...key, "balances"], queryFn: async () =>
+    (await http.get<Page<LeaveBalance>>("/leave/balances")).data });
+  return { categories, requests, balances };
+}
+
+export function useEmployeeSearch(query: string) {
+  return useQuery({ queryKey: [...key, "employees", query], queryFn: async () =>
+    (await http.get<{ user_id: number; label: string; kind: string }[]>("/leave/employees", { params: { q: query } })).data,
+    enabled: query.trim().length >= 2,
+    staleTime: 30_000,
+  });
+}
+
+export function useApplyForLeave() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async (body: Record<string, unknown>) => {
+      const draft = (await http.post<LeaveRequest>("/leave/requests", body)).data;
+      return (await http.post<LeaveRequest>(`/leave/requests/${draft.id}/submit`, {})).data;
+    },
+    onSuccess: () => client.invalidateQueries({ queryKey: key }),
+  });
+}
+
+export function useWithdrawLeave() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: async (id: number) =>
+      (await http.post<LeaveRequest>(`/leave/requests/${id}/withdraw`, {})).data,
+    onSuccess: () => client.invalidateQueries({ queryKey: key }),
+  });
+}
+
+export type LeaveTask = { id: number; request_id: number; employee_id: number; category_code: string; sequence: number; role: string; state: string };
+export function useTasks() {
+  const client = useQueryClient();
+  const query = useQuery({ queryKey: [...key, "tasks"], queryFn: async () =>
+    (await http.get<Page<LeaveTask>>("/leave/tasks")).data });
+  const decide = useMutation({
+    mutationFn: async ({ id, decision }: { id: number; decision: string }) =>
+      (await http.post(`/leave/tasks/${id}/decision`, { decision })).data,
+    onSuccess: () => client.invalidateQueries({ queryKey: key }),
+  });
+  return { ...query, decide };
+}
+
+export function useSubstitutions() {
+  const client = useQueryClient();
+  const query = useQuery({ queryKey: [...key, "substitutions"], queryFn: async () =>
+    (await http.get<Page<LeaveRequest>>("/leave/substitutions")).data });
+  const respond = useMutation({
+    mutationFn: async ({ id, decision }: { id: number; decision: "accept" | "decline" }) =>
+      (await http.post<LeaveRequest>(`/leave/requests/${id}/substitute-response`, { decision })).data,
+    onSuccess: () => client.invalidateQueries({ queryKey: key }),
+  });
+  return { ...query, respond };
+}
+
+export type LeaveCalendar = { id: number; year: number; revision: number; holidays: { date: string; description?: string; type?: string; restricted_holiday?: boolean }[] };
+export function useLeaveCalendars() {
+  return useQuery({ queryKey: [...key, "calendars"], queryFn: async () =>
+    (await http.get<Page<LeaveCalendar>>("/leave/calendars")).data });
+}
diff --git a/client/src/modules/leave/pages/CalendarPage.tsx b/client/src/modules/leave/pages/CalendarPage.tsx
new file mode 100644
index 00000000..574a2008
--- /dev/null
+++ b/client/src/modules/leave/pages/CalendarPage.tsx
@@ -0,0 +1,26 @@
+import { Alert, Card, Container, Stack, Table, Text } from "@mantine/core";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useLeaveCalendars } from "../api";
+
+export default function CalendarPage() {
+  const calendars = useLeaveCalendars();
+  if (calendars.error) return <Container size="md"><ErrorState error={calendars.error} /></Container>;
+  const published = calendars.data?.results ?? [];
+  return <Container size="md">
+    <PageHeader title="Holiday and RH calendar" subtitle="Dates from the currently published institute calendar." />
+    <Stack>
+      {published.length === 0 && <Alert color="gray">No published holiday calendar is available.</Alert>}
+      {published.map((calendar) => <Card key={calendar.id} withBorder>
+        <Text fw={600} mb="sm">{calendar.year} · revision {calendar.revision}</Text>
+        {calendar.holidays.length === 0 ? <Text size="sm" c="dimmed">No holiday dates listed.</Text> :
+          <Table striped><Table.Thead><Table.Tr><Table.Th>Date</Table.Th><Table.Th>Description</Table.Th><Table.Th>Type</Table.Th></Table.Tr></Table.Thead>
+            <Table.Tbody>{calendar.holidays.map((holiday, index) => <Table.Tr key={`${holiday.date}-${index}`}>
+              <Table.Td>{holiday.date}</Table.Td><Table.Td>{holiday.description ?? "—"}</Table.Td>
+              <Table.Td>{holiday.restricted_holiday || holiday.type === "RH" ? "Restricted holiday" : holiday.type ?? "Holiday"}</Table.Td>
+            </Table.Tr>)}</Table.Tbody>
+          </Table>}
+      </Card>)}
+    </Stack>
+  </Container>;
+}
diff --git a/client/src/modules/leave/pages/MyLeavePage.tsx b/client/src/modules/leave/pages/MyLeavePage.tsx
new file mode 100644
index 00000000..e787a9a9
--- /dev/null
+++ b/client/src/modules/leave/pages/MyLeavePage.tsx
@@ -0,0 +1,91 @@
+import { useState } from "react";
+import { Alert, Button, Card, Checkbox, Container, Grid, Group, Select, Stack, Table, Text, TextInput, Textarea } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useApplyForLeave, useEmployeeSearch, useMyLeave, useWithdrawLeave } from "../api";
+
+export default function MyLeavePage() {
+  const { categories, requests, balances } = useMyLeave();
+  const apply = useApplyForLeave();
+  const withdraw = useWithdrawLeave();
+  const [category, setCategory] = useState<string | null>(null);
+  const [start, setStart] = useState("");
+  const [end, setEnd] = useState("");
+  const [reason, setReason] = useState("");
+  const [portion, setPortion] = useState("full");
+  const [stationLeave, setStationLeave] = useState(false);
+  const [destination, setDestination] = useState("");
+  const [departure, setDeparture] = useState("");
+  const [returnTime, setReturnTime] = useState("");
+  const [substituteSearch, setSubstituteSearch] = useState("");
+  const [substituteUserId, setSubstituteUserId] = useState<string | null>(null);
+  const employees = useEmployeeSearch(substituteSearch);
+  if (requests.error) return <Container size="lg"><ErrorState error={requests.error} /></Container>;
+
+  function submit() {
+    if (!category || !start || !end || !reason.trim()) return;
+    apply.mutate({ category_code: category, start_date: start, end_date: end,
+      reason, cl_portion: category === "CL" ? portion : "full", station_leave: stationLeave,
+      station_destination: destination,
+      station_departure_at: departure ? new Date(departure).toISOString() : null,
+      station_return_at: returnTime ? new Date(returnTime).toISOString() : null,
+      substitute_user_id: substituteUserId ? Number(substituteUserId) : null }, {
+      onSuccess: () => { setReason(""); setStationLeave(false); setDestination(""); setDeparture(""); setReturnTime(""); setSubstituteUserId(null); notifications.show({ color: "green", title: "Leave request submitted", message: "You can follow its progress in your request history." }); },
+      onError: (error) => notifications.show({ color: "red", title: "Could not submit request", message: errorMessage(error) }),
+    });
+  }
+
+  return <Container size="lg">
+    <PageHeader title="My Leave" subtitle="Apply for leave and review your balances and requests." />
+    <Grid gutter="md" mb="lg">
+      {(balances.data?.results ?? []).map((balance) => <Grid.Col key={balance.id} span={{ base: 12, sm: 6, md: 4 }}>
+        <Card withBorder h="100"><Text fw={600}>{balance.category_code} · {balance.year}</Text>
+          <Text size="sm" c="dimmed">Available</Text><Text size="xl" fw={700}>{balance.available} days</Text>
+          <Text size="xs" c="dimmed">Entitlement {balance.entitlement}; carried forward {balance.carried_over}</Text>
+        </Card>
+      </Grid.Col>)}
+    </Grid>
+    <Card withBorder mb="lg">
+      <Text fw={600} mb="md">New leave application</Text>
+      <Stack gap="sm">
+        <Select label="Leave category" placeholder="Select a category" value={category}
+          onChange={setCategory} data={(categories.data?.results ?? []).map((item) => ({ value: item.code, label: `${item.code} · ${item.label}` }))} />
+        <Group grow>
+          <TextInput type="date" label="From" value={start} onChange={(e) => setStart(e.currentTarget.value)} />
+          <TextInput type="date" label="Through" value={end} onChange={(e) => setEnd(e.currentTarget.value)} />
+        </Group>
+        {category === "CL" && <Select label="CL portion" value={portion} onChange={(v) => setPortion(v ?? "full")}
+          data={[{ value: "full", label: "Full day" }, { value: "first_half", label: "First half" }, { value: "second_half", label: "Second half" }]} />}
+        {(category === "CL" || category === "RH") && <Checkbox label="I will be outside Jabalpur (Station Leave)" checked={stationLeave} onChange={(e) => setStationLeave(e.currentTarget.checked)} />}
+        {stationLeave && <>
+          <TextInput label="Destination" value={destination} onChange={(e) => setDestination(e.currentTarget.value)} />
+          <Group grow><TextInput type="datetime-local" label="Departure" value={departure} onChange={(e) => setDeparture(e.currentTarget.value)} />
+            <TextInput type="datetime-local" label="Return" value={returnTime} onChange={(e) => setReturnTime(e.currentTarget.value)} /></Group>
+        </>}
+        <Select label="Substitute (when responsibility coverage is required)" placeholder="Search employees"
+          searchable clearable searchValue={substituteSearch} onSearchChange={setSubstituteSearch}
+          value={substituteUserId} onChange={setSubstituteUserId} nothingFoundMessage={substituteSearch.length < 2 ? "Type at least two characters" : "No eligible employee found"}
+          data={(employees.data ?? []).map((person) => ({ value: String(person.user_id), label: `${person.label} · ${person.kind}` }))} />
+        <Textarea label="Purpose / reason" value={reason} onChange={(e) => setReason(e.currentTarget.value)} minRows={2} />
+        <Button onClick={submit} loading={apply.isPending} disabled={!category || !start || !end || !reason.trim() || (stationLeave && (!destination || !departure || !returnTime))}>Submit application</Button>
+      </Stack>
+    </Card>
+    <Card withBorder>
+      <Text fw={600} mb="sm">Request history</Text>
+      {(requests.data?.results?.length ?? 0) === 0 ? <Alert color="gray">No leave applications yet.</Alert> :
+        <Table.ScrollContainer minWidth={640}><Table striped highlightOnHover>
+          <Table.Thead><Table.Tr><Table.Th>Category</Table.Th><Table.Th>Period</Table.Th><Table.Th>Days</Table.Th><Table.Th>Status</Table.Th><Table.Th /></Table.Tr></Table.Thead>
+          <Table.Tbody>{requests.data?.results.map((item) => <Table.Tr key={item.id}>
+            <Table.Td>{item.category_code}</Table.Td><Table.Td>{item.start_date} – {item.end_date}</Table.Td>
+            <Table.Td>{item.duration_days}</Table.Td><Table.Td>{item.status.replaceAll("_", " ")}</Table.Td>
+            <Table.Td>{["awaiting_substitute", "applicant_action", "pending_unit_head", "pending_establishment", "pending_authority"].includes(item.status) &&
+              <Button size="xs" variant="light" color="red" loading={withdraw.isPending} onClick={() => withdraw.mutate(item.id, {
+                onError: (error) => notifications.show({ color: "red", title: "Could not withdraw request", message: errorMessage(error) }),
+              })}>Withdraw</Button>}</Table.Td>
+          </Table.Tr>)}</Table.Tbody>
+        </Table></Table.ScrollContainer>}
+    </Card>
+  </Container>;
+}
diff --git a/client/src/modules/leave/pages/SubstitutionsPage.tsx b/client/src/modules/leave/pages/SubstitutionsPage.tsx
new file mode 100644
index 00000000..2d3ed44e
--- /dev/null
+++ b/client/src/modules/leave/pages/SubstitutionsPage.tsx
@@ -0,0 +1,27 @@
+import { Alert, Button, Card, Container, Group, Stack, Text } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useSubstitutions } from "../api";
+
+export default function SubstitutionsPage() {
+  const inbox = useSubstitutions();
+  if (inbox.error) return <Container size="md"><ErrorState error={inbox.error} /></Container>;
+  return <Container size="md">
+    <PageHeader title="Substitute requests" subtitle="Accept or decline responsibility coverage assigned to you." />
+    <Stack>
+      {(inbox.data?.results ?? []).length === 0 && <Alert color="gray">There are no pending substitute requests.</Alert>}
+      {(inbox.data?.results ?? []).map((request) => <Card key={request.id} withBorder>
+        <Group justify="space-between">
+          <div><Text fw={600}>{request.category_code} · {request.start_date} to {request.end_date}</Text>
+            <Text size="sm" c="dimmed">Applicant #{request.employee_id} · {request.reason}</Text></div>
+          <Group>
+            <Button size="xs" color="green" onClick={() => inbox.respond.mutate({ id: request.id, decision: "accept" }, { onError: (e) => notifications.show({ color: "red", title: "Could not accept request", message: errorMessage(e) }) })}>Accept</Button>
+            <Button size="xs" color="red" variant="light" onClick={() => inbox.respond.mutate({ id: request.id, decision: "decline" }, { onError: (e) => notifications.show({ color: "red", title: "Could not decline request", message: errorMessage(e) }) })}>Decline</Button>
+          </Group>
+        </Group>
+      </Card>)}
+    </Stack>
+  </Container>;
+}
diff --git a/client/src/modules/leave/pages/TasksPage.tsx b/client/src/modules/leave/pages/TasksPage.tsx
new file mode 100644
index 00000000..c0476e86
--- /dev/null
+++ b/client/src/modules/leave/pages/TasksPage.tsx
@@ -0,0 +1,30 @@
+import { Alert, Button, Card, Container, Group, Stack, Text } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useTasks } from "../api";
+
+export default function TasksPage() {
+  const tasks = useTasks();
+  if (tasks.error) return <Container size="md"><ErrorState error={tasks.error} /></Container>;
+  return <Container size="md">
+    <PageHeader title="Leave tasks" subtitle="Review and route leave applications assigned to your role." />
+    <Stack>
+      {(tasks.data?.results ?? []).length === 0 && <Alert color="gray">There are no pending tasks assigned to you.</Alert>}
+      {(tasks.data?.results ?? []).map((task) => <Card withBorder key={task.id}>
+        <Group justify="space-between" align="flex-start"><div>
+        <Text fw={600}>Request #{task.request_id} · {task.category_code}</Text>
+          <Text size="sm" c="dimmed">{task.role.replaceAll("_", " ")} · step {task.sequence}</Text>
+        </div>
+        <Group>{task.role === "unit_head" && !["CL", "RH"].includes(task.category_code) ? <>
+          <Button size="xs" variant="light" onClick={() => tasks.decide.mutate({ id: task.id, decision: "recommended" }, { onError: (e) => notifications.show({ color: "red", title: "Could not record review", message: errorMessage(e) }) })}>Recommend</Button>
+          <Button size="xs" color="red" variant="light" onClick={() => tasks.decide.mutate({ id: task.id, decision: "not_recommended" }, { onError: (e) => notifications.show({ color: "red", title: "Could not record review", message: errorMessage(e) }) })}>Not recommended</Button>
+        </> : <>
+          <Button size="xs" color="green" onClick={() => tasks.decide.mutate({ id: task.id, decision: task.role === "establishment" ? "forwarded" : "approved" }, { onError: (e) => notifications.show({ color: "red", title: "Could not decide request", message: errorMessage(e) }) })}>{task.role === "establishment" ? "Forward" : "Approve"}</Button>
+          {task.role !== "establishment" && <Button size="xs" color="red" variant="light" onClick={() => tasks.decide.mutate({ id: task.id, decision: "rejected" }, { onError: (e) => notifications.show({ color: "red", title: "Could not decide request", message: errorMessage(e) }) })}>Reject</Button>}
+        </>}</Group></Group>
+      </Card>)}
+    </Stack>
+  </Container>;
+}
diff --git a/client/src/modules/leave/routes.tsx b/client/src/modules/leave/routes.tsx
new file mode 100644
index 00000000..f80ff217
--- /dev/null
+++ b/client/src/modules/leave/routes.tsx
@@ -0,0 +1,15 @@
+import { lazy } from "react";
+import type { RouteObject } from "react-router-dom";
+
+const MyLeavePage = lazy(() => import("./pages/MyLeavePage"));
+const TasksPage = lazy(() => import("./pages/TasksPage"));
+const SubstitutionsPage = lazy(() => import("./pages/SubstitutionsPage"));
+const CalendarPage = lazy(() => import("./pages/CalendarPage"));
+
+export const routes: RouteObject[] = [
+  { index: true, element: <MyLeavePage /> },
+  { path: "tasks", element: <TasksPage /> },
+  { path: "substitutions", element: <SubstitutionsPage /> },
+  { path: "balances", element: <MyLeavePage /> },
+  { path: "calendar", element: <CalendarPage /> },
+];
diff --git a/config/celery.py b/config/celery.py
index ad15f06b..61138bab 100644
--- a/config/celery.py
+++ b/config/celery.py
@@ -8,6 +8,8 @@
 from modules.placement.schedule import (
     TASK_ROUTES as PLACEMENT_ROUTES,
 )
+from modules.leave.schedule import BEAT_SCHEDULE as LEAVE_SCHEDULE
+from modules.leave.schedule import TASK_ROUTES as LEAVE_ROUTES
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings.dev")
 app = Celery("fusion_integrated")
@@ -15,5 +17,5 @@
 app.autodiscover_tasks()
 
 # Each module owns its timers; this only merges them, so modules stay removable.
-app.conf.beat_schedule = {**PLACEMENT_SCHEDULE}
-app.conf.task_routes = {**PLACEMENT_ROUTES}
+app.conf.beat_schedule = {**PLACEMENT_SCHEDULE, **LEAVE_SCHEDULE}
+app.conf.task_routes = {**PLACEMENT_ROUTES, **LEAVE_ROUTES}
diff --git a/config/settings/base.py b/config/settings/base.py
index 0dc7ada1..8cc02000 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.leave.apps.LeaveConfig",
 ]
 
 INSTALLED_APPS = (DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS
diff --git a/config/urls.py b/config/urls.py
index 33f7835b..91a4dc53 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/leave/", include("modules.leave.api.urls")),
     path("api/schema/", SpectacularAPIView.as_view(), name="schema"),
     path("api/docs/", SpectacularSwaggerView.as_view(url_name="schema"), name="docs"),
 ]
diff --git a/docs/00-overview/current-state-assessment.md b/docs/00-overview/current-state-assessment.md
index c74a8260..5f3abe21 100644
--- a/docs/00-overview/current-state-assessment.md
+++ b/docs/00-overview/current-state-assessment.md
@@ -71,6 +71,9 @@ WebOPAC with BeautifulSoup) · `iwdModuleV2` (22) · `estate_module` (5) · `sch
 `research_procedures` (7) · `filetracking` (2) · `notifications_extension` (0) · `department` (3) ·
 `counselling_cell` (9) · `recruitment` (24, near-empty views) · `feeds` (11) · `otheracademic` (7).
 
+This describes the legacy estate. The new ELM module is a fresh design against the synchronized
+ELM requirements bundle; it does not port the deprecated `leave` or `establishment` models.
+
 **14 of these have no DRF `api/` layer at all** and are still pure Django templates:
 `establishment`, `estate_module`, `finance_accounts`, `income_expenditure`, `hostel_management`,
 `iwdModuleV2`, `library`, `office_module`, `otheracademic`, `recruitment`, `scholarships`,
diff --git a/docs/00-overview/vision-and-scope.md b/docs/00-overview/vision-and-scope.md
index a2cdaf00..5596846f 100644
--- a/docs/00-overview/vision-and-scope.md
+++ b/docs/00-overview/vision-and-scope.md
@@ -65,6 +65,14 @@ Chosen deliberately as the first vertical slice: it is student-facing, it has a
 (postings → eligibility → applications → rounds → offers), it forces the academic-integration
 problem to be solved properly, and it is small enough to finish.
 
+### 5. Employee Leave Management
+
+ELM is a fresh domain module governed by the synchronized specifications in the repository's
+`ELM_Specifications_Bundle_v1.4_FINAL`. The legacy `leave` app is reference material only: its
+models and workflows are not copied. The new module owns leave requests, workflow tasks, calendars,
+and an append-only leave-account ledger; employee identity and employment facts remain projections
+from the platform's identity and HR contracts. See [ELM reference](../09-leave/ELM_REFERENCE.md).
+
 ## Non-goals
 
 These are as binding as the goals. A request to do any of them goes through a design document first,
@@ -73,7 +81,7 @@ and probably gets declined.
 | # | Non-goal | Why |
 |---|---|---|
 | **NG1** | **No multi-tenancy.** No `tenant_id`, no per-tenant schemas, no subdomain routing. | One institute. Tenancy would tax every table, every queryset and every migration for a second institute that does not exist. Revisit only if one actually appears. → [ADR-0011](../01-architecture/adr/0011-no-multi-tenancy.md) |
-| **NG2** | **No port of the 26 deprecated non-academic apps.** | They are deprecated for good reason. As one concrete example: the old placement module filters students on `Student.cpi`, a column that is permanently `0.0` because nothing has ever written a computed value to it. Porting that code would port its bugs. We design fresh. |
+| **NG2** | **No port of the 26 deprecated non-academic apps.** | Legacy apps remain unported. New modules, including ELM, are fresh implementations based on their current authoritative requirements; their legacy code is not a design contract. |
 | **NG3** | **No rewrite of the academic monolith in this programme.** | The five live academic apps stay exactly where they are. We add token validation and a one-way role projection; we change nothing else about how they work. Absorption is a later, separately-scoped programme. |
 | **NG4** | **No microservices.** Two new deployables, not twelve. | At this scale microservices buy distributed transactions, eventual-consistency bugs and an operations burden, and buy nothing back. Boundaries are enforced in-process so extraction stays cheap if it is ever justified. → [ADR-0001](../01-architecture/adr/0001-modular-monolith-over-microservices.md) |
 | **NG5** | **Placement does not compute CPI.** Ever. | The ERP's `calculate_cpi_for_student` has subtle, load-bearing semantics (grade `S` earns credit but is excluded from the average; `X` and `CD` are excluded entirely; **`F` earns 2.0 points and its credit**; dedup by course code; swayam replacement chains). Reimplementing it would produce a second, disagreeing CPI. We snapshot the ERP's own output. → [academic-snapshot-integration.md](../04-placement/academic-snapshot-integration.md) |
diff --git a/docs/02-iam/permission-catalog.generated.md b/docs/02-iam/permission-catalog.generated.md
index 6d748531..728b0d77 100644
--- a/docs/02-iam/permission-catalog.generated.md
+++ b/docs/02-iam/permission-catalog.generated.md
@@ -13,6 +13,28 @@ For the intended taxonomy of modules not yet built, see
 |---|---|---|
 | `directory.user.search` | Search the institute directory | `Dean Academic`, `acadadmin`, `placement_chairman`, `placement_coordinator`, `placement_officer` |
 
+## `leave_management`
+
+| Code | What it allows | Held by |
+|---|---|---|
+| `leave_management.request.view_self` | View own leave requests | `Faculty`, `Staff`, `Unit Head`, `Substitute`, `Director` |
+| `leave_management.request.view_all` | View all leave requests | `Unit Head`, `Deputy Registrar (Estt.)`, `Dean`, `Registrar`, `Director`, `Leave Administrator` |
+| `leave_management.request.create` | Create and submit own leave requests | `Faculty`, `Staff`, `Director` |
+| `leave_management.request.withdraw` | Withdraw own pending requests | `Faculty`, `Staff`, `Director` |
+| `leave_management.request.cancel` | Request cancellation of own approved leave | `Faculty`, `Staff`, `Director` |
+| `leave_management.balance.view_self` | View own leave balances and account history | `Faculty`, `Staff`, `Unit Head`, `Director` |
+| `leave_management.balance.view_all` | View employee leave balances | `Leave Administrator` |
+| `leave_management.substitute.respond` | Accept or decline a substitute assignment | `Faculty`, `Staff`, `Substitute` |
+| `leave_management.workflow.task.view` | View assigned leave workflow tasks | `Unit Head`, `Deputy Registrar (Estt.)`, `Dean`, `Registrar`, `Director` |
+| `leave_management.workflow.task.decide` | Review or decide assigned leave workflow tasks | `Unit Head`, `Deputy Registrar (Estt.)`, `Dean`, `Registrar`, `Director` |
+| `leave_management.policy.view` | View current leave policy | `Leave Administrator` |
+| `leave_management.policy.manage` | Maintain current leave policy parameters | `Leave Administrator` |
+| `leave_management.calendar.view` | View published holiday calendars | `Leave Administrator` |
+| `leave_management.calendar.manage` | Maintain and publish holiday calendars | `Leave Administrator` |
+| `leave_management.records.manage` | Maintain authorized leave records and enter already sanctioned offline leave | `Leave Administrator` |
+| `leave_management.sla.manage` | Configure workflow reminder and escalation thresholds | `Leave Administrator` |
+| `leave_management.routing.manage` | Maintain current authority routing configuration | `Leave Administrator` |
+
 ## `placement_cell`
 
 | Code | What it allows | Held by |
diff --git a/docs/02-iam/permission-catalog.md b/docs/02-iam/permission-catalog.md
index 77f5144a..c2fad0d4 100644
--- a/docs/02-iam/permission-catalog.md
+++ b/docs/02-iam/permission-catalog.md
@@ -142,17 +142,27 @@ No write permissions exist by design. The platform never writes academic data
 | `hr.employment.manage` | Create or end an appointment | ⚠️ |
 | `hr.export.pii` | Export employee-identifying data | ⚠️ |
 
-## `leave` *(Phase 6)*
+## `leave_management` — Employee Leave Management
 
 | Code | Description | ⚠️ |
 |---|---|---|
-| `leave.request.view_self` | View own leave requests and balance | |
-| `leave.request.create` | Apply for leave | |
-| `leave.request.delete` | Cancel own pending request | |
-| `leave.request.view` | View leave requests, within scope | |
-| `leave.request.approve` | Approve or reject a leave request | |
-| `leave.balance.update` | Adjust a leave balance | ⚠️ |
-| `leave.type.manage` | Configure leave types and entitlement rules | |
+| `leave_management.request.view_self` | View own leave requests | |
+| `leave_management.request.view_all` | View all leave requests | |
+| `leave_management.request.create` | Create and submit own leave requests | |
+| `leave_management.request.withdraw` | Withdraw own pending requests | |
+| `leave_management.request.cancel` | Request cancellation of own approved leave | |
+| `leave_management.balance.view_self` | View own leave balances and account history | |
+| `leave_management.balance.view_all` | View employee leave balances | |
+| `leave_management.substitute.respond` | Accept or decline a substitute assignment | |
+| `leave_management.workflow.task.view` | View assigned leave workflow tasks | |
+| `leave_management.workflow.task.decide` | Review or decide assigned leave workflow tasks | |
+| `leave_management.policy.view` | View current leave policy | |
+| `leave_management.policy.manage` | Maintain current leave policy parameters | |
+| `leave_management.calendar.view` | View published holiday calendars | |
+| `leave_management.calendar.manage` | Maintain and publish holiday calendars | |
+| `leave_management.records.manage` | Maintain authorized records and record offline-signed leave | ⚠️ |
+| `leave_management.sla.manage` | Configure workflow SLA thresholds | |
+| `leave_management.routing.manage` | Maintain current authority routing | ⚠️ |
 
 ## `sysops` *(Phase 7 — absorbed from the console)*
 
@@ -181,9 +191,9 @@ No write permissions exist by design. The platform never writes academic data
 | `academics` | 4 | 1 |
 | `placement_cell` | 36 | 11 |
 | `hr` | 5 | 2 |
-| `leave` | 7 | 1 |
+| `leave_management` | 17 | 2 |
 | `sysops` | 10 | 3 |
-| **Total** | **80** | **27** |
+| **Total** | **90** | **28** |
 
 ## Built-in role assignments
 
diff --git a/docs/08-delivery/roadmap-and-phases.md b/docs/08-delivery/roadmap-and-phases.md
index c272c1dc..f3ee5e51 100644
--- a/docs/08-delivery/roadmap-and-phases.md
+++ b/docs/08-delivery/roadmap-and-phases.md
@@ -168,14 +168,17 @@ being exactly right ([academic-snapshot-integration.md](../04-placement/academic
 
 ---
 
-## Phase 6 — HR + Leave *(4–5 weeks)*
+## Phase 6 — HR + Employee Leave Management *(4–5 weeks)*
 
 Same eight-step module recipe. Parallelizable after 5c, since the platform patterns are then settled.
 
-Leave consumes `hr.contracts.get_employments(user_ids)`. Neither reads the other's tables.
-
-**Fresh domain design** — the deprecated `establishment` (19 models), `hr2` (12) and `leave` (14) apps are not
-ported ([NG2](../00-overview/vision-and-scope.md#non-goals)).
+ELM is a fresh implementation of the synchronized ELM specifications in the repository-level
+specification bundle. It consumes employment facts through `hr.contracts.get_employments(user_ids)`;
+neither module reads the other's tables. The old `establishment`, `hr2`, and `leave` apps are not
+ported. The phase gate covers all categories and balances, substitute consent, the configured
+authority paths, cancellation/extension/resumption, offline record synchronization, calendars,
+year-end accounting, role authorization, and pending-only SLA reminders and escalation. See the
+[ELM traceability reference](../09-leave/ELM_REFERENCE.md) and [accounting rules](../09-leave/leave-counting-and-entitlement.md).
 
 ---
 
diff --git a/docs/09-leave/ELM_REFERENCE.md b/docs/09-leave/ELM_REFERENCE.md
new file mode 100644
index 00000000..890b68b5
--- /dev/null
+++ b/docs/09-leave/ELM_REFERENCE.md
@@ -0,0 +1,84 @@
+---
+owner: platform
+status: reviewed
+last-reviewed: 2026-10-12
+---
+
+# Employee Leave Management reference
+
+This is the implementation index for the synchronized ELM baseline. The source of truth is the
+repository-level `ELM_Specifications_Bundle_v1.4_FINAL`; the legacy ERP apps are historical context,
+not a template. ELM is a fresh domain module in `modules/leave` and follows the platform's module
+boundaries.
+
+## Scope
+
+ELM supports Faculty and Staff, the six leave categories CL, RH, SCL, EL, COL, VL, and Station Leave
+details embedded in the relevant application. It owns employee leave requests, workflow, calendars,
+account entries, and audit history. User IDs are references; no ELM table has a cross-module foreign
+key. Vacation periods are a read-only projection of the external Academic Calendar.
+
+The system validates before submission, freezes submitted applications, assigns workflow actions,
+and records every balance effect in `LeaveAccountEntry`. Cancellation, extension, and resumption are
+follow-up requests. Offline-sanctioned leave is synchronized with evidence and does not start another
+sanction workflow.
+
+## Rule index
+
+| Rule | Required behavior | Implementation location |
+|---|---|---|
+| BR-EL-001 | Only CL, RH, SCL, EL, COL, and VL are supported; category eligibility follows employee kind. | `domain/validation.py`; `domain/eligibility.py` |
+| BR-EL-002 | CL is 8 days yearly and unused balance lapses. | `domain/eligibility.py`; `services/accounting.py` |
+| BR-EL-003 | RH is 2 days yearly, limited to dates in the effective published RH calendar; unused balance lapses. | `services/requests.py`; `services/accounting.py` |
+| BR-EL-004 | SCL is up to 15 days; its admissibility is decided by the authority, not an encoded purpose list. | `domain/eligibility.py`; `services/requests.py` |
+| BR-EL-005 | Non-faculty staff receive 30 EL days yearly; unused EL carries forward. | `domain/eligibility.py`; `services/accounting.py` |
+| BR-EL-006 | Faculty receive 60 VL days, usable only during a supplied vacation period. | `domain/eligibility.py`; `VacationPeriod`; `services/requests.py` |
+| BR-EL-007 | At year end, unused faculty VL converts to EL at 2 VL : 1 EL, with fractional credit. | `services/accounting.py` |
+| BR-EL-008 | Converted credit is ordinary EL and may carry forward or be used. | `LeaveAccountEntry`; `services/accounting.py` |
+| BR-EL-009 | COL is 20 days yearly for eligible employees, balance controlled, with configurable medical evidence; unused balance carries forward. | `LeavePolicy`; `services/accounting.py` |
+| BR-EL-010 | Approved half-day CL consumes 0.5 day. | `LeaveRequest.cl_portion`; `domain/validation.py` |
+| BR-EL-011 | EL/COL/VL count every calendar day in the approved interval, including weekends and closed holidays. | `domain/validation.py` |
+| BR-EL-012 | Active pending/approved overlaps are rejected; distinct first-half and second-half CL on one date may coexist. | `domain/validation.py`; `services/requests.py` |
+| BR-EL-013 | Station Leave is captured with the leave application, including destination and departure/return. | `LeaveRequest`; `domain/validation.py` |
+| BR-EL-014 | A substitute is another active employee, not the applicant, and has no overlapping pending/approved leave. | `services/requests.py` |
+| BR-EL-015 | Required consent is accepted before routing; a decline permits one replacement or withdrawal. | `SubstituteResponse`; `services/requests.py` |
+| BR-EL-016 | Unit Head is final for CL/RH. | `domain/state_machine.py`; `services/requests.py` |
+| BR-EL-017 | Unit Head records Recommended / Not Recommended on higher-sanction leave; neither is a final decision. | `WorkflowTask.decision_kind`; `services/requests.py` |
+| BR-EL-018 | Higher-sanction requests follow the current configured hierarchy. | `LeaveRouteConfiguration`; `domain/state_machine.py` |
+| BR-EL-019 | Establishment verification is optional when configured; authority resolution uses current employee and route data. | `LeaveRouteConfiguration`; `services/requests.py` |
+| BR-EL-020 | Director leave follows the Director self-sanction route. | `EmployeeProfile.is_director`; `domain/state_machine.py` |
+| BR-EL-021 | Retired: pending submitted applications are not modified in place. | No update endpoint for submitted requests. |
+| BR-EL-022 | Pending withdrawal is immediate and terminates remaining workflow tasks. | `services/requests.py` |
+| BR-EL-023 | Pre-start cancellation follows the original hierarchy; approval reverses debits, rejection preserves the approval. | `services/requests.py` |
+| BR-EL-024 | A changed leave period after cancellation requires a fresh application. | Follow-up request model and API. |
+| BR-EL-025 | Ongoing EL/COL/VL extension validates and posts only the incremental days. | `services/requests.py` |
+| BR-EL-026 | Retired identifier. | No behavior. |
+| BR-EL-027 | EL/COL/VL resumption is reviewed by the original final authority. | `services/requests.py` |
+| BR-EL-028 | Normal resumption changes no balance; early/late resumption posts the reviewed actual-period adjustment. | `domain/state_machine.py`; `services/requests.py` |
+| BR-EL-029 | Offline leave requires sanction reference and evidence, consistency validation, and a balance entry; it does not route for a second approval. | `services/requests.py` |
+| BR-EL-030 | Current policy and route values are used; no policy publication lifecycle exists. | `LeavePolicy`; `LeaveRouteConfiguration` |
+| BR-EL-031 | Validation uses the currently published holiday/RH calendar until its replacement is published. | `HolidayCalendar`; `services/requests.py` |
+| BR-EL-032 | Reminders run only while a task remains pending and are logged. | `tasks.process_leave_sla_thresholds` |
+| BR-EL-033 | Escalation runs only while pending, notifies/reassigns to configured responsibility, and is logged. | `tasks.process_leave_sla_thresholds` |
+| BR-EL-034 | Submitted requests cannot be edited. | Draft creation only; follow-up requests for later actions. |
+| BR-EL-035 | Actionable task assignment sends a notification; final decisions notify the employee. | `services/notifications.py` |
+| BR-EL-036 | Role and permission checks gate employee, processing, sanction, and administrator actions. | `api/views.py`; `registry/permissions.json` |
+| BR-EL-037 | Record maintenance/offline entry does not confer sanction authority. | Separate `records.manage` permission and offline service. |
+| BR-EL-038 | Reminder and escalation thresholds are configurable per workflow role. | `LeaveSLAConfiguration`; `api/serializers.py` |
+
+## Use-case coverage
+
+The API covers apply/submit, substitute response and replacement, Unit Head review, higher sanction,
+withdrawal, cancellation, extension, resumption, balances and account history, printable application,
+policy/calendar/routing/SLA administration, offline entry, account correction, and the scheduled
+year-end and SLA triggers. The state machine and counting documents describe the sequencing and
+arithmetic in detail.
+
+## External dependencies and operational boundaries
+
+- `EmployeeProfile` is populated from the HR/IAM employment and hierarchy projection.
+- `VacationPeriod` is supplied by the Academic Calendar; ELM does not create vacation periods.
+- The Celery beat schedule checks the configured year-end boundary daily and delivers notification
+  outbox messages. A year-end run is idempotent by account-entry source key.
+- API requests authenticate through IAM and use the server-side `leave_management` grant and
+  fine-grained permissions.
diff --git a/docs/09-leave/leave-authority-and-routing.md b/docs/09-leave/leave-authority-and-routing.md
new file mode 100644
index 00000000..81be9c5d
--- /dev/null
+++ b/docs/09-leave/leave-authority-and-routing.md
@@ -0,0 +1,45 @@
+---
+owner: platform
+status: reviewed
+last-reviewed: 2026-10-12
+---
+
+# Leave authority and routing
+
+Access combines an IAM module grant with an ELM permission and the task's employee/role scope.
+The server scopes request and account querysets before serialization; hidden client links are not an
+authorization control.
+
+## Decision paths
+
+- CL and RH: the applicant's Unit Head makes the final decision.
+- SCL, EL, COL, and VL: the Unit Head recommends or does not recommend; the task continues through
+  the current configured hierarchy to the final Sanctioning Authority.
+- Establishment verification is included only when current route configuration requires it.
+- The Director's own leave uses the Director self-sanction route.
+- Cancellation follows the same route as the leave being cancelled. Extension uses the applicable
+  Unit Head and higher-sanction path. Resumption goes to the original final Sanctioning Authority.
+- Each task is assigned to a user from the employee/route projection. If an authority or Unit Head
+  is missing, ELM stops submission with a configuration error rather than creating an unowned task.
+
+## Permissions
+
+| Permission family | Intended holder |
+|---|---|
+| Own request, balance, create, withdraw, cancellation | Employee roles |
+| Substitute response | Current nominated substitute |
+| Workflow task view and decision | Assigned Unit Head, Establishment role, or final authority |
+| Policy, calendar, routing, SLA, and record maintenance | Leave Administrator |
+| All-request/all-balance inspection | Explicit authorized operational roles |
+
+Offline record maintenance and account corrections are separate from sanction permissions. An
+administrator may record an already sanctioned paper request with reference evidence, but that
+permission does not allow approving ordinary requests.
+
+## Notifications and SLA
+
+When an actionable task is assigned, ELM writes a deduplicated outbox message in the same transaction.
+Final decisions notify the employee. Intermediate status changes remain available in request history.
+Reminder and escalation thresholds are configured per role; scheduled processing rechecks that a
+task is still pending before sending or changing its assigned responsibility. Every reminder and
+escalation is recorded in the request audit history.
diff --git a/docs/09-leave/leave-counting-and-entitlement.md b/docs/09-leave/leave-counting-and-entitlement.md
new file mode 100644
index 00000000..99be184f
--- /dev/null
+++ b/docs/09-leave/leave-counting-and-entitlement.md
@@ -0,0 +1,63 @@
+---
+owner: platform
+status: reviewed
+last-reviewed: 2026-10-12
+---
+
+# Leave counting and entitlement
+
+This document states the baseline arithmetic. The authoritative values are the current configured
+ELM policy; the defaults below are the synchronized baseline values.
+
+## Annual entitlement
+
+| Category | Eligibility | Annual credit | Year-end treatment |
+|---|---|---:|---|
+| CL | Faculty and Staff | 8 days | Unused balance lapses |
+| RH | Faculty and Staff | 2 days | Unused balance lapses |
+| SCL | Faculty and Staff | Up to 15 days | Unused balance lapses |
+| EL | Non-faculty Staff | 30 days | Unused balance carries forward |
+| VL | Faculty, only during an Academic Calendar vacation | 60 days | Unused VL converts to EL at 2:1 |
+| COL | Eligible Faculty and Staff | 20 days | Unused balance carries forward |
+
+SCL admissibility is decided by the final authority. The system does not invent a separate encoded
+purpose list. COL medical evidence is requested only when current policy requires it.
+
+## Counting an interval
+
+- EL, COL, and VL count every date from start through end, inclusive. Saturdays, Sundays, and closed
+  holidays inside the interval count.
+- CL, SCL, and RH do not use that continuous-count rule. CL and SCL count chargeable working days
+  after removing weekends and closed calendar holidays. RH is one day and must match an RH entry in
+  the currently published calendar.
+- A CL half day must be for one date and consumes 0.5. A first-half and second-half request may
+  share a date; a full day cannot overlap either half.
+- Cross-year periods are split by calendar year for validation and ledger posting. Each year's
+  request portion must fit that year's available balance.
+- Station Leave adds details to the same request. It does not create another leave category or
+  account debit.
+
+## Balance equations
+
+For one employee, category, and year:
+
+`available = sum(all immutable account entries for that employee/category/year)`
+
+Entitlement, carry-in, approved use, cancellation reversal, resumption adjustment, and authorized
+administrative correction are separate ledger entries. A rejected or withdrawn request creates no
+leave debit. A final approval debits only the approved duration. A final cancellation approval
+credits the exact original debit by year.
+
+## Year-end event
+
+At the configured boundary, the event closes the ending leave year and opens the next one. The
+processor is idempotent and reports counts for closing, carry-forward, conversion, lapse, and
+exceptions.
+
+- CL, RH, and SCL unused balance is removed.
+- EL and COL unused balance is debited from the closing year and credited to the next year at 1:1.
+- Faculty VL unused balance is removed from VL and credited to next-year EL at 1 EL for every 2 VL.
+  Fractional conversions are retained at the account's decimal precision.
+- The next year's configured annual entitlement is credited once, separately from carry-in.
+- Failed employee/category records are retried by the same source key and remain visible as
+  operational exceptions; the year-end boundary is a system event, not a human actor.
diff --git a/docs/09-leave/leave-domain-model.md b/docs/09-leave/leave-domain-model.md
new file mode 100644
index 00000000..0cd99740
--- /dev/null
+++ b/docs/09-leave/leave-domain-model.md
@@ -0,0 +1,52 @@
+---
+owner: platform
+status: reviewed
+last-reviewed: 2026-10-12
+---
+
+# Leave domain model
+
+ELM owns leave facts and account history in its module database. It stores IAM user IDs as scalar
+references and never joins another module's tables. See the [reference index](ELM_REFERENCE.md).
+
+## Records
+
+| Record | Purpose |
+|---|---|
+| `EmployeeProfile` | Current employee kind, designation, unit, Unit Head, and Director flag projected from HR/IAM. |
+| `LeavePolicy` | One current parameter set for annual entitlements, COL evidence, and year-end boundary. |
+| `LeaveCategory` | The fixed CL/RH/SCL/EL/COL/VL category catalogue. |
+| `HolidayCalendar` | Draft, published, and superseded revisions of the institute holiday/RH calendar. |
+| `VacationPeriod` | Read-only Academic Calendar vacation projection used to validate VL. |
+| `LeaveRequest` | Draft, submitted, decision, cancellation, extension, resumption, and offline record. A follow-up links to its base request. |
+| `WorkflowTask` | Ordered, queued or pending action assigned to a user and role. Only the active step is actionable. |
+| `SubstituteResponse` | Append-only accept/decline records, including the single replacement traversal. |
+| `LeaveSanction` | One decision or recommendation for a completed workflow task. |
+| `LeaveAccountEntry` | Immutable credit/debit with a unique source key for retries and reconciliation. |
+| `LeaveBalance` | Materialized per employee/category/year balance, updated only with a ledger entry. |
+| `LeaveAuditEvent` | Append-only request lifecycle, SLA, and administrative action history. |
+| `LeaveRouteConfiguration` | Current category and employee-context authority route, optional Establishment step, and substitute requirement. |
+| `LeaveSLAConfiguration` | Current reminder/escalation threshold and escalation target for a workflow role. |
+| `LeaveNotificationOutbox` | Transactional notification queue, retried independently of the business action. |
+
+## Invariants
+
+1. A request has its own generated ID; an employee can hold many requests.
+2. Submission freezes the request fields. Later changes use a new cancellation, extension, or
+   resumption request, except the explicitly allowed replacement of a declined substitute.
+3. Every balance change has one `LeaveAccountEntry`. The unique source key makes approval,
+   cancellation, offline recording, and year-end retries idempotent.
+4. The cached `LeaveBalance` is an account summary; the ledger is the explanation for the balance.
+5. Workflow tasks after the current action remain queued. Withdrawal cancels every outstanding task.
+6. A negative Unit Head recommendation on a higher-sanction request continues to the configured
+   final authority; it is not a rejection.
+7. An approved leave record remains intact while its cancellation is considered. An approved
+   cancellation reverses the original account debits.
+
+## Ownership and synchronization
+
+The HR/IAM integration supplies employee kind, designation, organizational unit, Unit Head, and
+Director status. The Academic Calendar supplies vacation windows. ELM owns leave policy, holiday/RH
+calendar revisions, request workflow, leave balances, and account history. No ELM operation writes
+back to HR or the Academic Calendar directly; any attendance synchronization is an integration
+contract to be supplied by the owning service.
diff --git a/docs/09-leave/leave-state-machine.md b/docs/09-leave/leave-state-machine.md
new file mode 100644
index 00000000..380d750a
--- /dev/null
+++ b/docs/09-leave/leave-state-machine.md
@@ -0,0 +1,52 @@
+---
+owner: platform
+status: reviewed
+last-reviewed: 2026-10-12
+---
+
+# Leave request workflow states
+
+Each request has one status and a separate ordered set of workflow tasks. Only a pending task may be
+acted on. Queued tasks are activated after the preceding review is recorded.
+
+## New leave
+
+```mermaid
+stateDiagram-v2
+    [*] --> Draft
+    Draft --> AwaitingSubstitute: submit with required substitute
+    Draft --> PendingUnitHead: submit without substitute
+    AwaitingSubstitute --> PendingUnitHead: accepted
+    AwaitingSubstitute --> ApplicantAction: declined
+    ApplicantAction --> AwaitingSubstitute: nominate one replacement
+    ApplicantAction --> Withdrawn: applicant withdraws
+    PendingUnitHead --> Approved: CL/RH final approval
+    PendingUnitHead --> Rejected: CL/RH final rejection
+    PendingUnitHead --> PendingEstablishment: recommendation on higher-sanction leave
+    PendingUnitHead --> PendingAuthority: recommendation when no Establishment step
+    PendingEstablishment --> PendingAuthority: forwarded
+    PendingAuthority --> Approved: final approval
+    PendingAuthority --> Rejected: final rejection
+    PendingUnitHead --> Withdrawn: applicant withdraws
+    PendingEstablishment --> Withdrawn: applicant withdraws
+    PendingAuthority --> Withdrawn: applicant withdraws
+```
+
+A Unit Head's Not Recommended result on higher-sanction leave still routes to the next authority.
+Director-applicant requests use the Director self-sanction task. Substitute response and workflow
+task records are audited separately.
+
+## Follow-up requests
+
+| Request | Entry condition | Decision effect |
+|---|---|---|
+| Cancellation | Existing approved leave; before its start | Same applicable hierarchy. Approval marks the original cancelled and reverses its account debit; rejection preserves it. |
+| Extension | Ongoing approved EL, COL, or VL | Same leave eligibility and route; approval posts only the incremental interval. |
+| Resumption | Approved EL, COL, or VL; employee has returned | Original final authority reviews actual return date. Normal: no adjustment. Early/late: adjust to actual leave period. |
+| Offline sanctioned entry | Authorized administrator has evidence of prior sanction | Direct account/history synchronization, without a second approval workflow. |
+
+## Immediate withdrawal
+
+Before final approval, the employee may withdraw at any time. The request becomes Withdrawn
+immediately, every pending or queued workflow task is terminated, and remaining assigned reviewers
+are notified. Stale actions fail because task and request state are checked inside the transaction.
diff --git a/modules/leave/__init__.py b/modules/leave/__init__.py
new file mode 100644
index 00000000..8ed07c0e
--- /dev/null
+++ b/modules/leave/__init__.py
@@ -0,0 +1 @@
+"""Employee Leave Management domain module."""
diff --git a/modules/leave/api/serializers.py b/modules/leave/api/serializers.py
new file mode 100644
index 00000000..c1dee436
--- /dev/null
+++ b/modules/leave/api/serializers.py
@@ -0,0 +1,159 @@
+"""Wire representations for the Employee Leave Management API."""
+from rest_framework import serializers
+
+from modules.leave.models import (HolidayCalendar, LeaveAccountEntry, LeaveBalance,
+    LeaveAuditEvent, LeaveCategory, LeavePolicy, LeaveRequest, LeaveRouteConfiguration,
+    LeaveSanction, LeaveSLAConfiguration, WorkflowTask)
+
+
+class LeaveCategorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveCategory
+        fields = ["code", "label", "description"]
+        read_only_fields = fields
+
+
+class LeaveBalanceSerializer(serializers.ModelSerializer):
+    category_code = serializers.CharField(source="category_id", read_only=True)
+    class Meta:
+        model = LeaveBalance
+        fields = ["id", "category_code", "year", "entitlement", "carried_over", "available", "updated_at"]
+        read_only_fields = fields
+
+
+class LeaveRequestSerializer(serializers.ModelSerializer):
+    category_code = serializers.CharField(source="category_id", read_only=True)
+    class Meta:
+        model = LeaveRequest
+        fields = ["id", "employee_id", "category_code", "request_type", "parent_request", "status", "start_date", "end_date",
+                  "duration_days", "cl_portion", "reason", "station_leave", "station_destination",
+                  "station_departure_at", "station_return_at", "medical_evidence_ref", "substitute_user_id",
+                  "actual_resume_date", "submitted_at", "decided_at", "created_at", "updated_at"]
+        read_only_fields = ["id", "employee_id", "category_code", "request_type", "parent_request", "status", "duration_days", "submitted_at",
+                            "decided_at", "created_at", "updated_at"]
+
+
+class LeaveDraftSerializer(serializers.ModelSerializer):
+    category_code = serializers.SlugRelatedField(source="category", slug_field="code", queryset=LeaveCategory.objects.all())
+    class Meta:
+        model = LeaveRequest
+        fields = ["category_code", "start_date", "end_date", "cl_portion", "reason", "station_leave",
+                  "station_destination", "station_departure_at", "station_return_at", "medical_evidence_ref",
+                  "substitute_user_id"]
+
+
+class LeaveTaskSerializer(serializers.ModelSerializer):
+    category_code = serializers.CharField(source="request.category_id", read_only=True)
+    employee_id = serializers.IntegerField(source="request.employee_id", read_only=True)
+    class Meta:
+        model = WorkflowTask
+        fields = ["id", "request_id", "employee_id", "category_code", "sequence", "role", "state", "due_at", "created_at"]
+        read_only_fields = fields
+
+
+class LeaveSanctionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveSanction
+        fields = ["id", "task_id", "actor_user_id", "decision", "notes", "decided_at"]
+        read_only_fields = fields
+
+
+class LeaveAuditEventSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveAuditEvent
+        fields = ["id", "action", "from_status", "to_status", "actor_user_id", "occurred_at", "details"]
+        read_only_fields = fields
+
+
+class LeaveAccountEntrySerializer(serializers.ModelSerializer):
+    category_code = serializers.CharField(source="category_id", read_only=True)
+    class Meta:
+        model = LeaveAccountEntry
+        fields = ["id", "category_code", "year", "amount", "kind", "request_id", "source_key", "explanation", "created_at"]
+        read_only_fields = fields
+
+
+class LeavePolicySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeavePolicy
+        fields = ["policy_key", "cl_days", "rh_days", "scl_days", "faculty_vl_days",
+                  "nonfaculty_el_days", "col_days", "col_medical_evidence_required",
+                  "year_end_month", "year_end_day", "updated_at"]
+        read_only_fields = ["policy_key", "updated_at"]
+
+
+class HolidayCalendarSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HolidayCalendar
+        fields = ["id", "year", "revision", "holidays", "state", "published_by_user_id", "published_at", "created_at"]
+        read_only_fields = ["id", "revision", "state", "published_by_user_id", "published_at", "created_at"]
+
+
+class HolidayCalendarDraftSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = HolidayCalendar
+        fields = ["year", "holidays"]
+
+
+class LeaveRouteConfigurationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveRouteConfiguration
+        fields = ["id", "category", "employee_kind", "designation", "unit_code",
+                  "final_authority_role", "final_authority_user_id", "establishment_role",
+                  "establishment_user_id", "requires_substitute", "active", "updated_at"]
+        read_only_fields = ["id", "updated_at"]
+
+    def validate(self, attrs):
+        role = attrs.get("establishment_role", getattr(self.instance, "establishment_role", ""))
+        establishment_id = attrs.get("establishment_user_id", getattr(self.instance, "establishment_user_id", None))
+        final_id = attrs.get("final_authority_user_id", getattr(self.instance, "final_authority_user_id", None))
+        if not final_id:
+            raise serializers.ValidationError({"final_authority_user_id": "A final authority user must be assigned."})
+        if role and not establishment_id:
+            raise serializers.ValidationError({"establishment_user_id": "Assign a user when an Establishment step is configured."})
+        return attrs
+
+
+class LeaveSLAConfigurationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveSLAConfiguration
+        fields = ["id", "role", "reminder_after_hours", "escalate_after_hours",
+                  "escalation_role", "escalation_user_id", "updated_by_user_id", "updated_at"]
+        read_only_fields = ["id", "updated_by_user_id", "updated_at"]
+
+    def validate(self, attrs):
+        reminder = attrs.get("reminder_after_hours", getattr(self.instance, "reminder_after_hours", 24))
+        escalate = attrs.get("escalate_after_hours", getattr(self.instance, "escalate_after_hours", 72))
+        if escalate < reminder:
+            raise serializers.ValidationError({"escalate_after_hours": "Escalation must be at or after the reminder threshold."})
+        return attrs
+
+
+class LeaveExtensionInputSerializer(serializers.Serializer):
+    new_end_date = serializers.DateField()
+    reason = serializers.CharField()
+    substitute_user_id = serializers.IntegerField(required=False, allow_null=True)
+
+
+class LeaveResumptionInputSerializer(serializers.Serializer):
+    actual_resume_date = serializers.DateField()
+    reason = serializers.CharField()
+
+
+class OfflineLeaveInputSerializer(serializers.Serializer):
+    employee_id = serializers.IntegerField(min_value=1)
+    category_code = serializers.SlugRelatedField(slug_field="code", queryset=LeaveCategory.objects.all())
+    start_date = serializers.DateField()
+    end_date = serializers.DateField()
+    reason = serializers.CharField()
+    sanction_reference = serializers.CharField(max_length=240)
+    evidence_reference = serializers.CharField(max_length=500)
+
+
+class AccountAdjustmentInputSerializer(serializers.Serializer):
+    employee_id = serializers.IntegerField(min_value=1)
+    category_code = serializers.SlugRelatedField(slug_field="code", queryset=LeaveCategory.objects.all())
+    year = serializers.IntegerField(min_value=2000, max_value=9999)
+    amount = serializers.DecimalField(max_digits=8, decimal_places=2)
+    reference = serializers.CharField(max_length=100)
+    explanation = serializers.CharField(max_length=240)
diff --git a/modules/leave/api/urls.py b/modules/leave/api/urls.py
new file mode 100644
index 00000000..1133d81e
--- /dev/null
+++ b/modules/leave/api/urls.py
@@ -0,0 +1,35 @@
+"""Versioned ELM endpoints."""
+from django.urls import path
+
+from modules.leave.api import views
+
+urlpatterns = [
+    path("employees", views.EmployeeSearchView.as_view(), name="leave-employee-search"),
+    path("categories", views.CategoryListView.as_view(), name="leave-categories"),
+    path("balances", views.BalanceListView.as_view(), name="leave-balances"),
+    path("accounts", views.AccountHistoryView.as_view(), name="leave-account-history"),
+    path("requests", views.RequestListCreateView.as_view(), name="leave-requests"),
+    path("requests/<int:pk>", views.RequestDetailView.as_view(), name="leave-request"),
+    path("requests/<int:pk>/history", views.RequestHistoryView.as_view(), name="leave-request-history"),
+    path("requests/<int:pk>/submit", views.SubmitView.as_view(), name="leave-request-submit"),
+    path("requests/<int:pk>/withdraw", views.WithdrawView.as_view(), name="leave-request-withdraw"),
+    path("requests/<int:pk>/cancel", views.CancellationView.as_view(), name="leave-request-cancel"),
+    path("requests/<int:pk>/extend", views.ExtensionView.as_view(), name="leave-request-extend"),
+    path("requests/<int:pk>/resumption", views.ResumptionView.as_view(), name="leave-request-resumption"),
+    path("requests/<int:pk>/print", views.RequestPrintView.as_view(), name="leave-request-print"),
+    path("requests/<int:pk>/substitute-response", views.SubstituteResponseView.as_view(), name="leave-substitute-response"),
+    path("requests/<int:pk>/replace-substitute", views.ReplaceSubstituteView.as_view(), name="leave-replace-substitute"),
+    path("substitutions", views.SubstituteInboxView.as_view(), name="leave-substitute-inbox"),
+    path("tasks", views.TaskListView.as_view(), name="leave-tasks"),
+    path("tasks/<int:pk>/decision", views.TaskDecisionView.as_view(), name="leave-task-decision"),
+    path("policy", views.PolicyView.as_view(), name="leave-policy"),
+    path("calendars", views.HolidayCalendarListView.as_view(), name="leave-holiday-calendars"),
+    path("calendars/drafts", views.HolidayCalendarDraftView.as_view(), name="leave-calendar-drafts"),
+    path("calendars/<int:pk>/publish", views.HolidayCalendarPublishView.as_view(), name="leave-calendar-publish"),
+    path("configuration/routes", views.RouteConfigurationListView.as_view(), name="leave-route-configurations"),
+    path("configuration/routes/<int:pk>", views.RouteConfigurationDetailView.as_view(), name="leave-route-configuration"),
+    path("configuration/sla", views.SLAConfigurationListView.as_view(), name="leave-sla-configurations"),
+    path("configuration/sla/<int:pk>", views.SLAConfigurationDetailView.as_view(), name="leave-sla-configuration"),
+    path("admin/offline-leave", views.OfflineLeaveView.as_view(), name="leave-offline-record"),
+    path("admin/account-adjustments", views.AccountAdjustmentView.as_view(), name="leave-account-adjustment"),
+]
diff --git a/modules/leave/api/views.py b/modules/leave/api/views.py
new file mode 100644
index 00000000..9e20ce62
--- /dev/null
+++ b/modules/leave/api/views.py
@@ -0,0 +1,372 @@
+"""ELM HTTP endpoints. Querysets scope employee data before serialization."""
+from datetime import date
+
+from django.db.models import Q
+from django.db import transaction
+from django.http import HttpResponse
+from django.utils.html import escape
+from django.utils import timezone
+from django.shortcuts import get_object_or_404
+from rest_framework import generics, status
+from rest_framework.exceptions import PermissionDenied, ValidationError
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from fusion_auth.permissions import HasModuleGrant, HasPermission
+from modules.directory import contracts as directory
+from modules.leave.api import serializers as s
+from modules.leave.models import (
+    EmployeeProfile, HolidayCalendar, LeaveAccountEntry, LeaveAuditEvent, LeaveBalance,
+    LeaveCategory, LeavePolicy, LeaveRequest, LeaveRouteConfiguration,
+    LeaveSanction, LeaveSLAConfiguration, WorkflowTask,
+)
+from modules.leave.services import requests as service
+from modules.leave.domain.state_machine import normalize_role
+
+
+class _LeaveView:
+    """Common module gate; IAM owns credentials and the principal."""
+    @property
+    def actor(self):
+        return self.request.principal
+
+    def rule_error(self, exc):
+        raise ValidationError({"detail": str(exc)}) from exc
+
+
+class CategoryListView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.LeaveCategorySerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.view_self")]
+    queryset = LeaveCategory.objects.all()
+
+
+class EmployeeSearchView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.create")]
+    def get(self, request):
+        query = request.query_params.get("q", "").strip()
+        if len(query) < 2:
+            return Response([])
+        results = []
+        for user in directory.search(query, limit=25):
+            if user.user_id == self.actor.user_id or user.kind not in {"faculty", "staff"}:
+                continue
+            if not EmployeeProfile.objects.filter(user_id=user.user_id, active=True).exists():
+                continue
+            results.append({"user_id": user.user_id, "label": user.display_name, "kind": user.kind})
+        return Response(results)
+
+
+class BalanceListView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.LeaveBalanceSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.balance.view_self")]
+    def get_queryset(self):
+        return LeaveBalance.objects.filter(employee_id=self.actor.user_id).select_related("category").order_by("year", "category_id")
+
+
+class AccountHistoryView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.LeaveAccountEntrySerializer if hasattr(s, "LeaveAccountEntrySerializer") else None
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.balance.view_self")]
+    def get_queryset(self):
+        return LeaveAccountEntry.objects.filter(employee_id=self.actor.user_id).select_related("category").order_by("-created_at")
+
+
+class RequestListCreateView(_LeaveView, generics.ListCreateAPIView):
+    permission_classes = [HasModuleGrant("leave_management")]
+    def get_permissions(self):
+        permission = (HasPermission("leave_management.request.create") if self.request.method == "POST"
+                     else HasPermission("leave_management.request.view_self", "leave_management.request.view_all"))
+        return [permission(), HasModuleGrant("leave_management")()]
+    def get_serializer_class(self):
+        return s.LeaveDraftSerializer if self.request.method == "POST" else s.LeaveRequestSerializer
+    def get_queryset(self):
+        qs = LeaveRequest.objects.select_related("category", "parent_request")
+        if self.actor.has_permission("leave_management.request.view_all"):
+            return qs
+        return qs.filter(employee_id=self.actor.user_id)
+    def create(self, request, *args, **kwargs):
+        payload = s.LeaveDraftSerializer(data=request.data)
+        payload.is_valid(raise_exception=True)
+        request_obj = LeaveRequest.objects.create(employee_id=self.actor.user_id, **payload.validated_data)
+        return Response(s.LeaveRequestSerializer(request_obj).data, status=status.HTTP_201_CREATED)
+
+
+class RequestDetailView(_LeaveView, generics.RetrieveAPIView):
+    serializer_class = s.LeaveRequestSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.view_self", "leave_management.request.view_all")]
+    def get_queryset(self):
+        qs = LeaveRequest.objects.select_related("category", "parent_request")
+        return qs if self.actor.has_permission("leave_management.request.view_all") else qs.filter(employee_id=self.actor.user_id)
+
+
+class RequestHistoryView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.LeaveAuditEventSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.view_self", "leave_management.request.view_all")]
+    def get_queryset(self):
+        requests = LeaveRequest.objects.all()
+        if not self.actor.has_permission("leave_management.request.view_all"):
+            requests = requests.filter(employee_id=self.actor.user_id)
+        request_obj = get_object_or_404(requests, pk=self.kwargs["pk"])
+        return LeaveAuditEvent.objects.filter(request=request_obj).order_by("occurred_at", "id")
+
+
+class SubmitView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.create")]
+    def post(self, request, pk):
+        try:
+            obj = service.submit_request(pk, self.actor.user_id)
+        except (service.LeaveRuleViolation, EmployeeProfile.DoesNotExist, LeaveRequest.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data)
+
+
+class WithdrawView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.withdraw")]
+    def post(self, request, pk):
+        try:
+            obj = service.withdraw_request(pk, self.actor.user_id)
+        except (service.LeaveRuleViolation, LeaveRequest.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data)
+
+
+class CancellationView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.cancel")]
+    def post(self, request, pk):
+        try:
+            obj = service.request_cancellation(pk, self.actor.user_id)
+        except (service.LeaveRuleViolation, LeaveRequest.DoesNotExist, EmployeeProfile.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data, status=status.HTTP_201_CREATED)
+
+
+class ExtensionView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.create")]
+    def post(self, request, pk):
+        payload = s.LeaveExtensionInputSerializer(data=request.data)
+        payload.is_valid(raise_exception=True)
+        try:
+            obj = service.request_extension(pk, self.actor.user_id, **payload.validated_data)
+        except (service.LeaveRuleViolation, LeaveRequest.DoesNotExist, EmployeeProfile.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data, status=status.HTTP_201_CREATED)
+
+
+class ResumptionView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.create")]
+    def post(self, request, pk):
+        payload = s.LeaveResumptionInputSerializer(data=request.data)
+        payload.is_valid(raise_exception=True)
+        try:
+            obj = service.submit_resumption(pk, self.actor.user_id, **payload.validated_data)
+        except (service.LeaveRuleViolation, LeaveRequest.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data, status=status.HTTP_201_CREATED)
+
+
+class RequestPrintView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.view_self", "leave_management.request.view_all")]
+    def get(self, request, pk):
+        qs = LeaveRequest.objects.select_related("category")
+        if not self.actor.has_permission("leave_management.request.view_all"):
+            qs = qs.filter(employee_id=self.actor.user_id)
+        obj = get_object_or_404(qs, pk=pk)
+        rows = {
+            "Employee": obj.employee_id, "Leave category": f"{obj.category_id} · {obj.category.label}",
+            "Period": f"{obj.start_date} to {obj.end_date}", "Duration": f"{obj.duration_days} days",
+            "Status": obj.get_status_display(), "Purpose / reason": obj.reason,
+            "Station Leave": "Yes" if obj.station_leave else "No",
+            "Destination": obj.station_destination or "—",
+        }
+        details = "".join(f"<dt>{escape(label)}</dt><dd>{escape(str(value))}</dd>" for label, value in rows.items())
+        return HttpResponse(
+            "<!doctype html><html><head><meta charset='utf-8'><title>Leave application</title>"
+            "<style>body{font:16px system-ui;max-width:760px;margin:3rem auto;color:#172033}"
+            "dt{font-weight:600;margin-top:1rem}dd{margin:.25rem 0}button{margin-top:2rem}"
+            "@media print{button{display:none}body{margin:1cm}}</style></head><body>"
+            f"<h1>Leave application #{obj.pk}</h1><dl>{details}</dl>"
+            "<button onclick='window.print()'>Print / Save as PDF</button></body></html>",
+            content_type="text/html; charset=utf-8",
+        )
+
+
+class SubstituteResponseView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.substitute.respond")]
+    def post(self, request, pk):
+        accepted = request.data.get("decision") == "accept"
+        if request.data.get("decision") not in {"accept", "decline"}:
+            raise ValidationError({"decision": "Use accept or decline."})
+        try:
+            obj = service.respond_to_substitute(pk, self.actor.user_id, accepted=accepted)
+        except (service.LeaveRuleViolation, LeaveRequest.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data)
+
+
+class SubstituteInboxView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.LeaveRequestSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.substitute.respond")]
+    def get_queryset(self):
+        return LeaveRequest.objects.filter(substitute_user_id=self.actor.user_id,
+                                           status=LeaveRequest.Status.AWAITING_SUBSTITUTE).select_related("category")
+
+
+class ReplaceSubstituteView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.request.create")]
+    def post(self, request, pk):
+        try:
+            obj = service.replace_declined_substitute(pk, self.actor.user_id,
+                                                      int(request.data.get("substitute_user_id")))
+        except (service.LeaveRuleViolation, LeaveRequest.DoesNotExist, TypeError, ValueError) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data)
+
+
+class TaskListView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.LeaveTaskSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.workflow.task.view")]
+    def get_queryset(self):
+        role_names = [normalize_role(role) for role in self.actor.roles]
+        return WorkflowTask.objects.filter(state=WorkflowTask.State.PENDING).filter(
+            Q(assigned_user_id=self.actor.user_id) | Q(role__in=role_names)
+        ).select_related("request").order_by("created_at")
+
+
+class TaskDecisionView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.workflow.task.decide")]
+    def post(self, request, pk):
+        task = get_object_or_404(WorkflowTask, pk=pk, state=WorkflowTask.State.PENDING)
+        actor_roles = {normalize_role(role) for role in self.actor.roles}
+        if task.assigned_user_id != self.actor.user_id and task.role not in actor_roles:
+            raise PermissionDenied()
+        try:
+            obj = service.decide_task(pk, self.actor.user_id,
+                                      decision=request.data.get("decision", ""),
+                                      notes=request.data.get("notes", ""))
+        except (service.LeaveRuleViolation, WorkflowTask.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data)
+
+
+class PolicyView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.policy.view", "leave_management.policy.manage")]
+    def get(self, request):
+        policy = LeavePolicy.objects.filter(policy_key="current").first()
+        return Response(s.LeavePolicySerializer(policy).data if policy else None)
+    def put(self, request):
+        if not self.actor.has_permission("leave_management.policy.manage"):
+            raise PermissionDenied()
+        policy = LeavePolicy.objects.filter(policy_key="current").first()
+        payload = s.LeavePolicySerializer(policy, data=request.data, partial=policy is not None)
+        payload.is_valid(raise_exception=True)
+        obj = payload.save(updated_by_user_id=self.actor.user_id)
+        return Response(s.LeavePolicySerializer(obj).data)
+
+
+class HolidayCalendarListView(_LeaveView, generics.ListAPIView):
+    serializer_class = s.HolidayCalendarSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.calendar.view")]
+    def get_queryset(self):
+        return HolidayCalendar.objects.filter(state=HolidayCalendar.State.PUBLISHED).order_by("-year", "-revision")
+
+
+class HolidayCalendarDraftView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.calendar.manage")]
+    def post(self, request):
+        payload = s.HolidayCalendarDraftSerializer(data=request.data)
+        payload.is_valid(raise_exception=True)
+        year, holidays = payload.validated_data["year"], payload.validated_data["holidays"]
+        if not isinstance(holidays, list):
+            raise ValidationError({"holidays": "Must be a list of calendar dates."})
+        for item in holidays:
+            if not isinstance(item, dict) or not item.get("date"):
+                raise ValidationError({"holidays": "Each entry needs a date and description."})
+            try:
+                date.fromisoformat(item["date"])
+            except (TypeError, ValueError) as exc:
+                raise ValidationError({"holidays": "Calendar dates must use YYYY-MM-DD."}) from exc
+        with transaction.atomic():
+            revision = (HolidayCalendar.objects.select_for_update().filter(year=year).order_by("-revision").values_list("revision", flat=True).first() or 0) + 1
+            obj = HolidayCalendar.objects.create(year=year, revision=revision, holidays=holidays)
+        return Response(s.HolidayCalendarSerializer(obj).data, status=status.HTTP_201_CREATED)
+
+
+class HolidayCalendarPublishView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.calendar.manage")]
+    def post(self, request, pk):
+        with transaction.atomic():
+            obj = get_object_or_404(HolidayCalendar.objects.select_for_update(), pk=pk)
+            if obj.state != HolidayCalendar.State.DRAFT:
+                raise ValidationError({"detail": "Only a draft calendar can be published."})
+            HolidayCalendar.objects.filter(year=obj.year, state=HolidayCalendar.State.PUBLISHED).update(state=HolidayCalendar.State.SUPERSEDED)
+            obj.state = HolidayCalendar.State.PUBLISHED
+            obj.published_by_user_id = self.actor.user_id
+            obj.published_at = timezone.now()
+            obj.save(update_fields=["state", "published_by_user_id", "published_at"])
+        return Response(s.HolidayCalendarSerializer(obj).data)
+
+
+class RouteConfigurationListView(_LeaveView, generics.ListCreateAPIView):
+    serializer_class = s.LeaveRouteConfigurationSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.routing.manage")]
+    queryset = LeaveRouteConfiguration.objects.select_related("category").all()
+    def perform_create(self, serializer):
+        serializer.save(updated_by_user_id=self.actor.user_id)
+
+
+class RouteConfigurationDetailView(_LeaveView, generics.RetrieveUpdateAPIView):
+    serializer_class = s.LeaveRouteConfigurationSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.routing.manage")]
+    queryset = LeaveRouteConfiguration.objects.select_related("category").all()
+    def perform_update(self, serializer):
+        serializer.save(updated_by_user_id=self.actor.user_id)
+
+
+class SLAConfigurationListView(_LeaveView, generics.ListCreateAPIView):
+    serializer_class = s.LeaveSLAConfigurationSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.sla.manage")]
+    queryset = LeaveSLAConfiguration.objects.all()
+    def perform_create(self, serializer):
+        serializer.save(updated_by_user_id=self.actor.user_id)
+
+
+class SLAConfigurationDetailView(_LeaveView, generics.RetrieveUpdateAPIView):
+    serializer_class = s.LeaveSLAConfigurationSerializer
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.sla.manage")]
+    queryset = LeaveSLAConfiguration.objects.all()
+    def perform_update(self, serializer):
+        serializer.save(updated_by_user_id=self.actor.user_id)
+
+
+class OfflineLeaveView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.records.manage")]
+    def post(self, request):
+        payload = s.OfflineLeaveInputSerializer(data=request.data)
+        payload.is_valid(raise_exception=True)
+        values = payload.validated_data
+        try:
+            obj = service.record_offline_sanctioned_leave(
+                employee_id=values["employee_id"], category_code=values["category_code"].code,
+                start_date=values["start_date"], end_date=values["end_date"], reason=values["reason"],
+                sanction_reference=values["sanction_reference"], evidence_reference=values["evidence_reference"],
+                actor_user_id=self.actor.user_id,
+            )
+        except (service.LeaveRuleViolation, EmployeeProfile.DoesNotExist, LeaveCategory.DoesNotExist) as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveRequestSerializer(obj).data, status=status.HTTP_201_CREATED)
+
+
+class AccountAdjustmentView(_LeaveView, APIView):
+    permission_classes = [HasModuleGrant("leave_management"), HasPermission("leave_management.records.manage")]
+    def post(self, request):
+        payload = s.AccountAdjustmentInputSerializer(data=request.data)
+        payload.is_valid(raise_exception=True)
+        values = payload.validated_data
+        try:
+            entry = service.record_account_adjustment(
+                employee_id=values["employee_id"], category=values["category_code"], year=values["year"],
+                amount=values["amount"], reference=values["reference"], explanation=values["explanation"],
+                actor_user_id=self.actor.user_id,
+            )
+        except service.LeaveRuleViolation as exc:
+            self.rule_error(exc)
+        return Response(s.LeaveAccountEntrySerializer(entry).data, status=status.HTTP_201_CREATED)
diff --git a/modules/leave/apps.py b/modules/leave/apps.py
new file mode 100644
index 00000000..601ccc9d
--- /dev/null
+++ b/modules/leave/apps.py
@@ -0,0 +1,13 @@
+"""Leave Management Django app configuration.
+
+Follows placement module pattern: AppConfig with ready() for check
+registration. MODULE/NAV_ITEMS with permission filtering.
+"""
+from django.apps import AppConfig
+
+
+class LeaveConfig(AppConfig):
+    """Leave Management app configuration."""
+    name = "modules.leave"
+    label = "leave"
+    verbose_name = "Employee Leave Management"
diff --git a/modules/leave/contracts.py b/modules/leave/contracts.py
new file mode 100644
index 00000000..ee61bc30
--- /dev/null
+++ b/modules/leave/contracts.py
@@ -0,0 +1,61 @@
+"""The stable ELM public surface for other domain modules."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Sequence
+
+
+@dataclass(frozen=True)
+class EmploymentProjection:
+    """HR-owned employee facts used by ELM eligibility and routing."""
+    user_id: int
+    kind: str
+    designation: str
+    unit_code: str
+    unit_head_user_id: int | None
+    is_director: bool = False
+    active: bool = True
+
+
+@dataclass(frozen=True)
+class VacationPeriodProjection:
+    """Academic Calendar vacation interval supplied to ELM."""
+    external_id: str
+    label: str
+    start_date: date
+    end_date: date
+    academic_year: str
+
+
+@dataclass(frozen=True)
+class ProjectionSyncResult:
+    employees_written: int = 0
+    vacation_periods_written: int = 0
+
+
+@dataclass(frozen=True)
+class LeaveBalanceDTO:
+    employee_id: int
+    category_code: str
+    year: int
+    entitlement: Decimal
+    carried_over: Decimal
+    available: Decimal
+
+
+@dataclass(frozen=True)
+class LeaveAccountEntryDTO:
+    employee_id: int
+    category_code: str
+    year: int
+    amount: Decimal
+    kind: str
+    source_key: str
+    created_at: datetime
+
+
+@dataclass(frozen=True)
+class EmploymentQuery:
+    user_ids: Sequence[int]
diff --git a/modules/leave/domain/eligibility.py b/modules/leave/domain/eligibility.py
new file mode 100644
index 00000000..71d74cde
--- /dev/null
+++ b/modules/leave/domain/eligibility.py
@@ -0,0 +1,54 @@
+"""Entitlement and year-end account rules from the synchronized ELM baseline."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal, ROUND_DOWN
+
+
+@dataclass(frozen=True)
+class YearEndEntry:
+    category: str
+    amount: Decimal
+    kind: str
+    explanation: str
+
+
+def annual_entitlement(category: str, employee_kind: str, policy) -> Decimal:
+    """Return configured annual credit for an employee and category."""
+    if category == "CL":
+        return Decimal(policy.cl_days)
+    if category == "RH":
+        return Decimal(policy.rh_days)
+    if category == "SCL":
+        return Decimal(policy.scl_days)
+    if category == "EL" and employee_kind == "staff":
+        return Decimal(policy.nonfaculty_el_days)
+    if category == "VL" and employee_kind == "faculty":
+        return Decimal(policy.faculty_vl_days)
+    if category == "COL":
+        return Decimal(policy.col_days)
+    return Decimal("0")
+
+
+def year_end_entries(*, cl: Decimal, rh: Decimal, scl: Decimal, el: Decimal,
+                     col: Decimal, vl: Decimal, employee_kind: str) -> list[YearEndEntry]:
+    """Create idempotently-keyable year-end account movements.
+
+    CL/RH/SCL/VL unused amounts lapse. EL and COL carry forward. Faculty VL is
+    converted at exactly 2 VL : 1 EL, preserving fractional EL credit.
+    """
+    entries: list[YearEndEntry] = []
+    if el > 0:
+        entries.append(YearEndEntry("EL", el, "carry_forward", "Unused EL carried forward"))
+    if col > 0:
+        entries.append(YearEndEntry("COL", col, "carry_forward", "Unused COL carried forward"))
+    if employee_kind == "faculty" and vl > 0:
+        converted = (vl / Decimal("2")).quantize(Decimal("0.01"), rounding=ROUND_DOWN)
+        if converted:
+            entries.append(YearEndEntry("EL", converted, "vl_conversion", "Unused VL converted at 2:1"))
+    return entries
+
+
+def resumption_adjustment(approved_days: Decimal, actual_days: Decimal) -> Decimal:
+    """Balance credit/debit on reviewed early or late resumption."""
+    return approved_days - actual_days
diff --git a/modules/leave/domain/state_machine.py b/modules/leave/domain/state_machine.py
new file mode 100644
index 00000000..86273577
--- /dev/null
+++ b/modules/leave/domain/state_machine.py
@@ -0,0 +1,77 @@
+"""ELM workflow transition policy; persistence and authorization live in services."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+import re
+
+
+class TransitionError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class RouteStep:
+    role: str
+    decision_kind: str
+
+
+def normalize_role(role: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "_", role.casefold()).strip("_")
+
+
+def route_for(*, category: str, is_director: bool, establishment_role: str | None,
+              final_authority_role: str | None) -> tuple[RouteStep, ...]:
+    """Resolve the current configured route shape, leaving user assignment to IAM/HR."""
+    if is_director:
+        return (RouteStep("director", "final"),)
+    if category in {"CL", "RH"}:
+        return (RouteStep("unit_head", "final"),)
+    if not final_authority_role:
+        raise TransitionError("No final sanctioning authority is configured")
+    steps = [RouteStep("unit_head", "recommendation")]
+    if establishment_role:
+        steps.append(RouteStep("establishment", "forward"))
+    steps.append(RouteStep(normalize_role(final_authority_role), "final"))
+    return tuple(steps)
+
+
+def after_substitute_response(*, accepted: bool, declined_before: int,
+                              replacement_limit: int = 1) -> str:
+    """Return next state while enforcing the specified replacement traversal."""
+    if accepted:
+        return "pending_unit_head"
+    if declined_before >= replacement_limit:
+        return "applicant_action"
+    return "applicant_action"
+
+
+def validate_withdrawal(status: str) -> None:
+    if status not in {"awaiting_substitute", "applicant_action", "pending_unit_head",
+                      "pending_establishment", "pending_authority"}:
+        raise TransitionError("Only a pending request can be withdrawn")
+
+
+def validate_cancellation(*, status: str, start_date: date, today: date) -> None:
+    if status != "approved":
+        raise TransitionError("Only approved leave can be cancelled")
+    if start_date <= today:
+        raise TransitionError("Approved leave can only be cancelled before its start date")
+
+
+def validate_extension(*, category: str, status: str, start_date: date, end_date: date,
+                       new_end_date: date, today: date) -> None:
+    if category not in {"EL", "COL", "VL"}:
+        raise TransitionError("Only EL, COL, or VL may be extended")
+    if status != "approved" or not (start_date <= today <= end_date):
+        raise TransitionError("An extension is allowed only while approved leave is ongoing")
+    if new_end_date <= end_date:
+        raise TransitionError("An extension must add at least one day")
+
+
+def resumption_outcome(*, approved_end_date: date, actual_resume_date: date) -> str:
+    if actual_resume_date < approved_end_date:
+        return "early"
+    if actual_resume_date > approved_end_date:
+        return "late"
+    return "normal"
diff --git a/modules/leave/domain/validation.py b/modules/leave/domain/validation.py
new file mode 100644
index 00000000..1dab598e
--- /dev/null
+++ b/modules/leave/domain/validation.py
@@ -0,0 +1,114 @@
+"""Deterministic ELM counting and application validation rules."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from decimal import Decimal
+from typing import Iterable
+
+
+CONTINUOUS_CATEGORIES = frozenset({"EL", "COL", "VL"})
+SUPPORTED_CATEGORIES = frozenset({"CL", "RH", "SCL", "EL", "COL", "VL"})
+
+
+@dataclass(frozen=True)
+class ValidationResult:
+    errors: tuple[str, ...] = ()
+    warnings: tuple[str, ...] = ()
+
+    @property
+    def is_valid(self) -> bool:
+        return not self.errors
+
+
+def dates_inclusive(start: date, end: date) -> Iterable[date]:
+    day = start
+    while day <= end:
+        yield day
+        day += timedelta(days=1)
+
+
+def calculate_duration(
+    category: str, start: date, end: date, *, cl_portion: str = "full",
+    holidays: Iterable[date] = (), rh_dates: Iterable[date] = (),
+) -> Decimal:
+    """Count ELM leave days, including half-day CL and category calendars."""
+    if end < start:
+        raise ValueError("end_date must be on or after start_date")
+    if category not in SUPPORTED_CATEGORIES:
+        raise ValueError(f"Unsupported leave category: {category}")
+    holiday_set, rh_set = set(holidays), set(rh_dates)
+    days = tuple(dates_inclusive(start, end))
+    if category in CONTINUOUS_CATEGORIES:
+        return Decimal(len(days))
+    if category == "RH":
+        if len(days) != 1 or start not in rh_set:
+            raise ValueError("RH must be a date in the effective published RH calendar")
+        return Decimal("1")
+    if category == "CL":
+        if cl_portion not in {"full", "first_half", "second_half"}:
+            raise ValueError("Invalid CL portion")
+        if cl_portion != "full" and len(days) != 1:
+            raise ValueError("Half-day CL must cover one date")
+        units = sum(day.weekday() < 5 and day not in holiday_set for day in days)
+        amount = Decimal(units)
+        return amount / 2 if cl_portion != "full" else amount
+    # SCL follows the institute's working-day calendar; no separate
+    # encoded purpose-admissibility or employee-kind rule exists in baseline.
+    return Decimal(sum(day.weekday() < 5 and day not in holiday_set for day in days))
+
+
+def validate_application(
+    *, category: str, start: date, end: date, employee_kind: str,
+    cl_portion: str = "full", station_leave: bool = False,
+    station_destination: str = "", station_departure_at=None,
+    station_return_at=None, holidays: Iterable[date] = (),
+    rh_dates: Iterable[date] = (), available: Decimal | None = None,
+    overlapping: Iterable[tuple[date, date, str, str]] = (),
+    medical_evidence_ref: str = "", medical_required: bool = False,
+    vacation_periods: Iterable[tuple[date, date]] = (),
+) -> ValidationResult:
+    """Validate eligibility, calendar, overlap, evidence, and balance."""
+    errors: list[str] = []
+    warnings: list[str] = []
+    if category not in SUPPORTED_CATEGORIES:
+        errors.append("Unsupported leave category")
+    if end < start:
+        errors.append("End date must be on or after start date")
+    if employee_kind not in {"faculty", "staff"}:
+        errors.append("ELM is available to Faculty and Staff employees only")
+    if category == "EL" and employee_kind == "faculty":
+        errors.append("EL entitlement is assigned to non-faculty employees")
+    if category == "VL":
+        if employee_kind != "faculty":
+            errors.append("VL is available to faculty only")
+        elif not any(start >= lo and end <= hi for lo, hi in vacation_periods):
+            errors.append("VL dates must fall inside an Academic Calendar vacation period")
+    if station_leave and (not station_destination.strip() or not station_departure_at or not station_return_at):
+        errors.append("Station Leave requires destination, departure, and return details")
+    if station_leave and station_return_at and station_departure_at and station_return_at <= station_departure_at:
+        errors.append("Station Leave return must be after departure")
+    if category == "COL" and medical_required and not medical_evidence_ref.strip():
+        errors.append("Medical evidence is required for this COL request")
+    if start <= end and category in SUPPORTED_CATEGORIES:
+        try:
+            requested = calculate_duration(category, start, end, cl_portion=cl_portion, holidays=holidays, rh_dates=rh_dates)
+        except ValueError as exc:
+            errors.append(str(exc))
+        else:
+            if requested <= 0:
+                errors.append("The requested period contains no chargeable leave days")
+            if available is not None and requested > available:
+                errors.append(f"Insufficient balance: {available} available, {requested} requested")
+            for prior_start, prior_end, prior_category, prior_portion in overlapping:
+                is_other_half = (
+                    category == prior_category == "CL"
+                    and start == end == prior_start == prior_end
+                    and cl_portion in {"first_half", "second_half"}
+                    and prior_portion in {"first_half", "second_half"}
+                    and cl_portion != prior_portion
+                )
+                if not is_other_half and prior_start <= end and prior_end >= start:
+                    errors.append(f"Request overlaps active {prior_category} leave from {prior_start} to {prior_end}")
+                    break
+    return ValidationResult(tuple(dict.fromkeys(errors)), tuple(warnings))
diff --git a/modules/leave/management/__init__.py b/modules/leave/management/__init__.py
new file mode 100644
index 00000000..e859f8a3
--- /dev/null
+++ b/modules/leave/management/__init__.py
@@ -0,0 +1 @@
+"""Leave domain management commands."""
diff --git a/modules/leave/management/commands/__init__.py b/modules/leave/management/commands/__init__.py
new file mode 100644
index 00000000..e1057ab3
--- /dev/null
+++ b/modules/leave/management/commands/__init__.py
@@ -0,0 +1 @@
+"""Operational commands for the Leave module."""
diff --git a/modules/leave/management/commands/process_leave_year_end.py b/modules/leave/management/commands/process_leave_year_end.py
new file mode 100644
index 00000000..3e65a056
--- /dev/null
+++ b/modules/leave/management/commands/process_leave_year_end.py
@@ -0,0 +1,19 @@
+from django.core.management.base import BaseCommand, CommandError
+
+from modules.leave.services.accounting import process_year_end
+
+
+class Command(BaseCommand):
+    help = "Close and carry forward Employee Leave Management accounts for a year."
+
+    def add_arguments(self, parser):
+        parser.add_argument("year", type=int, help="Leave year being closed")
+
+    def handle(self, *args, **options):
+        try:
+            result = process_year_end(options["year"])
+        except Exception as exc:
+            raise CommandError(str(exc)) from exc
+        self.stdout.write(self.style.SUCCESS(
+            "Year-end completed: " + ", ".join(f"{key}={value}" for key, value in result.items())
+        ))
diff --git a/modules/leave/migrations/0001_initial.py b/modules/leave/migrations/0001_initial.py
new file mode 100644
index 00000000..9ce5b0f3
--- /dev/null
+++ b/modules/leave/migrations/0001_initial.py
@@ -0,0 +1,186 @@
+# Initial schema for the Employee Leave Management baseline.
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+def seed_categories(apps, schema_editor):
+    Category = apps.get_model("leave", "LeaveCategory")
+    for code, label in (("CL", "Casual Leave"), ("RH", "Restricted Holiday"),
+                        ("SCL", "Special Casual Leave"), ("EL", "Earned Leave"),
+                        ("COL", "Commuted Leave"), ("VL", "Vacation Leave")):
+        Category.objects.get_or_create(code=code, defaults={"label": label, "description": ""})
+    Policy = apps.get_model("leave", "LeavePolicy")
+    Policy.objects.get_or_create(policy_key="current")
+
+
+class Migration(migrations.Migration):
+    initial = True
+    dependencies = []
+    operations = [
+        migrations.CreateModel(
+            name="EmployeeProfile",
+            fields=[
+                ("user_id", models.PositiveBigIntegerField(primary_key=True, serialize=False)),
+                ("kind", models.CharField(choices=[("faculty", "Faculty"), ("staff", "Staff")], max_length=8)),
+                ("designation", models.CharField(max_length=120)),
+                ("unit_code", models.CharField(db_index=True, max_length=64)),
+                ("unit_head_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("is_director", models.BooleanField(default=False)),
+                ("active", models.BooleanField(default=True)),
+                ("synced_at", models.DateTimeField()),
+            ], options={"db_table": "leave_employee_profile"}),
+        migrations.CreateModel(
+            name="LeaveCategory",
+            fields=[("code", models.CharField(max_length=3, primary_key=True, serialize=False)),
+                    ("label", models.CharField(max_length=64)), ("description", models.TextField(blank=True))],
+            options={"db_table": "leave_category", "ordering": ["code"]}),
+        migrations.CreateModel(
+            name="LeavePolicy",
+            fields=[
+                ("policy_key", models.CharField(default="current", editable=False, max_length=16, primary_key=True, serialize=False)),
+                ("cl_days", models.DecimalField(decimal_places=2, default=8, max_digits=6)),
+                ("rh_days", models.DecimalField(decimal_places=2, default=2, max_digits=6)),
+                ("scl_days", models.DecimalField(decimal_places=2, default=15, max_digits=6)),
+                ("faculty_vl_days", models.DecimalField(decimal_places=2, default=60, max_digits=6)),
+                ("nonfaculty_el_days", models.DecimalField(decimal_places=2, default=30, max_digits=6)),
+                ("col_days", models.DecimalField(decimal_places=2, default=20, max_digits=6)),
+                ("col_medical_evidence_required", models.BooleanField(default=False)),
+                ("year_end_month", models.PositiveSmallIntegerField(default=12)),
+                ("year_end_day", models.PositiveSmallIntegerField(default=31)),
+                ("updated_by_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ], options={"db_table": "leave_policy"}),
+        migrations.CreateModel(
+            name="LeaveBalance",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("employee_id", models.PositiveBigIntegerField(db_index=True)), ("year", models.PositiveSmallIntegerField()),
+                ("entitlement", models.DecimalField(decimal_places=2, default=0, max_digits=8)),
+                ("carried_over", models.DecimalField(decimal_places=2, default=0, max_digits=8)),
+                ("available", models.DecimalField(decimal_places=2, default=0, max_digits=8)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("category", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="balances", to="leave.leavecategory")),
+            ], options={"db_table": "leave_balance", "constraints": [models.UniqueConstraint(fields=("employee_id", "category", "year"), name="leave_balance_employee_category_year_uniq")], "indexes": [models.Index(fields=["employee_id", "year"], name="leave_balance_employee_year_idx")]}),
+        migrations.CreateModel(
+            name="HolidayCalendar",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("year", models.PositiveSmallIntegerField()), ("revision", models.PositiveSmallIntegerField(default=1)),
+                ("holidays", models.JSONField(default=list)),
+                ("state", models.CharField(choices=[("draft", "Draft"), ("published", "Published"), ("superseded", "Superseded")], default="draft", max_length=12)),
+                ("published_by_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("published_at", models.DateTimeField(blank=True, null=True)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+            ], options={"db_table": "leave_holiday_calendar", "constraints": [models.UniqueConstraint(fields=("year", "revision"), name="leave_calendar_year_revision_uniq")], "indexes": [models.Index(fields=["year", "state"], name="leave_calendar_year_state_idx")]}),
+        migrations.CreateModel(
+            name="LeaveSLAConfiguration",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("role", models.CharField(max_length=64, unique=True)), ("reminder_after_hours", models.PositiveIntegerField(default=24)),
+                ("escalate_after_hours", models.PositiveIntegerField(default=72)), ("escalation_role", models.CharField(blank=True, max_length=64)),
+                ("escalation_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("updated_by_user_id", models.PositiveBigIntegerField(blank=True, null=True)), ("updated_at", models.DateTimeField(auto_now=True)),
+            ], options={"db_table": "leave_sla_configuration"}),
+        migrations.CreateModel(
+            name="VacationPeriod",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("external_id", models.CharField(max_length=120, unique=True)), ("label", models.CharField(max_length=120)),
+                ("start_date", models.DateField()), ("end_date", models.DateField()), ("academic_year", models.CharField(db_index=True, max_length=16)),
+                ("synced_at", models.DateTimeField()),
+            ], options={"db_table": "leave_vacation_period", "constraints": [models.CheckConstraint(condition=models.Q(("end_date__gte", models.F("start_date"))), name="leave_vacation_valid_date_range")]}),
+        migrations.CreateModel(
+            name="LeaveRequest",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("employee_id", models.PositiveBigIntegerField(db_index=True)), ("request_type", models.CharField(choices=[("new", "New leave"), ("cancellation", "Cancellation"), ("extension", "Extension"), ("resumption", "Resumption"), ("offline", "Offline sanctioned entry")], default="new", max_length=16)),
+                ("status", models.CharField(choices=[("draft", "Draft"), ("awaiting_substitute", "Awaiting substitute"), ("applicant_action", "Applicant action required"), ("pending_unit_head", "Pending Unit Head"), ("pending_establishment", "Pending Establishment"), ("pending_authority", "Pending authority"), ("approved", "Approved"), ("rejected", "Rejected"), ("withdrawn", "Withdrawn"), ("cancelled", "Cancelled"), ("completed", "Completed")], db_index=True, default="draft", max_length=32)),
+                ("start_date", models.DateField()), ("end_date", models.DateField()), ("duration_days", models.DecimalField(decimal_places=2, max_digits=7)),
+                ("cl_portion", models.CharField(choices=[("full", "Full day"), ("first_half", "First half"), ("second_half", "Second half")], default="full", max_length=16)),
+                ("reason", models.TextField()), ("station_leave", models.BooleanField(default=False)),
+                ("station_destination", models.CharField(blank=True, max_length=240)), ("station_departure_at", models.DateTimeField(blank=True, null=True)),
+                ("station_return_at", models.DateTimeField(blank=True, null=True)), ("medical_evidence_ref", models.CharField(blank=True, max_length=500)),
+                ("substitute_user_id", models.PositiveBigIntegerField(blank=True, null=True)), ("actual_resume_date", models.DateField(blank=True, null=True)),
+                ("offline_sanction_ref", models.CharField(blank=True, max_length=240)), ("offline_evidence_ref", models.CharField(blank=True, max_length=500)),
+                ("submitted_at", models.DateTimeField(blank=True, null=True)), ("decided_at", models.DateTimeField(blank=True, null=True)),
+                ("created_at", models.DateTimeField(auto_now_add=True)), ("updated_at", models.DateTimeField(auto_now=True)),
+                ("category", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="requests", to="leave.leavecategory")),
+                ("parent_request", models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name="follow_ups", to="leave.leaverequest")),
+            ], options={"db_table": "leave_request", "ordering": ["-created_at", "-id"], "indexes": [models.Index(fields=["employee_id", "status"], name="leave_request_employee_status_idx"), models.Index(fields=["start_date", "end_date", "status"], name="leave_request_period_status_idx")], "constraints": [models.CheckConstraint(condition=models.Q(("end_date__gte", models.F("start_date"))), name="leave_request_valid_date_range")]}),
+        migrations.CreateModel(
+            name="LeaveAccountEntry",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("employee_id", models.PositiveBigIntegerField(db_index=True)), ("year", models.PositiveSmallIntegerField()),
+                ("amount", models.DecimalField(decimal_places=2, max_digits=8)),
+                ("kind", models.CharField(choices=[("entitlement", "Entitlement"), ("carry_forward", "Carry forward"), ("leave_used", "Leave used"), ("cancellation_reversal", "Cancellation reversal"), ("vl_conversion", "VL to EL conversion"), ("resumption_adjustment", "Resumption adjustment"), ("offline_adjustment", "Offline adjustment"), ("year_end_lapse", "Year-end lapse")], max_length=32)),
+                ("source_key", models.CharField(max_length=120, unique=True)), ("actor_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("explanation", models.CharField(blank=True, max_length=240)), ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("category", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="entries", to="leave.leavecategory")),
+                ("request", models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name="account_entries", to="leave.leaverequest")),
+            ], options={"db_table": "leave_account_entry", "ordering": ["created_at", "id"], "indexes": [models.Index(fields=["employee_id", "category", "year"], name="leave_entry_account_idx")]}),
+        migrations.CreateModel(
+            name="LeaveAuditEvent",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("action", models.CharField(max_length=48)), ("from_status", models.CharField(blank=True, max_length=32)),
+                ("to_status", models.CharField(blank=True, max_length=32)), ("actor_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("occurred_at", models.DateTimeField(auto_now_add=True)), ("details", models.JSONField(blank=True, default=dict)),
+                ("request", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="audit_events", to="leave.leaverequest")),
+            ], options={"db_table": "leave_audit_event", "ordering": ["occurred_at", "id"]}),
+        migrations.CreateModel(
+            name="LeaveRouteConfiguration",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("employee_kind", models.CharField(choices=[("faculty", "Faculty"), ("staff", "Staff")], max_length=8)),
+                ("designation", models.CharField(blank=True, max_length=120)), ("unit_code", models.CharField(blank=True, max_length=64)),
+                ("final_authority_role", models.CharField(max_length=64)), ("final_authority_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("establishment_role", models.CharField(blank=True, max_length=64)), ("establishment_user_id", models.PositiveBigIntegerField(blank=True, null=True)),
+                ("requires_substitute", models.BooleanField(default=False)), ("active", models.BooleanField(default=True)),
+                ("updated_by_user_id", models.PositiveBigIntegerField(blank=True, null=True)), ("updated_at", models.DateTimeField(auto_now=True)),
+                ("category", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name="routes", to="leave.leavecategory")),
+            ], options={"db_table": "leave_route_configuration", "indexes": [models.Index(fields=["category", "employee_kind", "active"], name="leave_route_lookup_idx")]}),
+        migrations.CreateModel(
+            name="WorkflowTask",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("sequence", models.PositiveSmallIntegerField()), ("role", models.CharField(max_length=64)),
+                ("decision_kind", models.CharField(choices=[("final", "Final decision"), ("recommendation", "Recommendation"), ("forward", "Forward")], max_length=20)),
+                ("assigned_user_id", models.PositiveBigIntegerField(blank=True, db_index=True, null=True)),
+                ("state", models.CharField(choices=[("queued", "Queued"), ("pending", "Pending"), ("completed", "Completed"), ("cancelled", "Cancelled")], db_index=True, default="pending", max_length=12)),
+                ("activated_at", models.DateTimeField(blank=True, null=True)),
+                ("due_at", models.DateTimeField(blank=True, null=True)), ("reminder_sent_at", models.DateTimeField(blank=True, null=True)),
+                ("escalated_at", models.DateTimeField(blank=True, null=True)), ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("request", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="tasks", to="leave.leaverequest")),
+            ], options={"db_table": "leave_workflow_task", "ordering": ["sequence", "id"], "constraints": [models.UniqueConstraint(fields=("request", "sequence"), name="leave_workflow_request_sequence_uniq")], "indexes": [models.Index(fields=["state", "due_at"], name="leave_task_state_due_idx")]}),
+        migrations.CreateModel(
+            name="LeaveSanction",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("actor_user_id", models.PositiveBigIntegerField()), ("decision", models.CharField(choices=[("recommended", "Recommended"), ("not_recommended", "Not recommended"), ("approved", "Approved"), ("rejected", "Rejected"), ("forwarded", "Forwarded")], max_length=20)),
+                ("notes", models.TextField(blank=True)), ("decided_at", models.DateTimeField(auto_now_add=True)),
+                ("task", models.OneToOneField(on_delete=django.db.models.deletion.PROTECT, related_name="sanction", to="leave.workflowtask")),
+            ], options={"db_table": "leave_sanction", "ordering": ["decided_at"]}),
+        migrations.CreateModel(
+            name="SubstituteResponse",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("substitute_user_id", models.PositiveBigIntegerField()), ("decision", models.CharField(choices=[("accepted", "Accepted"), ("declined", "Declined")], max_length=12)),
+                ("responded_at", models.DateTimeField(auto_now_add=True)),
+                ("request", models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name="substitute_responses", to="leave.leaverequest")),
+            ], options={"db_table": "leave_substitute_response", "ordering": ["-responded_at"]}),
+        migrations.CreateModel(
+            name="LeaveNotificationOutbox",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("dedupe_key", models.CharField(max_length=160, unique=True)), ("recipient_user_id", models.PositiveBigIntegerField(db_index=True)),
+                ("subject", models.CharField(max_length=200)), ("body", models.TextField()),
+                ("payload", models.JSONField(blank=True, default=dict)),
+                ("state", models.CharField(choices=[("pending", "Pending"), ("sending", "Sending"), ("sent", "Sent"), ("failed", "Failed")], db_index=True, default="pending", max_length=12)),
+                ("attempts", models.PositiveSmallIntegerField(default=0)), ("last_error", models.CharField(blank=True, max_length=300)),
+                ("claimed_at", models.DateTimeField(blank=True, null=True)),
+                ("sent_at", models.DateTimeField(blank=True, null=True)), ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ], options={"db_table": "leave_notification_outbox", "indexes": [models.Index(fields=["state", "created_at"], name="leave_notify_state_created_idx")]}),
+        migrations.RunPython(seed_categories, migrations.RunPython.noop),
+    ]
diff --git a/modules/leave/migrations/__init__.py b/modules/leave/migrations/__init__.py
new file mode 100644
index 00000000..d516bc50
--- /dev/null
+++ b/modules/leave/migrations/__init__.py
@@ -0,0 +1 @@
+"""Schema migrations for Employee Leave Management."""
diff --git a/modules/leave/models.py b/modules/leave/models.py
new file mode 100644
index 00000000..c844b9b6
--- /dev/null
+++ b/modules/leave/models.py
@@ -0,0 +1,322 @@
+"""Persistence for the Employee Leave Management domain.
+
+Employee identities are local IAM references (integer IDs), never cross-module
+foreign keys. Balances are projections of an immutable account ledger.
+"""
+from django.db import models
+from django.db.models import Q
+
+
+class EmployeeProfile(models.Model):
+    """Current employee facts and routing context projected from HR/IAM."""
+
+    class Kind(models.TextChoices):
+        FACULTY = "faculty", "Faculty"
+        STAFF = "staff", "Staff"
+
+    user_id = models.PositiveBigIntegerField(primary_key=True)
+    kind = models.CharField(max_length=8, choices=Kind.choices)
+    designation = models.CharField(max_length=120)
+    unit_code = models.CharField(max_length=64, db_index=True)
+    unit_head_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    is_director = models.BooleanField(default=False)
+    active = models.BooleanField(default=True)
+    synced_at = models.DateTimeField()
+
+    class Meta:
+        db_table = "leave_employee_profile"
+
+
+class LeaveCategory(models.Model):
+    code = models.CharField(max_length=3, primary_key=True)
+    label = models.CharField(max_length=64)
+    description = models.TextField(blank=True)
+    class Meta:
+        db_table = "leave_category"
+        ordering = ["code"]
+
+
+class LeavePolicy(models.Model):
+    """Current configurable parameters; policy versions are not part of ELM."""
+
+    policy_key = models.CharField(max_length=16, primary_key=True, default="current", editable=False)
+    cl_days = models.DecimalField(max_digits=6, decimal_places=2, default=8)
+    rh_days = models.DecimalField(max_digits=6, decimal_places=2, default=2)
+    scl_days = models.DecimalField(max_digits=6, decimal_places=2, default=15)
+    faculty_vl_days = models.DecimalField(max_digits=6, decimal_places=2, default=60)
+    nonfaculty_el_days = models.DecimalField(max_digits=6, decimal_places=2, default=30)
+    col_days = models.DecimalField(max_digits=6, decimal_places=2, default=20)
+    col_medical_evidence_required = models.BooleanField(default=False)
+    year_end_month = models.PositiveSmallIntegerField(default=12)
+    year_end_day = models.PositiveSmallIntegerField(default=31)
+    updated_by_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        db_table = "leave_policy"
+
+
+class LeaveBalance(models.Model):
+    """Materialized balance, reconciled to its immutable ledger entries."""
+
+    employee_id = models.PositiveBigIntegerField(db_index=True)
+    category = models.ForeignKey(LeaveCategory, on_delete=models.PROTECT, related_name="balances")
+    year = models.PositiveSmallIntegerField()
+    entitlement = models.DecimalField(max_digits=8, decimal_places=2, default=0)
+    carried_over = models.DecimalField(max_digits=8, decimal_places=2, default=0)
+    available = models.DecimalField(max_digits=8, decimal_places=2, default=0)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        db_table = "leave_balance"
+        constraints = [models.UniqueConstraint(fields=["employee_id", "category", "year"], name="leave_balance_employee_category_year_uniq")]
+        indexes = [models.Index(fields=["employee_id", "year"], name="leave_balance_employee_year_idx")]
+
+
+class LeaveRequest(models.Model):
+    """Immutable-after-submission request; follow-on actions are separate records."""
+
+    class Type(models.TextChoices):
+        NEW = "new", "New leave"
+        CANCELLATION = "cancellation", "Cancellation"
+        EXTENSION = "extension", "Extension"
+        RESUMPTION = "resumption", "Resumption"
+        OFFLINE = "offline", "Offline sanctioned entry"
+
+    class Status(models.TextChoices):
+        DRAFT = "draft", "Draft"
+        AWAITING_SUBSTITUTE = "awaiting_substitute", "Awaiting substitute"
+        APPLICANT_ACTION = "applicant_action", "Applicant action required"
+        PENDING_UNIT_HEAD = "pending_unit_head", "Pending Unit Head"
+        PENDING_ESTABLISHMENT = "pending_establishment", "Pending Establishment"
+        PENDING_AUTHORITY = "pending_authority", "Pending authority"
+        APPROVED = "approved", "Approved"
+        REJECTED = "rejected", "Rejected"
+        WITHDRAWN = "withdrawn", "Withdrawn"
+        CANCELLED = "cancelled", "Cancelled"
+        COMPLETED = "completed", "Completed"
+
+    class CLPortion(models.TextChoices):
+        FULL = "full", "Full day"
+        FIRST_HALF = "first_half", "First half"
+        SECOND_HALF = "second_half", "Second half"
+
+    employee_id = models.PositiveBigIntegerField(db_index=True)
+    category = models.ForeignKey(LeaveCategory, on_delete=models.PROTECT, related_name="requests")
+    request_type = models.CharField(max_length=16, choices=Type.choices, default=Type.NEW)
+    parent_request = models.ForeignKey("self", null=True, blank=True, on_delete=models.PROTECT, related_name="follow_ups")
+    status = models.CharField(max_length=32, choices=Status.choices, default=Status.DRAFT, db_index=True)
+    start_date = models.DateField()
+    end_date = models.DateField()
+    duration_days = models.DecimalField(max_digits=7, decimal_places=2)
+    cl_portion = models.CharField(max_length=16, choices=CLPortion.choices, default=CLPortion.FULL)
+    reason = models.TextField()
+    station_leave = models.BooleanField(default=False)
+    station_destination = models.CharField(max_length=240, blank=True)
+    station_departure_at = models.DateTimeField(null=True, blank=True)
+    station_return_at = models.DateTimeField(null=True, blank=True)
+    medical_evidence_ref = models.CharField(max_length=500, blank=True)
+    substitute_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    actual_resume_date = models.DateField(null=True, blank=True)
+    offline_sanction_ref = models.CharField(max_length=240, blank=True)
+    offline_evidence_ref = models.CharField(max_length=500, blank=True)
+    submitted_at = models.DateTimeField(null=True, blank=True)
+    decided_at = models.DateTimeField(null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        db_table = "leave_request"
+        ordering = ["-created_at", "-id"]
+        indexes = [models.Index(fields=["employee_id", "status"], name="leave_request_employee_status_idx"), models.Index(fields=["start_date", "end_date", "status"], name="leave_request_period_status_idx")]
+        constraints = [models.CheckConstraint(condition=Q(end_date__gte=models.F("start_date")), name="leave_request_valid_date_range")]
+
+
+class SubstituteResponse(models.Model):
+    class Decision(models.TextChoices):
+        ACCEPTED = "accepted", "Accepted"
+        DECLINED = "declined", "Declined"
+
+    request = models.ForeignKey(LeaveRequest, on_delete=models.PROTECT, related_name="substitute_responses")
+    substitute_user_id = models.PositiveBigIntegerField()
+    decision = models.CharField(max_length=12, choices=Decision.choices)
+    responded_at = models.DateTimeField(auto_now_add=True)
+    class Meta:
+        db_table = "leave_substitute_response"
+        ordering = ["-responded_at"]
+
+
+class WorkflowTask(models.Model):
+    """Assigned decision/review step; each response is recorded as a sanction."""
+
+    class State(models.TextChoices):
+        QUEUED = "queued", "Queued"
+        PENDING = "pending", "Pending"
+        COMPLETED = "completed", "Completed"
+        CANCELLED = "cancelled", "Cancelled"
+
+    request = models.ForeignKey(LeaveRequest, on_delete=models.PROTECT, related_name="tasks")
+    sequence = models.PositiveSmallIntegerField()
+    role = models.CharField(max_length=64)
+    decision_kind = models.CharField(max_length=20, choices=[("final", "Final decision"), ("recommendation", "Recommendation"), ("forward", "Forward")])
+    assigned_user_id = models.PositiveBigIntegerField(null=True, blank=True, db_index=True)
+    state = models.CharField(max_length=12, choices=State.choices, default=State.PENDING, db_index=True)
+    activated_at = models.DateTimeField(null=True, blank=True)
+    due_at = models.DateTimeField(null=True, blank=True)
+    reminder_sent_at = models.DateTimeField(null=True, blank=True)
+    escalated_at = models.DateTimeField(null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    class Meta:
+        db_table = "leave_workflow_task"
+        ordering = ["sequence", "id"]
+        constraints = [models.UniqueConstraint(fields=["request", "sequence"], name="leave_workflow_request_sequence_uniq")]
+        indexes = [models.Index(fields=["state", "due_at"], name="leave_task_state_due_idx")]
+
+
+class LeaveSanction(models.Model):
+    class Decision(models.TextChoices):
+        RECOMMENDED = "recommended", "Recommended"
+        NOT_RECOMMENDED = "not_recommended", "Not recommended"
+        APPROVED = "approved", "Approved"
+        REJECTED = "rejected", "Rejected"
+        FORWARDED = "forwarded", "Forwarded"
+
+    task = models.OneToOneField(WorkflowTask, on_delete=models.PROTECT, related_name="sanction")
+    actor_user_id = models.PositiveBigIntegerField()
+    decision = models.CharField(max_length=20, choices=Decision.choices)
+    notes = models.TextField(blank=True)
+    decided_at = models.DateTimeField(auto_now_add=True)
+    class Meta:
+        db_table = "leave_sanction"
+        ordering = ["decided_at"]
+
+
+class LeaveAccountEntry(models.Model):
+    """Append-only credits/debits; positive amounts credit, negative debit."""
+
+    class Kind(models.TextChoices):
+        ENTITLEMENT = "entitlement", "Entitlement"
+        CARRY_FORWARD = "carry_forward", "Carry forward"
+        LEAVE_USED = "leave_used", "Leave used"
+        CANCELLATION_REVERSAL = "cancellation_reversal", "Cancellation reversal"
+        VL_CONVERSION = "vl_conversion", "VL to EL conversion"
+        RESUMPTION_ADJUSTMENT = "resumption_adjustment", "Resumption adjustment"
+        OFFLINE_ADJUSTMENT = "offline_adjustment", "Offline adjustment"
+        YEAR_END_LAPSE = "year_end_lapse", "Year-end lapse"
+
+    employee_id = models.PositiveBigIntegerField(db_index=True)
+    category = models.ForeignKey(LeaveCategory, on_delete=models.PROTECT, related_name="entries")
+    year = models.PositiveSmallIntegerField()
+    amount = models.DecimalField(max_digits=8, decimal_places=2)
+    kind = models.CharField(max_length=32, choices=Kind.choices)
+    request = models.ForeignKey(LeaveRequest, null=True, blank=True, on_delete=models.PROTECT, related_name="account_entries")
+    source_key = models.CharField(max_length=120, unique=True)
+    actor_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    explanation = models.CharField(max_length=240, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    class Meta:
+        db_table = "leave_account_entry"
+        ordering = ["created_at", "id"]
+        indexes = [models.Index(fields=["employee_id", "category", "year"], name="leave_entry_account_idx")]
+
+
+class HolidayCalendar(models.Model):
+    class State(models.TextChoices):
+        DRAFT = "draft", "Draft"
+        PUBLISHED = "published", "Published"
+        SUPERSEDED = "superseded", "Superseded"
+
+    year = models.PositiveSmallIntegerField()
+    revision = models.PositiveSmallIntegerField(default=1)
+    holidays = models.JSONField(default=list)
+    state = models.CharField(max_length=12, choices=State.choices, default=State.DRAFT)
+    published_by_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    published_at = models.DateTimeField(null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    class Meta:
+        db_table = "leave_holiday_calendar"
+        constraints = [models.UniqueConstraint(fields=["year", "revision"], name="leave_calendar_year_revision_uniq")]
+        indexes = [models.Index(fields=["year", "state"], name="leave_calendar_year_state_idx")]
+
+
+class VacationPeriod(models.Model):
+    """Read-only projection of vacation dates from the external Academic Calendar."""
+    external_id = models.CharField(max_length=120, unique=True)
+    label = models.CharField(max_length=120)
+    start_date = models.DateField()
+    end_date = models.DateField()
+    academic_year = models.CharField(max_length=16, db_index=True)
+    synced_at = models.DateTimeField()
+    class Meta:
+        db_table = "leave_vacation_period"
+        constraints = [models.CheckConstraint(condition=Q(end_date__gte=models.F("start_date")), name="leave_vacation_valid_date_range")]
+
+
+class LeaveSLAConfiguration(models.Model):
+    """Current reminder/escalation thresholds (hours) for actionable tasks."""
+    role = models.CharField(max_length=64, unique=True)
+    reminder_after_hours = models.PositiveIntegerField(default=24)
+    escalate_after_hours = models.PositiveIntegerField(default=72)
+    escalation_role = models.CharField(max_length=64, blank=True)
+    escalation_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    updated_by_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    class Meta:
+        db_table = "leave_sla_configuration"
+
+
+class LeaveRouteConfiguration(models.Model):
+    """Current authority mapping by employee context and leave category."""
+    category = models.ForeignKey(LeaveCategory, on_delete=models.CASCADE, related_name="routes")
+    employee_kind = models.CharField(max_length=8, choices=EmployeeProfile.Kind.choices)
+    designation = models.CharField(max_length=120, blank=True)
+    unit_code = models.CharField(max_length=64, blank=True)
+    final_authority_role = models.CharField(max_length=64)
+    final_authority_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    establishment_role = models.CharField(max_length=64, blank=True)
+    establishment_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    requires_substitute = models.BooleanField(default=False)
+    active = models.BooleanField(default=True)
+    updated_by_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    class Meta:
+        db_table = "leave_route_configuration"
+        indexes = [models.Index(fields=["category", "employee_kind", "active"], name="leave_route_lookup_idx")]
+
+
+class LeaveAuditEvent(models.Model):
+    request = models.ForeignKey(LeaveRequest, on_delete=models.PROTECT, related_name="audit_events")
+    action = models.CharField(max_length=48)
+    from_status = models.CharField(max_length=32, blank=True)
+    to_status = models.CharField(max_length=32, blank=True)
+    actor_user_id = models.PositiveBigIntegerField(null=True, blank=True)
+    occurred_at = models.DateTimeField(auto_now_add=True)
+    details = models.JSONField(default=dict, blank=True)
+    class Meta:
+        db_table = "leave_audit_event"
+        ordering = ["occurred_at", "id"]
+
+
+class LeaveNotificationOutbox(models.Model):
+    """Transactional email delivery queue for assigned tasks and decisions."""
+    class State(models.TextChoices):
+        PENDING = "pending", "Pending"
+        SENDING = "sending", "Sending"
+        SENT = "sent", "Sent"
+        FAILED = "failed", "Failed"
+
+    dedupe_key = models.CharField(max_length=160, unique=True)
+    recipient_user_id = models.PositiveBigIntegerField(db_index=True)
+    subject = models.CharField(max_length=200)
+    body = models.TextField()
+    payload = models.JSONField(default=dict, blank=True)
+    state = models.CharField(max_length=12, choices=State.choices, default=State.PENDING, db_index=True)
+    attempts = models.PositiveSmallIntegerField(default=0)
+    last_error = models.CharField(max_length=300, blank=True)
+    claimed_at = models.DateTimeField(null=True, blank=True)
+    sent_at = models.DateTimeField(null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    class Meta:
+        db_table = "leave_notification_outbox"
+        indexes = [models.Index(fields=["state", "created_at"], name="leave_notify_state_created_idx")]
diff --git a/modules/leave/registry.py b/modules/leave/registry.py
new file mode 100644
index 00000000..0f8f4bc2
--- /dev/null
+++ b/modules/leave/registry.py
@@ -0,0 +1,39 @@
+"""Server-side module descriptor and permission catalog for ELM."""
+MODULE = {
+    "code": "leave_management", "label": "Employee Leave Management",
+    "icon": "Calendar", "base_path": "/leave", "nav_section": "People",
+    "sort_order": 20, "status": "active",
+}
+
+NAV_ITEMS = [
+    {"code": "leave.mine", "label": "My Leave", "icon": "Calendar",
+     "to": "/leave", "required_permission": "leave_management.request.view_self", "sort_order": 10},
+    {"code": "leave.tasks", "label": "Leave Tasks", "icon": "Checks",
+     "to": "/leave/tasks", "required_permission": "leave_management.workflow.task.view", "sort_order": 20},
+    {"code": "leave.substitutions", "label": "Substitute Requests", "icon": "UserCheck",
+     "to": "/leave/substitutions", "required_permission": "leave_management.substitute.respond", "sort_order": 25},
+    {"code": "leave.balances", "label": "Leave Balances", "icon": "Wallet",
+     "to": "/leave/balances", "required_permission": "leave_management.balance.view_self", "sort_order": 30},
+    {"code": "leave.calendar", "label": "Holiday Calendar", "icon": "CalendarBlank",
+     "to": "/leave/calendar", "required_permission": "leave_management.calendar.view", "sort_order": 40},
+]
+
+PERMISSIONS = [
+    ("leave_management.request.view_self", "View own leave requests"),
+    ("leave_management.request.view_all", "View all leave requests"),
+    ("leave_management.request.create", "Create and submit own leave requests"),
+    ("leave_management.request.withdraw", "Withdraw own pending requests"),
+    ("leave_management.request.cancel", "Request cancellation of own approved leave"),
+    ("leave_management.balance.view_self", "View own leave balances and account history"),
+    ("leave_management.balance.view_all", "View employee leave balances"),
+    ("leave_management.substitute.respond", "Accept or decline a substitute assignment"),
+    ("leave_management.workflow.task.view", "View assigned leave workflow tasks"),
+    ("leave_management.workflow.task.decide", "Review or decide assigned workflow tasks"),
+    ("leave_management.policy.view", "View current policy parameters"),
+    ("leave_management.policy.manage", "Maintain current policy parameters"),
+    ("leave_management.calendar.view", "View published calendars"),
+    ("leave_management.calendar.manage", "Maintain and publish calendars"),
+    ("leave_management.records.manage", "Maintain authorized records and offline-sanctioned leave"),
+    ("leave_management.sla.manage", "Configure workflow SLA thresholds"),
+    ("leave_management.routing.manage", "Maintain current authority routing"),
+]
diff --git a/modules/leave/schedule.py b/modules/leave/schedule.py
new file mode 100644
index 00000000..6763112d
--- /dev/null
+++ b/modules/leave/schedule.py
@@ -0,0 +1,20 @@
+"""Daily date gate for the currently configured ELM year-end boundary."""
+from celery.schedules import crontab
+
+BEAT_SCHEDULE = {
+    "leave-notification-outbox": {
+        "task": "leave.deliver_notifications",
+        "schedule": crontab(minute="*/5"),
+    },
+    "leave-configured-year-end": {
+        "task": "leave.process_configured_year_end",
+        "schedule": crontab(minute=10, hour=0),
+    },
+    "leave-sla-thresholds": {
+        "task": "leave.process_sla_thresholds",
+        "schedule": crontab(minute="*/15"),
+    },
+}
+TASK_ROUTES = {"leave.process_configured_year_end": {"queue": "scheduled"}}
+TASK_ROUTES["leave.deliver_notifications"] = {"queue": "notifications"}
+TASK_ROUTES["leave.process_sla_thresholds"] = {"queue": "scheduled"}
diff --git a/modules/leave/services/__init__.py b/modules/leave/services/__init__.py
new file mode 100644
index 00000000..3e1c903f
--- /dev/null
+++ b/modules/leave/services/__init__.py
@@ -0,0 +1 @@
+# Leave Management services
diff --git a/modules/leave/services/accounting.py b/modules/leave/services/accounting.py
new file mode 100644
index 00000000..3fcd1877
--- /dev/null
+++ b/modules/leave/services/accounting.py
@@ -0,0 +1,113 @@
+"""Entitlement provisioning and idempotent year-end account processing."""
+from __future__ import annotations
+
+import logging
+from decimal import Decimal
+
+from django.db import transaction
+from django.utils import timezone
+
+from modules.leave.domain.eligibility import annual_entitlement
+from modules.leave.models import (
+    EmployeeProfile, LeaveAccountEntry, LeaveBalance, LeaveCategory,
+    LeavePolicy,
+)
+from modules.leave.services.requests import LeaveRuleViolation, _post_entry
+
+log = logging.getLogger("fusion.leave.accounting")
+
+
+@transaction.atomic
+def provision_year(year: int, *, actor_user_id: int | None = None) -> int:
+    """Credit configured annual entitlements once for every active employee."""
+    policy = LeavePolicy.objects.filter(policy_key="current").first()
+    if not policy:
+        raise LeaveRuleViolation("Leave policy has not been configured")
+    count = 0
+    categories = {item.code: item for item in LeaveCategory.objects.all()}
+    for employee in EmployeeProfile.objects.filter(active=True).order_by("user_id").iterator():
+        for code in ("CL", "RH", "SCL", "EL", "COL", "VL"):
+            category = categories.get(code)
+            if category is None:
+                continue
+            credit = annual_entitlement(code, employee.kind, policy)
+            if credit <= 0:
+                LeaveBalance.objects.get_or_create(employee_id=employee.user_id, category=category, year=year)
+                continue
+            before = LeaveAccountEntry.objects.filter(source_key=f"entitlement:{employee.user_id}:{code}:{year}").exists()
+            _post_entry(employee_id=employee.user_id, category=category, year=year,
+                        amount=credit, kind=LeaveAccountEntry.Kind.ENTITLEMENT,
+                        source_key=f"entitlement:{employee.user_id}:{code}:{year}",
+                        actor_user_id=actor_user_id, explanation="Annual leave entitlement")
+            count += int(not before)
+    return count
+
+
+@transaction.atomic
+def process_year_end(year: int, *, actor_user_id: int | None = None) -> dict[str, int]:
+    """Close accounts idempotently and open next-year balances.
+
+    CL/RH/SCL lapse. EL and COL carry at 1:1. Faculty VL is removed and
+    converted to EL at 2:1. Each close and credit is persisted as ledger rows.
+    """
+    if year >= 9999:
+        raise LeaveRuleViolation("Invalid leave year")
+    totals = {"closed": 0, "carried": 0, "vl_converted": 0, "lapsed": 0, "exceptions": 0}
+    balances = list(LeaveBalance.objects.select_for_update().filter(year=year).select_related("category").order_by("employee_id", "category_id"))
+    profiles = {p.user_id: p for p in EmployeeProfile.objects.filter(user_id__in={b.employee_id for b in balances})}
+    by_code = {item.code: item for item in LeaveCategory.objects.all()}
+    for balance in balances:
+        if balance.available < 0:
+            totals["exceptions"] += 1
+            log.error("Negative leave balance at year end", extra={
+                "employee_id": balance.employee_id, "category": balance.category_id,
+                "year": year, "available": str(balance.available),
+            })
+            continue
+        amount = max(balance.available, Decimal("0"))
+        if amount == 0:
+            continue
+        code = balance.category_id
+        profile = profiles.get(balance.employee_id)
+        if code == "VL" and profile is None:
+            totals["exceptions"] += 1
+            log.error("Missing employee projection for VL year-end", extra={
+                "employee_id": balance.employee_id, "year": year,
+            })
+            continue
+        if code == "VL" and profile.kind == "faculty":
+            converted = amount / Decimal("2")
+            _close_old_balance(balance, amount, year, actor_user_id, "Unused VL converted",
+                               LeaveAccountEntry.Kind.VL_CONVERSION)
+            if converted:
+                _post_entry(employee_id=balance.employee_id, category=by_code["EL"], year=year + 1,
+                            amount=converted, kind=LeaveAccountEntry.Kind.VL_CONVERSION,
+                            source_key=f"yearend:{year}:{balance.employee_id}:vl-to-el",
+                            actor_user_id=actor_user_id,
+                            explanation="Unused VL converted to EL at 2:1")
+                totals["vl_converted"] += 1
+            totals["closed"] += 1
+        elif code in {"EL", "COL"}:
+            _close_old_balance(balance, amount, year, actor_user_id, f"{code} carried forward",
+                               LeaveAccountEntry.Kind.CARRY_FORWARD)
+            _post_entry(employee_id=balance.employee_id, category=balance.category,
+                        year=year + 1, amount=amount,
+                        kind=LeaveAccountEntry.Kind.CARRY_FORWARD,
+                        source_key=f"yearend:{year}:{balance.employee_id}:{code}:carry-in",
+                        actor_user_id=actor_user_id, explanation=f"Unused {code} carried forward")
+            totals["carried"] += 1
+            totals["closed"] += 1
+        else:
+            _close_old_balance(balance, amount, year, actor_user_id, f"Unused {code} lapsed",
+                               LeaveAccountEntry.Kind.YEAR_END_LAPSE)
+            totals["lapsed"] += 1
+            totals["closed"] += 1
+    totals["entitlements_issued"] = provision_year(year + 1, actor_user_id=actor_user_id)
+    return totals
+
+
+def _close_old_balance(balance, amount, year, actor_user_id, explanation, kind):
+    _post_entry(employee_id=balance.employee_id, category=balance.category, year=year,
+                amount=-amount, kind=kind,
+                source_key=f"yearend:{year}:{balance.employee_id}:{balance.category_id}:close",
+                actor_user_id=actor_user_id, explanation=explanation)
diff --git a/modules/leave/services/notifications.py b/modules/leave/services/notifications.py
new file mode 100644
index 00000000..8b2eab99
--- /dev/null
+++ b/modules/leave/services/notifications.py
@@ -0,0 +1,89 @@
+"""Transactional ELM notices and an idempotent email outbox worker."""
+from __future__ import annotations
+
+import logging
+from datetime import timedelta
+
+from django.conf import settings
+from django.core.mail import send_mail
+from django.db import transaction
+from django.utils import timezone
+
+from modules.directory import contracts as directory
+from modules.leave.models import LeaveNotificationOutbox
+
+log = logging.getLogger("fusion.leave.notify")
+
+
+def enqueue(*, recipient_user_id: int, topic: str, dedupe_key: str,
+            subject: str, body: str, payload: dict | None = None):
+    return LeaveNotificationOutbox.objects.get_or_create(
+        dedupe_key=dedupe_key,
+        defaults={"recipient_user_id": recipient_user_id, "subject": subject,
+                  "body": body, "payload": {**(payload or {}), "topic": topic}},
+    )[0]
+
+
+def enqueue_task(task):
+    if task.assigned_user_id is None:
+        return None
+    req = task.request
+    return enqueue(
+        recipient_user_id=task.assigned_user_id, topic="task.assigned",
+        dedupe_key=f"task:{task.pk}:assigned",
+        subject="ELM action required",
+        body=(f"Leave request #{req.pk} ({req.category_id}, {req.start_date} to {req.end_date}) "
+              f"is waiting for your {task.role.replace('_', ' ')} action."),
+        payload={"task_id": task.pk, "request_id": req.pk, "role": task.role},
+    )
+
+
+def enqueue_decision(request, *, decision: str):
+    return enqueue(
+        recipient_user_id=request.employee_id, topic="request.decision",
+        dedupe_key=f"request:{request.pk}:decision:{decision}",
+        subject=f"Leave request #{request.pk}: {decision.replace('_', ' ')}",
+        body=(f"Your {request.category_id} leave request from {request.start_date} to {request.end_date} "
+              f"was {decision.replace('_', ' ')}."),
+        payload={"request_id": request.pk, "decision": decision},
+    )
+
+
+def deliver_pending(*, limit: int = 100) -> dict[str, int]:
+    now = timezone.now()
+    LeaveNotificationOutbox.objects.filter(
+        state=LeaveNotificationOutbox.State.SENDING,
+        updated_at__lt=now - timedelta(minutes=10),
+    ).update(state=LeaveNotificationOutbox.State.PENDING, claimed_at=None)
+    pending = list(LeaveNotificationOutbox.objects.filter(state=LeaveNotificationOutbox.State.PENDING)
+                   .order_by("created_at")[:limit])
+    recipients = directory.get_users([row.recipient_user_id for row in pending])
+    report = {"sent": 0, "failed": 0, "deferred": 0}
+    for row in pending:
+        claimed = LeaveNotificationOutbox.objects.filter(pk=row.pk, state=LeaveNotificationOutbox.State.PENDING).update(
+            state=LeaveNotificationOutbox.State.SENDING, claimed_at=now, updated_at=now)
+        if not claimed:
+            report["deferred"] += 1
+            continue
+        user = recipients.get(row.recipient_user_id)
+        try:
+            if not user or not user.email:
+                raise ValueError("Recipient has no email address in the institute directory")
+            send_mail(row.subject, row.body, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=False)
+        except Exception as exc:  # delivery failure must not roll back the business action
+            failed_state = (LeaveNotificationOutbox.State.PENDING if row.attempts < 4
+                            else LeaveNotificationOutbox.State.FAILED)
+            LeaveNotificationOutbox.objects.filter(pk=row.pk).update(
+                state=failed_state, claimed_at=None,
+                attempts=row.attempts + 1, last_error=f"{type(exc).__name__}: {exc}"[:300],
+                updated_at=timezone.now(),
+            )
+            report["failed"] += 1
+            log.exception("ELM notification delivery failed", extra={"notification_id": row.pk})
+        else:
+            LeaveNotificationOutbox.objects.filter(pk=row.pk).update(
+                state=LeaveNotificationOutbox.State.SENT,
+                attempts=row.attempts + 1, claimed_at=None, sent_at=timezone.now(), updated_at=timezone.now(),
+            )
+            report["sent"] += 1
+    return report
diff --git a/modules/leave/services/projections.py b/modules/leave/services/projections.py
new file mode 100644
index 00000000..54802ecc
--- /dev/null
+++ b/modules/leave/services/projections.py
@@ -0,0 +1,41 @@
+"""Upsert employment and Academic Calendar projections from their owners."""
+from django.db import transaction
+from django.utils import timezone
+
+from modules.leave.contracts import (
+    EmploymentProjection, ProjectionSyncResult, VacationPeriodProjection,
+)
+from modules.leave.models import EmployeeProfile, VacationPeriod
+
+
+@transaction.atomic
+def sync_projections(*, employments=(), vacation_periods=()) -> ProjectionSyncResult:
+    """Apply a batch from HR/identity and Academic Calendar contracts."""
+    employee_count = vacation_count = 0
+    now = timezone.now()
+    for row in employments:
+        if not isinstance(row, EmploymentProjection):
+            raise TypeError("employments must contain EmploymentProjection values")
+        if row.kind not in {EmployeeProfile.Kind.FACULTY, EmployeeProfile.Kind.STAFF}:
+            raise ValueError(f"Unsupported ELM employee kind for user {row.user_id}")
+        _, created = EmployeeProfile.objects.update_or_create(
+            user_id=row.user_id,
+            defaults={"kind": row.kind, "designation": row.designation,
+                      "unit_code": row.unit_code, "unit_head_user_id": row.unit_head_user_id,
+                      "is_director": row.is_director, "active": row.active,
+                      "synced_at": now},
+        )
+        employee_count += 1
+    for row in vacation_periods:
+        if not isinstance(row, VacationPeriodProjection):
+            raise TypeError("vacation_periods must contain VacationPeriodProjection values")
+        if row.end_date < row.start_date:
+            raise ValueError(f"Invalid Academic Calendar interval {row.external_id}")
+        VacationPeriod.objects.update_or_create(
+            external_id=row.external_id,
+            defaults={"label": row.label, "start_date": row.start_date,
+                      "end_date": row.end_date, "academic_year": row.academic_year,
+                      "synced_at": now},
+        )
+        vacation_count += 1
+    return ProjectionSyncResult(employee_count, vacation_count)
diff --git a/modules/leave/services/requests.py b/modules/leave/services/requests.py
new file mode 100644
index 00000000..b1c902dc
--- /dev/null
+++ b/modules/leave/services/requests.py
@@ -0,0 +1,587 @@
+"""Transactional use-case services for leave requests and account entries."""
+from __future__ import annotations
+
+from datetime import date, timedelta
+from decimal import Decimal
+
+from django.db import transaction
+from django.db.models import Q
+from django.utils import timezone
+
+from modules.leave.domain.state_machine import route_for, resumption_outcome, validate_cancellation, validate_withdrawal
+from modules.leave.domain.eligibility import annual_entitlement
+from modules.leave.domain.validation import validate_application
+from modules.leave.models import (
+    EmployeeProfile, HolidayCalendar, LeaveAccountEntry, LeaveAuditEvent,
+    LeaveBalance, LeaveCategory, LeavePolicy, LeaveRequest, LeaveRouteConfiguration,
+    LeaveSanction, LeaveSLAConfiguration, SubstituteResponse, VacationPeriod,
+    WorkflowTask,
+)
+from modules.leave.services.notifications import enqueue as enqueue_notification, enqueue_task
+
+
+class LeaveRuleViolation(ValueError):
+    """A request conflicts with an ELM rule or current configuration."""
+
+
+def _effective_calendar(year: int):
+    return HolidayCalendar.objects.filter(year=year, state=HolidayCalendar.State.PUBLISHED).order_by("-revision").first()
+
+
+def _calendar_dates(year: int):
+    calendar = _effective_calendar(year)
+    if not calendar:
+        return (), ()
+    holidays, rh_dates = [], []
+    for item in calendar.holidays:
+        try:
+            day = date.fromisoformat(item["date"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        holidays.append(day)
+        if item.get("restricted_holiday") or item.get("type") == "RH":
+            rh_dates.append(day)
+    return tuple(holidays), tuple(rh_dates)
+
+
+def _duration_by_year(request: LeaveRequest) -> dict[int, Decimal]:
+    grouped = {}
+    for year in range(request.start_date.year, request.end_date.year + 1):
+        start, end = max(request.start_date, date(year, 1, 1)), min(request.end_date, date(year, 12, 31))
+        holidays, rh_dates = _calendar_dates(year)
+        grouped[year] = calculate_duration(request.category_id, start, end,
+                                            cl_portion=request.cl_portion,
+                                            holidays=holidays, rh_dates=rh_dates)
+    return grouped
+
+
+def _current_policy():
+    policy = LeavePolicy.objects.filter(policy_key="current").first()
+    if not policy:
+        raise LeaveRuleViolation("Leave policy has not been configured")
+    return policy
+
+
+def _post_entry(*, employee_id, category, year, amount, kind, source_key,
+                request=None, actor_user_id=None, explanation=""):
+    entry, created = LeaveAccountEntry.objects.get_or_create(
+        source_key=source_key,
+        defaults={"employee_id": employee_id, "category": category, "year": year,
+                  "amount": amount, "kind": kind, "request": request,
+                  "actor_user_id": actor_user_id, "explanation": explanation},
+    )
+    if created:
+        balance, _ = LeaveBalance.objects.select_for_update().get_or_create(
+            employee_id=employee_id, category=category, year=year,
+            defaults={"available": Decimal("0")},
+        )
+        balance.available += amount
+        if kind == LeaveAccountEntry.Kind.ENTITLEMENT:
+            balance.entitlement += amount
+        if kind == LeaveAccountEntry.Kind.CARRY_FORWARD and amount > 0:
+            balance.carried_over += amount
+        fields = ["available", "updated_at"]
+        if kind == LeaveAccountEntry.Kind.ENTITLEMENT:
+            fields.append("entitlement")
+        if kind == LeaveAccountEntry.Kind.CARRY_FORWARD and amount > 0:
+            fields.append("carried_over")
+        balance.save(update_fields=fields)
+    return entry
+
+
+def _validate_request(request: LeaveRequest, employee: EmployeeProfile):
+    policy = _current_policy()
+    balances = []
+    for year in range(request.start_date.year, request.end_date.year + 1):
+        balance, _ = LeaveBalance.objects.select_for_update().get_or_create(
+            employee_id=employee.user_id, category=request.category, year=year)
+        key = f"entitlement:{employee.user_id}:{request.category_id}:{year}"
+        credit = annual_entitlement(request.category_id, employee.kind, policy)
+        if credit and not LeaveAccountEntry.objects.filter(source_key=key).exists():
+            _post_entry(employee_id=employee.user_id, category=request.category, year=year,
+                        amount=credit, kind=LeaveAccountEntry.Kind.ENTITLEMENT,
+                        source_key=key, explanation="Annual leave entitlement")
+            balance.refresh_from_db()
+        balances.append(balance)
+    available = sum((balance.available for balance in balances), Decimal("0"))
+    holidays, rh_dates = [], []
+    for year in range(request.start_date.year, request.end_date.year + 1):
+        h, r = _calendar_dates(year)
+        holidays.extend(h)
+        rh_dates.extend(r)
+    overlaps = LeaveRequest.objects.filter(
+        employee_id=employee.user_id,
+        status__in=[LeaveRequest.Status.AWAITING_SUBSTITUTE, LeaveRequest.Status.APPLICANT_ACTION,
+                    LeaveRequest.Status.PENDING_UNIT_HEAD, LeaveRequest.Status.PENDING_ESTABLISHMENT,
+                    LeaveRequest.Status.PENDING_AUTHORITY, LeaveRequest.Status.APPROVED],
+        start_date__lte=request.end_date, end_date__gte=request.start_date,
+    ).exclude(pk=request.pk).values_list("start_date", "end_date", "category__code", "cl_portion")
+    vacations = VacationPeriod.objects.filter(start_date__lte=request.start_date, end_date__gte=request.end_date).values_list("start_date", "end_date")
+    result = validate_application(
+        category=request.category_id, start=request.start_date, end=request.end_date,
+        employee_kind=employee.kind, cl_portion=request.cl_portion,
+        station_leave=request.station_leave, station_destination=request.station_destination,
+        station_departure_at=request.station_departure_at, station_return_at=request.station_return_at,
+        holidays=holidays, rh_dates=rh_dates, available=available,
+        overlapping=overlaps,
+        medical_evidence_ref=request.medical_evidence_ref,
+        medical_required=policy.col_medical_evidence_required,
+        vacation_periods=vacations,
+    )
+    if not result.is_valid:
+        raise LeaveRuleViolation("; ".join(result.errors))
+    by_year = _duration_by_year(request)
+    for balance in balances:
+        required = by_year.get(balance.year, Decimal("0"))
+        if required > balance.available:
+            raise LeaveRuleViolation(
+                f"Insufficient {request.category_id} balance for {balance.year}: "
+                f"{balance.available} available, {required} requested"
+            )
+    # SCL admissibility is an authority judgment. The service deliberately does
+    # not try to infer it from employee kind or encode purpose categories.
+    request.duration_days = sum(by_year.values(), Decimal("0"))
+    return request
+
+
+@transaction.atomic
+def submit_request(request_id: int, actor_user_id: int):
+    request = LeaveRequest.objects.select_for_update().select_related("category").get(pk=request_id)
+    if request.employee_id != actor_user_id or request.status != LeaveRequest.Status.DRAFT:
+        raise LeaveRuleViolation("Only the employee may submit their own draft")
+    employee = EmployeeProfile.objects.get(user_id=actor_user_id, active=True)
+    request = _validate_request(request, employee)
+    config = _route_configuration(request, employee)
+    if config and config.requires_substitute and not request.substitute_user_id:
+        raise LeaveRuleViolation("A substitute is required for this leave route")
+    request.submitted_at = timezone.now()
+    if request.substitute_user_id:
+        substitute = EmployeeProfile.objects.filter(user_id=request.substitute_user_id, active=True).first()
+        if not substitute or substitute.user_id == employee.user_id:
+            raise LeaveRuleViolation("Substitute must be another active employee")
+        if LeaveRequest.objects.filter(
+            employee_id=substitute.user_id,
+            status__in=[LeaveRequest.Status.AWAITING_SUBSTITUTE, LeaveRequest.Status.APPLICANT_ACTION,
+                        LeaveRequest.Status.PENDING_UNIT_HEAD, LeaveRequest.Status.PENDING_ESTABLISHMENT,
+                        LeaveRequest.Status.PENDING_AUTHORITY, LeaveRequest.Status.APPROVED],
+            start_date__lte=request.end_date, end_date__gte=request.start_date,
+        ).exists():
+            raise LeaveRuleViolation("Substitute has overlapping pending or approved leave")
+        request.status = LeaveRequest.Status.AWAITING_SUBSTITUTE
+        _create_substitute_task(request, substitute.user_id)
+    else:
+        request.status = LeaveRequest.Status.PENDING_UNIT_HEAD
+        first_task = _create_route_tasks(request, employee)
+        request.status = _status_for_role(first_task.role)
+    request.save()
+    LeaveAuditEvent.objects.create(request=request, action="submitted", from_status="draft", to_status=request.status,
+                                   actor_user_id=actor_user_id)
+    return request
+
+
+def _count_request_days(request):
+    return sum(_duration_by_year(request).values(), Decimal("0"))
+
+
+def _create_route_tasks(request: LeaveRequest, employee: EmployeeProfile):
+    cfg = _route_configuration(request, employee)
+    if employee.is_director:
+        route = route_for(category=request.category_id, is_director=True,
+                          establishment_role=None, final_authority_role=None)
+    elif request.category_id in {"CL", "RH"}:
+        route = route_for(category=request.category_id, is_director=False,
+                          establishment_role=None, final_authority_role="unit_head")
+    else:
+        if not cfg:
+            raise LeaveRuleViolation("No current sanction route is configured for this employee and leave category")
+        route = route_for(category=request.category_id, is_director=False,
+                          establishment_role=cfg.establishment_role or None,
+                          final_authority_role=cfg.final_authority_role)
+    created = []
+    start_sequence = (request.tasks.order_by("-sequence").values_list("sequence", flat=True).first() or 0) + 1
+    created = []
+    for index, step in enumerate(route):
+        sequence = start_sequence + index
+        if step.role == "unit_head":
+            assigned = employee.unit_head_user_id
+        elif step.role == "director":
+            assigned = employee.user_id
+        elif step.role == "establishment":
+            assigned = cfg.establishment_user_id if cfg else None
+        else:
+            assigned = cfg.final_authority_user_id if cfg else None
+        if assigned is None:
+            raise LeaveRuleViolation(f"No user is assigned to the {step.role.replace('_', ' ')} workflow step")
+        task = WorkflowTask.objects.create(
+            request=request, sequence=sequence, role=step.role,
+            decision_kind=step.decision_kind, assigned_user_id=assigned,
+            state=WorkflowTask.State.PENDING if index == 0 else WorkflowTask.State.QUEUED,
+            activated_at=timezone.now() if index == 0 else None,
+            due_at=_task_due_at(step.role) if index == 0 else None,
+        )
+        created.append(task)
+    if not created:
+        raise LeaveRuleViolation("No workflow task was created")
+    enqueue_task(created[0])
+    return created[0]
+
+
+def _task_due_at(role: str):
+    config, _ = LeaveSLAConfiguration.objects.get_or_create(role=role)
+    hours = config.escalate_after_hours if config else 72
+    return timezone.now() + timedelta(hours=hours)
+
+
+def _create_substitute_task(request: LeaveRequest, substitute_user_id: int):
+    sequence = (request.tasks.order_by("-sequence").values_list("sequence", flat=True).first() or 0) + 1
+    task = WorkflowTask.objects.create(
+        request=request, sequence=sequence, role="substitute", decision_kind="forward",
+        assigned_user_id=substitute_user_id, state=WorkflowTask.State.PENDING,
+        activated_at=timezone.now(),
+        due_at=_task_due_at("substitute"),
+    )
+    enqueue_task(task)
+    return task
+
+
+def _route_configuration(request: LeaveRequest, employee: EmployeeProfile):
+    return LeaveRouteConfiguration.objects.filter(
+        category=request.category, employee_kind=employee.kind, active=True,
+    ).filter(Q(designation="") | Q(designation=employee.designation)).filter(
+        Q(unit_code="") | Q(unit_code=employee.unit_code)
+    ).order_by("-unit_code", "-designation").first()
+
+
+@transaction.atomic
+def respond_to_substitute(request_id: int, actor_user_id: int, *, accepted: bool):
+    request = LeaveRequest.objects.select_for_update().get(pk=request_id)
+    if request.status != LeaveRequest.Status.AWAITING_SUBSTITUTE or request.substitute_user_id != actor_user_id:
+        raise LeaveRuleViolation("This substitute request is no longer pending for you")
+    SubstituteResponse.objects.create(request=request, substitute_user_id=actor_user_id,
+                                      decision=SubstituteResponse.Decision.ACCEPTED if accepted else SubstituteResponse.Decision.DECLINED)
+    old = request.status
+    request.tasks.filter(role="substitute", state=WorkflowTask.State.PENDING,
+                         assigned_user_id=actor_user_id).update(state=WorkflowTask.State.COMPLETED)
+    if accepted:
+        first_task = _create_route_tasks(request, EmployeeProfile.objects.get(user_id=request.employee_id))
+        request.status = _status_for_role(first_task.role)
+    else:
+        request.status = LeaveRequest.Status.APPLICANT_ACTION
+    request.save(update_fields=["status", "updated_at"])
+    LeaveAuditEvent.objects.create(request=request, action="substitute_accepted" if accepted else "substitute_declined",
+                                   from_status=old, to_status=request.status, actor_user_id=actor_user_id)
+    return request
+
+
+@transaction.atomic
+def replace_declined_substitute(request_id: int, actor_user_id: int, substitute_user_id: int):
+    request = LeaveRequest.objects.select_for_update().get(pk=request_id)
+    if request.employee_id != actor_user_id or request.status != LeaveRequest.Status.APPLICANT_ACTION:
+        raise LeaveRuleViolation("Only the applicant may replace a declined substitute")
+    declined = request.substitute_responses.filter(decision=SubstituteResponse.Decision.DECLINED).count()
+    if declined != 1:
+        raise LeaveRuleViolation("One substitute replacement is allowed after the initial decline")
+    substitute = EmployeeProfile.objects.filter(user_id=substitute_user_id, active=True).first()
+    if not substitute or substitute.user_id == actor_user_id:
+        raise LeaveRuleViolation("Replacement must be another active employee")
+    overlap = LeaveRequest.objects.filter(
+        employee_id=substitute_user_id,
+        status__in=[LeaveRequest.Status.AWAITING_SUBSTITUTE, LeaveRequest.Status.APPLICANT_ACTION,
+                    LeaveRequest.Status.PENDING_UNIT_HEAD, LeaveRequest.Status.PENDING_ESTABLISHMENT,
+                    LeaveRequest.Status.PENDING_AUTHORITY, LeaveRequest.Status.APPROVED],
+        start_date__lte=request.end_date, end_date__gte=request.start_date,
+    ).exists()
+    if overlap:
+        raise LeaveRuleViolation("Replacement substitute has overlapping pending or approved leave")
+    request.substitute_user_id = substitute_user_id
+    request.status = LeaveRequest.Status.AWAITING_SUBSTITUTE
+    request.save(update_fields=["substitute_user_id", "status", "updated_at"])
+    _create_substitute_task(request, substitute_user_id)
+    LeaveAuditEvent.objects.create(request=request, action="substitute_replaced",
+                                   from_status=LeaveRequest.Status.APPLICANT_ACTION,
+                                   to_status=request.status, actor_user_id=actor_user_id,
+                                   details={"substitute_user_id": substitute_user_id})
+    return request
+
+
+@transaction.atomic
+def withdraw_request(request_id: int, actor_user_id: int):
+    request = LeaveRequest.objects.select_for_update().get(pk=request_id)
+    if request.employee_id != actor_user_id:
+        raise LeaveRuleViolation("Only the applicant may withdraw this request")
+    validate_withdrawal(request.status)
+    old = request.status
+    request.status = LeaveRequest.Status.WITHDRAWN
+    request.save(update_fields=["status", "updated_at"])
+    request.tasks.filter(state=WorkflowTask.State.PENDING).update(state=WorkflowTask.State.CANCELLED)
+    for task in request.tasks.filter(assigned_user_id__isnull=False):
+        enqueue_notification(
+            recipient_user_id=task.assigned_user_id,
+            dedupe_key=f"request:{request.pk}:withdrawn:task:{task.pk}",
+            topic="request.withdrawn", subject="ELM request withdrawn",
+            body=f"Leave request #{request.pk} was withdrawn by the applicant.",
+            payload={"request_id": request.pk, "task_id": task.pk},
+        )
+    LeaveAuditEvent.objects.create(request=request, action="withdrawn", from_status=old,
+                                   to_status=request.status, actor_user_id=actor_user_id)
+    return request
+
+
+@transaction.atomic
+def decide_task(task_id: int, actor_user_id: int, *, decision: str, notes: str = ""):
+    task = WorkflowTask.objects.select_for_update().select_related("request", "request__category").get(pk=task_id)
+    if task.state != WorkflowTask.State.PENDING:
+        raise LeaveRuleViolation("This workflow task is no longer pending")
+    if task.assigned_user_id and task.assigned_user_id != actor_user_id:
+        raise LeaveRuleViolation("This task is assigned to another user")
+    request = LeaveRequest.objects.select_for_update().get(pk=task.request_id)
+    allowed = {"final": {"approved", "rejected"},
+               "recommendation": {"recommended", "not_recommended"},
+               "forward": {"forwarded"}}
+    if decision not in allowed[task.decision_kind]:
+        raise LeaveRuleViolation("Decision is not valid for this workflow step")
+    LeaveSanction.objects.create(task=task, actor_user_id=actor_user_id, decision=decision, notes=notes)
+    task.state = WorkflowTask.State.COMPLETED
+    task.save(update_fields=["state"])
+    old = request.status
+    if task.decision_kind == "final":
+        if decision == "approved":
+            _apply_final_approval(request, actor_user_id)
+            request.status = (LeaveRequest.Status.COMPLETED
+                              if request.request_type == LeaveRequest.Type.RESUMPTION
+                              else LeaveRequest.Status.APPROVED)
+        else:
+            request.status = LeaveRequest.Status.REJECTED
+        request.decided_at = timezone.now()
+    else:
+        next_task = request.tasks.filter(state=WorkflowTask.State.QUEUED).order_by("sequence").first()
+        if not next_task:
+            raise LeaveRuleViolation("No next authority is configured for this workflow")
+        next_task.state = WorkflowTask.State.PENDING
+        next_task.due_at = _task_due_at(next_task.role)
+        next_task.activated_at = timezone.now()
+        next_task.save(update_fields=["state", "due_at", "activated_at"])
+        enqueue_task(next_task)
+        request.status = _status_for_role(next_task.role)
+    request.save(update_fields=["status", "decided_at", "updated_at"])
+    LeaveAuditEvent.objects.create(request=request, action=decision, from_status=old,
+                                   to_status=request.status, actor_user_id=actor_user_id,
+                                   details={"task_id": task.id, "notes": notes})
+    if task.decision_kind == "final":
+        from modules.leave.services.notifications import enqueue_decision
+        enqueue_decision(request, decision=decision)
+    return request
+
+
+def _status_for_role(role: str) -> str:
+    return {"unit_head": LeaveRequest.Status.PENDING_UNIT_HEAD,
+            "establishment": LeaveRequest.Status.PENDING_ESTABLISHMENT}.get(role, LeaveRequest.Status.PENDING_AUTHORITY)
+
+
+def _approve_leave(request, actor_user_id):
+    if request.request_type != LeaveRequest.Type.NEW:
+        return
+    for year, days in _duration_by_year(request).items():
+        _post_entry(employee_id=request.employee_id, category=request.category,
+                    year=year, amount=-days, kind=LeaveAccountEntry.Kind.LEAVE_USED,
+                    source_key=f"request:{request.pk}:approved:{year}", request=request,
+                    actor_user_id=actor_user_id, explanation="Approved leave")
+
+
+def _apply_final_approval(request, actor_user_id):
+    if request.request_type == LeaveRequest.Type.NEW:
+        _approve_leave(request, actor_user_id)
+    elif request.request_type == LeaveRequest.Type.CANCELLATION:
+        original = LeaveRequest.objects.select_for_update().get(pk=request.parent_request_id)
+        original.status = LeaveRequest.Status.CANCELLED
+        original.save(update_fields=["status", "updated_at"])
+        for debit in original.account_entries.filter(kind=LeaveAccountEntry.Kind.LEAVE_USED):
+            _post_entry(employee_id=original.employee_id, category=original.category,
+                        year=debit.year, amount=-debit.amount,
+                        kind=LeaveAccountEntry.Kind.CANCELLATION_REVERSAL,
+                        source_key=f"request:{request.pk}:cancellation-reversal:{debit.year}", request=original,
+                        actor_user_id=actor_user_id, explanation="Approved leave cancellation")
+    elif request.request_type == LeaveRequest.Type.EXTENSION:
+        for year, days in _duration_by_year(request).items():
+            _post_entry(employee_id=request.employee_id, category=request.category,
+                        year=year, amount=-days, kind=LeaveAccountEntry.Kind.LEAVE_USED,
+                        source_key=f"request:{request.pk}:extension-approved:{year}", request=request,
+                        actor_user_id=actor_user_id, explanation="Approved extension period")
+    elif request.request_type == LeaveRequest.Type.RESUMPTION:
+        original = LeaveRequest.objects.select_for_update().get(pk=request.parent_request_id)
+        outcome = resumption_outcome(approved_end_date=original.end_date,
+                                     actual_resume_date=request.actual_resume_date)
+        approved_by_year = _duration_by_year(original)
+        actual_end = request.actual_resume_date.fromordinal(request.actual_resume_date.toordinal() - 1)
+        actual_by_year = {}
+        if actual_end >= original.start_date:
+            for year in range(original.start_date.year, actual_end.year + 1):
+                first, last = max(original.start_date, date(year, 1, 1)), min(actual_end, date(year, 12, 31))
+                actual_by_year[year] = Decimal((last - first).days + 1)
+        adjustments = {}
+        if outcome != "normal":
+            for year in approved_by_year.keys() | actual_by_year.keys():
+                amount = approved_by_year.get(year, Decimal("0")) - actual_by_year.get(year, Decimal("0"))
+                if amount:
+                    _post_entry(employee_id=original.employee_id, category=original.category,
+                                year=year, amount=amount,
+                                kind=LeaveAccountEntry.Kind.RESUMPTION_ADJUSTMENT,
+                                source_key=f"request:{request.pk}:resumption-adjustment:{year}", request=original,
+                                actor_user_id=actor_user_id, explanation="Reviewed early/late resumption")
+                    adjustments[year] = str(amount)
+        LeaveAuditEvent.objects.create(request=request, action=f"resumption_{outcome}",
+                                       from_status=request.status, to_status=request.status,
+                                       actor_user_id=actor_user_id,
+                                       details={"approved_days": {str(k): str(v) for k, v in approved_by_year.items()},
+                                                "actual_days": {str(k): str(v) for k, v in actual_by_year.items()},
+                                                "balance_adjustment": adjustments})
+
+
+@transaction.atomic
+def request_cancellation(request_id: int, actor_user_id: int):
+    original = LeaveRequest.objects.select_for_update().get(pk=request_id)
+    if original.employee_id != actor_user_id:
+        raise LeaveRuleViolation("Only the employee may request cancellation")
+    validate_cancellation(status=original.status, start_date=original.start_date, today=timezone.localdate())
+    cancellation = LeaveRequest.objects.create(
+        employee_id=actor_user_id, category=original.category, request_type=LeaveRequest.Type.CANCELLATION,
+        parent_request=original, start_date=original.start_date, end_date=original.end_date,
+        duration_days=original.duration_days, reason="Cancellation requested",
+        status=LeaveRequest.Status.PENDING_UNIT_HEAD,
+    )
+    employee = EmployeeProfile.objects.get(user_id=actor_user_id)
+    first_task = _create_route_tasks(cancellation, employee)
+    cancellation.status = _status_for_role(first_task.role)
+    cancellation.save(update_fields=["status", "updated_at"])
+    LeaveAuditEvent.objects.create(request=cancellation, action="cancellation_requested",
+                                   from_status="approved", to_status=cancellation.status,
+                                   actor_user_id=actor_user_id)
+    return cancellation
+
+
+@transaction.atomic
+def request_extension(request_id: int, actor_user_id: int, *, new_end_date: date,
+                      reason: str, substitute_user_id: int | None = None):
+    from datetime import timedelta
+    from modules.leave.domain.state_machine import validate_extension
+    original = LeaveRequest.objects.select_for_update().select_related("category").get(pk=request_id)
+    validate_extension(category=original.category_id, status=original.status,
+                       start_date=original.start_date, end_date=original.end_date,
+                       new_end_date=new_end_date, today=timezone.localdate())
+    if original.employee_id != actor_user_id:
+        raise LeaveRuleViolation("Only the employee may request an extension")
+    period_start = original.end_date + timedelta(days=1)
+    extension = LeaveRequest.objects.create(
+        employee_id=actor_user_id, category=original.category, request_type=LeaveRequest.Type.EXTENSION,
+        parent_request=original, start_date=period_start, end_date=new_end_date,
+        duration_days=Decimal((new_end_date - original.end_date).days), reason=reason,
+        substitute_user_id=substitute_user_id,
+        status=LeaveRequest.Status.AWAITING_SUBSTITUTE if substitute_user_id else LeaveRequest.Status.PENDING_UNIT_HEAD,
+    )
+    employee = EmployeeProfile.objects.get(user_id=actor_user_id, active=True)
+    _validate_request(extension, employee)
+    config = _route_configuration(extension, employee)
+    if config and config.requires_substitute and not substitute_user_id:
+        raise LeaveRuleViolation("A substitute is required for this extension route")
+    if substitute_user_id:
+        substitute = EmployeeProfile.objects.filter(user_id=substitute_user_id, active=True).first()
+        if not substitute or substitute.user_id == actor_user_id:
+            raise LeaveRuleViolation("Substitute must be another active employee")
+        if LeaveRequest.objects.filter(
+            employee_id=substitute_user_id,
+            status__in=[LeaveRequest.Status.AWAITING_SUBSTITUTE, LeaveRequest.Status.APPLICANT_ACTION,
+                        LeaveRequest.Status.PENDING_UNIT_HEAD, LeaveRequest.Status.PENDING_ESTABLISHMENT,
+                        LeaveRequest.Status.PENDING_AUTHORITY, LeaveRequest.Status.APPROVED],
+            start_date__lte=extension.end_date, end_date__gte=extension.start_date,
+        ).exists():
+            raise LeaveRuleViolation("Substitute has overlapping pending or approved leave")
+    if not substitute_user_id:
+        first_task = _create_route_tasks(extension, employee)
+        extension.status = _status_for_role(first_task.role)
+        extension.save(update_fields=["status", "updated_at"])
+    else:
+        _create_substitute_task(extension, substitute_user_id)
+    LeaveAuditEvent.objects.create(request=extension, action="extension_requested",
+                                   from_status="approved", to_status=extension.status,
+                                   actor_user_id=actor_user_id)
+    return extension
+
+
+@transaction.atomic
+def submit_resumption(request_id: int, actor_user_id: int, *, actual_resume_date: date,
+                      reason: str):
+    original = LeaveRequest.objects.select_for_update().select_related("category").get(pk=request_id)
+    if original.employee_id != actor_user_id or original.category_id not in {"EL", "COL", "VL"}:
+        raise LeaveRuleViolation("Resumption is available to the employee for approved EL, COL, or VL only")
+    if original.status != LeaveRequest.Status.APPROVED:
+        raise LeaveRuleViolation("Only approved leave can be resumed")
+    if actual_resume_date > timezone.localdate():
+        raise LeaveRuleViolation("Actual resumption date cannot be in the future")
+    if actual_resume_date < original.start_date:
+        raise LeaveRuleViolation("Actual resumption cannot precede leave start")
+    # The reviewer is the same final authority resolved for the original request.
+    final = original.tasks.order_by("-sequence").first()
+    if not final:
+        raise LeaveRuleViolation("The original sanction route is unavailable")
+    followup = LeaveRequest.objects.create(
+        employee_id=actor_user_id, category=original.category, request_type=LeaveRequest.Type.RESUMPTION,
+        parent_request=original, start_date=original.start_date, end_date=original.end_date,
+        duration_days=original.duration_days, actual_resume_date=actual_resume_date,
+        reason=reason, status=LeaveRequest.Status.PENDING_AUTHORITY,
+    )
+    task = WorkflowTask.objects.create(request=followup, sequence=1, role=final.role,
+                                       decision_kind="final", assigned_user_id=final.assigned_user_id)
+    enqueue_task(task)
+    LeaveAuditEvent.objects.create(request=followup, action="resumption_submitted",
+                                   from_status="approved", to_status=followup.status,
+                                   actor_user_id=actor_user_id)
+    return followup
+
+
+@transaction.atomic
+def record_offline_sanctioned_leave(*, employee_id: int, category_code: str,
+                                    start_date: date, end_date: date, reason: str,
+                                    sanction_reference: str, evidence_reference: str,
+                                    actor_user_id: int):
+    """Synchronize an already-sanctioned offline leave without a second approval."""
+    from modules.leave.domain.validation import calculate_duration
+    employee = EmployeeProfile.objects.get(user_id=employee_id, active=True)
+    category = LeaveCategory.objects.get(pk=category_code)
+    req = LeaveRequest(employee_id=employee_id, category=category,
+                       request_type=LeaveRequest.Type.OFFLINE, start_date=start_date,
+                       end_date=end_date, duration_days=Decimal("0"), reason=reason,
+                       offline_sanction_ref=sanction_reference,
+                       offline_evidence_ref=evidence_reference)
+    if not sanction_reference.strip() or not evidence_reference.strip():
+        raise LeaveRuleViolation("Offline entry requires sanction reference and evidence")
+    req = _validate_request(req, employee)
+    req.duration_days = _count_request_days(req)
+    req.status = LeaveRequest.Status.APPROVED
+    req.submitted_at = req.decided_at = timezone.now()
+    req.save()
+    for year, days in _duration_by_year(req).items():
+        _post_entry(employee_id=employee_id, category=category, year=year,
+                    amount=-days, kind=LeaveAccountEntry.Kind.OFFLINE_ADJUSTMENT,
+                    source_key=f"request:{req.pk}:offline-record:{year}", request=req,
+                    actor_user_id=actor_user_id,
+                    explanation=f"Offline sanction {sanction_reference}")
+    LeaveAuditEvent.objects.create(request=req, action="offline_sanction_recorded",
+                                   from_status="", to_status=req.status,
+                                   actor_user_id=actor_user_id,
+                                   details={"sanction_reference": sanction_reference,
+                                            "evidence_reference": evidence_reference})
+    return req
+
+
+@transaction.atomic
+def record_account_adjustment(*, employee_id: int, category: LeaveCategory, year: int,
+                              amount: Decimal, reference: str, explanation: str,
+                              actor_user_id: int):
+    if not reference.strip() or not explanation.strip() or amount == 0:
+        raise LeaveRuleViolation("An adjustment needs a non-zero amount, reference, and explanation")
+    if not EmployeeProfile.objects.filter(user_id=employee_id, active=True).exists():
+        raise LeaveRuleViolation("Employee is not active in the ELM projection")
+    return _post_entry(employee_id=employee_id, category=category, year=year,
+                       amount=amount, kind=LeaveAccountEntry.Kind.OFFLINE_ADJUSTMENT,
+                       source_key=f"admin-adjustment:{reference}", actor_user_id=actor_user_id,
+                       explanation=explanation)
diff --git a/modules/leave/tasks.py b/modules/leave/tasks.py
new file mode 100644
index 00000000..d17c870f
--- /dev/null
+++ b/modules/leave/tasks.py
@@ -0,0 +1,80 @@
+"""Scheduled ELM event handlers."""
+from celery import shared_task
+from datetime import timedelta
+from django.db import transaction
+from django.utils import timezone
+
+from modules.leave.models import LeaveAuditEvent, LeavePolicy, LeaveSLAConfiguration, WorkflowTask
+from modules.leave.services.accounting import process_year_end
+from modules.leave.services.notifications import deliver_pending, enqueue
+from modules.leave.domain.state_machine import normalize_role
+
+
+@shared_task(name="leave.process_configured_year_end")
+def process_configured_year_end():
+    """Run the configured annual close once on its configured date."""
+    today = timezone.localdate()
+    policy = LeavePolicy.objects.filter(policy_key="current").first()
+    if not policy or (today.month, today.day) != (policy.year_end_month, policy.year_end_day):
+        return {"processed": False}
+    result = process_year_end(today.year)
+    return {"processed": True, **result}
+
+
+@shared_task(name="leave.deliver_notifications")
+def deliver_leave_notifications():
+    return deliver_pending()
+
+
+@shared_task(name="leave.process_sla_thresholds")
+def process_leave_sla_thresholds():
+    """Remind or escalate only tasks that remain pending at each threshold."""
+    now = timezone.now()
+    counts = {"reminded": 0, "escalated": 0}
+    ids = list(WorkflowTask.objects.filter(state=WorkflowTask.State.PENDING).values_list("id", flat=True))
+    for task_id in ids:
+        with transaction.atomic():
+            task = (WorkflowTask.objects.select_for_update().select_related("request")
+                    .filter(pk=task_id, state=WorkflowTask.State.PENDING).first())
+            if not task:
+                continue
+            config, _ = LeaveSLAConfiguration.objects.get_or_create(role=task.role)
+            activated = task.activated_at or task.created_at
+            age = now - activated
+            if task.reminder_sent_at is None and age >= timedelta(hours=config.reminder_after_hours):
+                enqueue(
+                    recipient_user_id=task.assigned_user_id, topic="task.reminder",
+                    dedupe_key=f"task:{task.pk}:reminder",
+                    subject="Reminder: ELM action is still pending",
+                    body=f"Leave request #{task.request_id} is still waiting for your {task.role.replace('_', ' ')} action.",
+                    payload={"task_id": task.pk, "request_id": task.request_id},
+                )
+                task.reminder_sent_at = now
+                task.save(update_fields=["reminder_sent_at"])
+                LeaveAuditEvent.objects.create(request=task.request, action="sla_reminder",
+                                               from_status=task.request.status, to_status=task.request.status,
+                                               details={"task_id": task.pk, "role": task.role})
+                counts["reminded"] += 1
+            if task.escalated_at is None and age >= timedelta(hours=config.escalate_after_hours):
+                old_role = task.role
+                recipient = config.escalation_user_id or task.assigned_user_id
+                enqueue(
+                    recipient_user_id=recipient, topic="task.escalation",
+                    dedupe_key=f"task:{task.pk}:escalation",
+                    subject="Escalation: ELM action remains pending",
+                    body=f"Leave request #{task.request_id} remains pending beyond the configured escalation threshold.",
+                    payload={"task_id": task.pk, "request_id": task.request_id, "role": old_role},
+                )
+                if config.escalation_user_id:
+                    task.assigned_user_id = config.escalation_user_id
+                if config.escalation_role:
+                    task.role = normalize_role(config.escalation_role)
+                task.escalated_at = now
+                task.save(update_fields=["assigned_user_id", "role", "escalated_at"])
+                LeaveAuditEvent.objects.create(request=task.request, action="sla_escalated",
+                                               from_status=task.request.status, to_status=task.request.status,
+                                               details={"task_id": task.pk, "from_role": old_role,
+                                                        "to_role": task.role,
+                                                        "recipient_user_id": recipient})
+                counts["escalated"] += 1
+    return counts
diff --git a/openapi/fusion-integrated.v1.yaml b/openapi/fusion-integrated.v1.yaml
index 850dd24a..012d251c 100644
--- a/openapi/fusion-integrated.v1.yaml
+++ b/openapi/fusion-integrated.v1.yaml
@@ -1674,8 +1674,766 @@ paths:
               schema:
                 $ref: '#/components/schemas/AcademicFilters'
           description: ''
+  /api/v1/leave/employees:
+    get:
+      operationId: leave_employees_list
+      summary: Search projected active Faculty and Staff for substitute nomination
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/categories:
+    get:
+      operationId: leave_categories_list
+      summary: List supported ELM categories
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/balances:
+    get:
+      operationId: leave_balances_list
+      summary: List the caller’s leave balances
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/accounts:
+    get:
+      operationId: leave_accounts_list
+      summary: List the caller’s leave-account history
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/requests:
+    get:
+      operationId: leave_requests_list
+      summary: List requests in the caller’s scope
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+    post:
+      operationId: leave_requests_create
+      summary: Create a leave draft
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '201':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}:
+    get:
+      operationId: leave_requests_retrieve
+      summary: Retrieve a leave request
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/submit:
+    post:
+      operationId: leave_requests_submit
+      summary: Validate and submit a draft
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/withdraw:
+    post:
+      operationId: leave_requests_withdraw
+      summary: Immediately withdraw a pending request
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/cancel:
+    post:
+      operationId: leave_requests_cancel
+      summary: Request pre-start cancellation
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/extend:
+    post:
+      operationId: leave_requests_extend
+      summary: Request an ongoing leave extension
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/resumption:
+    post:
+      operationId: leave_requests_resumption_create
+      summary: Submit actual resumption for review
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/print:
+    get:
+      operationId: leave_requests_print_retrieve
+      summary: Get a printable leave application
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      responses:
+        '200':
+          content:
+            text/html:
+              schema:
+                type: string
+          description: Printable leave application
+
+  /api/v1/leave/requests/{id}/substitute-response:
+    post:
+      operationId: leave_requests_substitute_response_create
+      summary: Accept or decline a substitute assignment
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/replace-substitute:
+    post:
+      operationId: leave_requests_replace_substitute_create
+      summary: Nominate a replacement after a decline
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/substitutions:
+    get:
+      operationId: leave_substitutions_list
+      summary: List substitute requests assigned to the caller
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/tasks:
+    get:
+      operationId: leave_tasks_list
+      summary: List the caller’s pending workflow tasks
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/tasks/{id}/decision:
+    post:
+      operationId: leave_tasks_decision_create
+      summary: Record a workflow decision
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/policy:
+    get:
+      operationId: leave_policy_retrieve
+      summary: Read current leave-policy parameters
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+    put:
+      operationId: leave_policy_update
+      summary: Update current leave-policy parameters
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/calendars:
+    get:
+      operationId: leave_calendars_list
+      summary: List published holiday calendars
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+
+  /api/v1/leave/calendars/drafts:
+    post:
+      operationId: leave_calendars_drafts_create
+      summary: Create a holiday-calendar draft
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/calendars/{id}/publish:
+    post:
+      operationId: leave_calendars_publish_create
+      summary: Publish a holiday-calendar revision
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/configuration/routes:
+    get:
+      operationId: leave_route_configurations_list
+      summary: List current authority routes
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+    post:
+      operationId: leave_route_configurations_create
+      summary: Create an authority route
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/configuration/routes/{id}:
+    get:
+      operationId: leave_route_configuration_retrieve
+      summary: Retrieve an authority route
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+    put:
+      operationId: leave_route_configuration_update
+      summary: Update an authority route
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/configuration/sla:
+    get:
+      operationId: leave_sla_configurations_list
+      summary: List workflow SLA thresholds
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
+    post:
+      operationId: leave_sla_configurations_create
+      summary: Create workflow SLA thresholds
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/configuration/sla/{id}:
+    get:
+      operationId: leave_sla_configuration_retrieve
+      summary: Retrieve workflow SLA thresholds
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+    put:
+      operationId: leave_sla_configuration_update
+      summary: Update workflow SLA thresholds
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/admin/offline-leave:
+    post:
+      operationId: leave_offline_leave_create
+      summary: Record already-sanctioned offline leave
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/admin/account-adjustments:
+    post:
+      operationId: leave_account_adjustment_create
+      summary: Record an authorized account adjustment
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ELMInput'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMObject'
+
+  /api/v1/leave/requests/{id}/history:
+    get:
+      operationId: leave_requests_history_list
+      summary: List the request audit history and recorded decisions
+      tags:
+      - leave
+      security:
+      - iamSession: []
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: integer
+      responses:
+        '200':
+          description: Request history
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ELMCollection'
 components:
   schemas:
+    ELMCollection:
+      type: object
+      properties:
+        count:
+          type: integer
+        next:
+          type: string
+          nullable: true
+        previous:
+          type: string
+          nullable: true
+        results:
+          type: array
+          items:
+            type: object
+            additionalProperties: true
+      required: [count, results]
+    ELMObject:
+      type: object
+      additionalProperties: true
+    ELMInput:
+      type: object
+      additionalProperties: true
     AcademicDirectory:
       type: object
       properties:
diff --git a/registry/permissions.json b/registry/permissions.json
index 213c8f24..1037997e 100644
--- a/registry/permissions.json
+++ b/registry/permissions.json
@@ -278,6 +278,202 @@
         "placement_cell.application.auto_withdraw",
         "placement_cell.offer.expire"
       ]
+    },
+    "leave_management": {
+      "grants": {
+        "Faculty": [
+          "leave_management.request.view_self",
+          "leave_management.balance.view_self",
+          "leave_management.request.create",
+          "leave_management.request.withdraw",
+          "leave_management.request.cancel",
+          "leave_management.substitute.respond"
+        ],
+        "Staff": [
+          "leave_management.request.view_self",
+          "leave_management.balance.view_self",
+          "leave_management.request.create",
+          "leave_management.request.withdraw",
+          "leave_management.request.cancel",
+          "leave_management.substitute.respond"
+        ],
+        "Unit Head": [
+          "leave_management.request.view_self",
+          "leave_management.balance.view_self",
+          "leave_management.workflow.task.view",
+          "leave_management.workflow.task.decide",
+          "leave_management.request.view_all"
+        ],
+        "Substitute": [
+          "leave_management.request.view_self",
+          "leave_management.substitute.respond"
+        ],
+        "Deputy Registrar (Estt.)": [
+          "leave_management.workflow.task.view",
+          "leave_management.workflow.task.decide",
+          "leave_management.request.view_all"
+        ],
+        "Dean": [
+          "leave_management.workflow.task.view",
+          "leave_management.workflow.task.decide",
+          "leave_management.request.view_all"
+        ],
+        "Registrar": [
+          "leave_management.workflow.task.view",
+          "leave_management.workflow.task.decide",
+          "leave_management.request.view_all"
+        ],
+        "Director": [
+          "leave_management.workflow.task.view",
+          "leave_management.workflow.task.decide",
+          "leave_management.request.view_all",
+          "leave_management.request.view_self",
+          "leave_management.balance.view_self",
+          "leave_management.request.create",
+          "leave_management.request.withdraw",
+          "leave_management.request.cancel"
+        ],
+        "Leave Administrator": [
+          "leave_management.request.view_all",
+          "leave_management.balance.view_all",
+          "leave_management.policy.view",
+          "leave_management.policy.manage",
+          "leave_management.calendar.view",
+          "leave_management.calendar.manage",
+          "leave_management.records.manage",
+          "leave_management.sla.manage",
+          "leave_management.routing.manage"
+        ]
+      },
+      "module_grants": [
+        "Faculty",
+        "Staff",
+        "Unit Head",
+        "Substitute",
+        "Deputy Registrar (Estt.)",
+        "Dean",
+        "Registrar",
+        "Director",
+        "Leave Administrator"
+      ],
+      "permissions": [
+        {
+          "code": "leave_management.request.view_self",
+          "label": "View own leave requests"
+        },
+        {
+          "code": "leave_management.request.view_all",
+          "label": "View all leave requests"
+        },
+        {
+          "code": "leave_management.request.create",
+          "label": "Create and submit own leave requests"
+        },
+        {
+          "code": "leave_management.request.withdraw",
+          "label": "Withdraw own pending requests"
+        },
+        {
+          "code": "leave_management.request.cancel",
+          "label": "Request cancellation of own approved leave"
+        },
+        {
+          "code": "leave_management.balance.view_self",
+          "label": "View own leave balances and account history"
+        },
+        {
+          "code": "leave_management.balance.view_all",
+          "label": "View employee leave balances"
+        },
+        {
+          "code": "leave_management.substitute.respond",
+          "label": "Accept or decline a substitute assignment"
+        },
+        {
+          "code": "leave_management.workflow.task.view",
+          "label": "View assigned leave workflow tasks"
+        },
+        {
+          "code": "leave_management.workflow.task.decide",
+          "label": "Review or decide assigned leave workflow tasks"
+        },
+        {
+          "code": "leave_management.policy.view",
+          "label": "View current leave policy"
+        },
+        {
+          "code": "leave_management.policy.manage",
+          "label": "Maintain current leave policy parameters"
+        },
+        {
+          "code": "leave_management.calendar.view",
+          "label": "View published holiday calendars"
+        },
+        {
+          "code": "leave_management.calendar.manage",
+          "label": "Maintain and publish holiday calendars"
+        },
+        {
+          "code": "leave_management.records.manage",
+          "label": "Maintain authorized leave records and enter already sanctioned offline leave"
+        },
+        {
+          "code": "leave_management.sla.manage",
+          "label": "Configure workflow reminder and escalation thresholds"
+        },
+        {
+          "code": "leave_management.routing.manage",
+          "label": "Maintain current authority routing configuration"
+        }
+      ],
+      "scope_permissions": [],
+      "system_permissions": [],
+      "nav": {
+        "base_path": "/leave",
+        "icon": "Calendar",
+        "items": [
+          {
+            "code": "leave.mine",
+            "label": "My Leave",
+            "icon": "Calendar",
+            "to": "/leave",
+            "required_permission": "leave_management.request.view_self",
+            "sort_order": 10
+          },
+          {
+            "code": "leave.tasks",
+            "label": "Leave Tasks",
+            "icon": "Checks",
+            "to": "/leave/tasks",
+            "required_permission": "leave_management.workflow.task.view",
+            "sort_order": 20
+          },
+          {
+            "code": "leave.substitutions",
+            "label": "Substitute Requests",
+            "icon": "UserCheck",
+            "to": "/leave/substitutions",
+            "required_permission": "leave_management.substitute.respond",
+            "sort_order": 25
+          },
+          {
+            "code": "leave.balances",
+            "label": "Leave Balances",
+            "icon": "Wallet",
+            "to": "/leave/balances",
+            "required_permission": "leave_management.balance.view_self",
+            "sort_order": 30
+          },
+          {
+            "code": "leave.calendar",
+            "label": "Holiday Calendar",
+            "icon": "CalendarBlank",
+            "to": "/leave/calendar",
+            "required_permission": "leave_management.calendar.view",
+            "sort_order": 40
+          }
+        ]
+      }
     }
   },
   "publisher": "integrated",