diff --git a/.importlinter b/.importlinter
index d964dc3c..ac2796ba 100644
--- a/.importlinter
+++ b/.importlinter
@@ -13,6 +13,7 @@ name = Modules may reach each other ONLY through contracts.py
 type = forbidden
 source_modules =
     modules.placement
+    modules.elm
     modules.directory
     modules.accesscontrol
 forbidden_modules =
@@ -21,6 +22,11 @@ forbidden_modules =
     modules.placement.selectors
     modules.placement.api
     modules.placement.domain
+    modules.elm.models
+    modules.elm.services
+    modules.elm.selectors
+    modules.elm.api
+    modules.elm.domain
     modules.directory.models
     modules.directory.services
     modules.directory.api
@@ -38,6 +44,7 @@ type = forbidden
 source_modules =
 # Every module's domain, not just the first one written.
     modules.placement.domain
+    modules.elm.domain
 forbidden_modules =
     django
     rest_framework
@@ -66,3 +73,13 @@ layers =
     modules.placement.selectors
     modules.placement.models
     modules.placement.domain
+
+[importlinter:contract:elm-layers]
+name = Layering inside elm
+type = layers
+layers =
+    modules.elm.api
+    modules.elm.services
+    modules.elm.selectors
+    modules.elm.models
+    modules.elm.domain
diff --git a/client/src/app/registry.ts b/client/src/app/registry.ts
index e76d32bf..62a76ddf 100644
--- a/client/src/app/registry.ts
+++ b/client/src/app/registry.ts
@@ -17,4 +17,9 @@ export const MODULE_REGISTRY: Record<string, ModuleManifest> = {
     basePath: "/placement",
     load: () => import("../modules/placement/routes"),
   },
+  elm: {
+    code: "elm",
+    basePath: "/elm",
+    load: () => import("../modules/elm/routes"),
+  },
 };
diff --git a/client/src/modules/elm/api/hooks.test.tsx b/client/src/modules/elm/api/hooks.test.tsx
new file mode 100644
index 00000000..852f15f8
--- /dev/null
+++ b/client/src/modules/elm/api/hooks.test.tsx
@@ -0,0 +1,60 @@
+/** The write hooks post to the right endpoint and refresh the module's data. */
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import * as download from "../../../lib/download";
+import { http } from "../../../lib/http";
+import { useDecide, useEmployeeSearch, usePrint, useWithdraw } from "./hooks";
+
+function setup() {
+  const qc = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  });
+  const invalidate = vi.spyOn(qc, "invalidateQueries");
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={qc}>{children}</QueryClientProvider>
+  );
+  return { wrapper, invalidate };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("elm hooks", () => {
+  it("records a decision against the queue endpoint and refreshes", async () => {
+    const post = vi.spyOn(http, "post").mockResolvedValue({ data: { id: 7 } });
+    const { wrapper, invalidate } = setup();
+    const { result } = renderHook(() => useDecide(), { wrapper });
+    result.current.mutate({ id: 7, event: "reject", note: "short staffed" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(post).toHaveBeenCalledWith("/elm/queue/7/decide",
+      { event: "reject", note: "short staffed" });
+    expect(invalidate).toHaveBeenCalledWith({ queryKey: ["elm"] });
+  });
+
+  it("withdraws with a reason only", async () => {
+    const post = vi.spyOn(http, "post").mockResolvedValue({ data: {} });
+    const { wrapper } = setup();
+    const { result } = renderHook(() => useWithdraw(), { wrapper });
+    result.current.mutate({ id: 3, reason: "plans changed" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(post).toHaveBeenCalledWith("/elm/requests/3/withdraw", { reason: "plans changed" });
+  });
+
+  it("does not search the directory for a single letter", () => {
+    const get = vi.spyOn(http, "get");
+    const { wrapper } = setup();
+    renderHook(() => useEmployeeSearch("a"), { wrapper });
+    expect(get).not.toHaveBeenCalled();
+  });
+
+  it("saves the printable application instead of navigating to it", async () => {
+    vi.spyOn(http, "get").mockResolvedValue({ data: new Blob(["x"]), headers: {} });
+    const save = vi.spyOn(download, "saveBlob").mockImplementation(() => undefined);
+    const { wrapper } = setup();
+    const { result } = renderHook(() => usePrint(), { wrapper });
+    result.current.mutate(12);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(save).toHaveBeenCalledWith(expect.any(Blob), "leave-12.txt");
+  });
+});
diff --git a/client/src/modules/elm/api/hooks.ts b/client/src/modules/elm/api/hooks.ts
new file mode 100644
index 00000000..baa68ddc
--- /dev/null
+++ b/client/src/modules/elm/api/hooks.ts
@@ -0,0 +1,154 @@
+/** Data access for ELM. Every mutation invalidates the whole module key. */
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { saveBlob } from "../../../lib/download";
+import { http } from "../../../lib/http";
+import type {
+  Balance, CalendarEntry, CalendarVersion, Employee, LeaveDetail, LeaveInput,
+  LeaveRequest, Notification, OfflineInput, OfflineRecord, Page, PolicyVersion,
+} from "./types";
+
+const KEY = "elm";
+export const keys = {
+  mine: () => [KEY, "mine"] as const,
+  detail: (id: number) => [KEY, "detail", id] as const,
+  balances: () => [KEY, "balances"] as const,
+  account: (uid: number) => [KEY, "account", uid] as const,
+  substitutions: () => [KEY, "substitutions"] as const,
+  queue: () => [KEY, "queue"] as const,
+  resumptions: () => [KEY, "resumptions"] as const,
+  policies: () => [KEY, "policies"] as const,
+  calendars: () => [KEY, "calendars"] as const,
+  offline: () => [KEY, "offline"] as const,
+  employees: (q: string) => [KEY, "employees", q] as const,
+  notifications: () => [KEY, "notifications"] as const,
+};
+
+function useInvalidate() {
+  const qc = useQueryClient();
+  return () => qc.invalidateQueries({ queryKey: [KEY] });
+}
+
+function list<T>(key: readonly unknown[], url: string) {
+  return {
+    queryKey: key,
+    queryFn: async () => (await http.get<Page<T>>(url)).data,
+  };
+}
+
+export const useMyRequests = () => useQuery(list<LeaveRequest>(keys.mine(), "/elm/requests"));
+export const useSubstitutions = () =>
+  useQuery(list<LeaveRequest>(keys.substitutions(), "/elm/substitutions"));
+export const useQueue = () => useQuery(list<LeaveRequest>(keys.queue(), "/elm/queue"));
+export const useResumptions = () =>
+  useQuery(list<LeaveRequest>(keys.resumptions(), "/elm/resumptions"));
+export const usePolicies = () =>
+  useQuery(list<PolicyVersion>(keys.policies(), "/elm/admin/policies"));
+export const useCalendars = () =>
+  useQuery(list<CalendarVersion>(keys.calendars(), "/elm/admin/calendars"));
+export const useOfflineRecords = () =>
+  useQuery(list<OfflineRecord>(keys.offline(), "/elm/admin/offline"));
+export const useNotifications = () =>
+  useQuery(list<Notification>(keys.notifications(), "/elm/notifications"));
+
+export function useRequest(id: number | null) {
+  return useQuery({
+    queryKey: keys.detail(id ?? 0),
+    queryFn: async () => (await http.get<LeaveDetail>(`/elm/requests/${id}`)).data,
+    enabled: id != null,
+  });
+}
+
+export function useBalances() {
+  return useQuery({
+    queryKey: keys.balances(),
+    queryFn: async () => (await http.get<Balance>("/elm/balances")).data,
+  });
+}
+
+export function useAccount(userId: number | null) {
+  return useQuery({
+    queryKey: keys.account(userId ?? 0),
+    queryFn: async () =>
+      (await http.get<Balance>("/elm/admin/accounts", { params: { user_id: userId } })).data,
+    enabled: userId != null,
+    retry: false,
+  });
+}
+
+export function useEmployeeSearch(q: string) {
+  return useQuery({
+    queryKey: keys.employees(q),
+    queryFn: async () =>
+      (await http.get<{ results: Employee[] }>("/elm/employees", { params: { q } }))
+        .data.results,
+    enabled: q.trim().length >= 2,
+    staleTime: 60_000,
+  });
+}
+
+function usePost<V>(url: (v: V) => string, body: (v: V) => unknown = (v) => v) {
+  const invalidate = useInvalidate();
+  return useMutation({
+    mutationFn: async (v: V) => (await http.post(url(v), body(v))).data,
+    onSuccess: invalidate,
+  });
+}
+
+export const useApply = () =>
+  usePost<LeaveInput>(() => "/elm/requests");
+export const useModify = () =>
+  usePost<{ id: number; data: LeaveInput }>((v) => `/elm/requests/${v.id}/modify`,
+    (v) => v.data);
+export const useWithdraw = () =>
+  usePost<{ id: number; reason: string }>((v) => `/elm/requests/${v.id}/withdraw`,
+    (v) => ({ reason: v.reason }));
+export const useCancel = () =>
+  usePost<{ id: number; reason: string }>((v) => `/elm/requests/${v.id}/cancel`,
+    (v) => ({ reason: v.reason }));
+export const useRenominate = () =>
+  usePost<{ id: number; substitute_user_id: number; responsibility: string }>(
+    (v) => `/elm/requests/${v.id}/substitute`,
+    (v) => ({ substitute_user_id: v.substitute_user_id, responsibility: v.responsibility }));
+export const useExtend = () =>
+  usePost<{ id: number; end_date: string; purpose: string;
+    substitute_user_id: number | null }>(
+    (v) => `/elm/requests/${v.id}/extend`,
+    (v) => ({ end_date: v.end_date, purpose: v.purpose,
+      substitute_user_id: v.substitute_user_id }));
+export const useResume = () =>
+  usePost<{ id: number; actual_return_date: string; note: string }>(
+    (v) => `/elm/requests/${v.id}/resume`,
+    (v) => ({ actual_return_date: v.actual_return_date, note: v.note }));
+export const useRespondSubstitution = () =>
+  usePost<{ id: number; accept: boolean; note: string }>(
+    (v) => `/elm/substitutions/${v.id}/respond`,
+    (v) => ({ accept: v.accept, note: v.note }));
+export const useDecide = () =>
+  usePost<{ id: number; event: string; note: string }>(
+    (v) => `/elm/queue/${v.id}/decide`, (v) => ({ event: v.event, note: v.note }));
+export const useVerify = () =>
+  usePost<{ id: number; verified: boolean; note: string }>(
+    (v) => `/elm/resumptions/${v.id}/verify`,
+    (v) => ({ verified: v.verified, note: v.note }));
+export const useCreatePolicy = () =>
+  usePost<Omit<PolicyVersion, "id" | "status" | "published_at" | "created_at">>(
+    () => "/elm/admin/policies");
+export const usePublishPolicy = () =>
+  usePost<number>((id) => `/elm/admin/policies/${id}/publish`, () => ({}));
+export const useCreateCalendar = () =>
+  usePost<{ name: string; effective_from: string; entries: CalendarEntry[] }>(
+    () => "/elm/admin/calendars");
+export const usePublishCalendar = () =>
+  usePost<number>((id) => `/elm/admin/calendars/${id}/publish`, () => ({}));
+export const useRecordOffline = () =>
+  usePost<OfflineInput>(() => "/elm/admin/offline");
+
+/** EL-UC-013: fetched, not navigated to, so a refusal stays in the app. */
+export function usePrint() {
+  return useMutation({
+    mutationFn: async (id: number) => {
+      const res = await http.get(`/elm/requests/${id}/print`, { responseType: "blob" });
+      saveBlob(res.data as Blob, `leave-${id}.txt`);
+    },
+  });
+}
diff --git a/client/src/modules/elm/api/types.ts b/client/src/modules/elm/api/types.ts
new file mode 100644
index 00000000..f0b66a1b
--- /dev/null
+++ b/client/src/modules/elm/api/types.ts
@@ -0,0 +1,175 @@
+/** Mirrors modules/elm/api/serializers.py. */
+export interface Page<T> {
+  results: T[];
+  next: string | null;
+  previous: string | null;
+}
+
+export type Category = "CL" | "RH" | "SCL" | "EL" | "COL" | "VL";
+
+export const CATEGORY_LABELS: Record<Category, string> = {
+  CL: "Casual Leave",
+  RH: "Restricted Holiday",
+  SCL: "Special Casual Leave",
+  EL: "Earned Leave",
+  COL: "Commuted Leave",
+  VL: "Vacation Leave",
+};
+
+export interface RouteStep {
+  step: "unit_head" | "establishment" | "sanction" | "director";
+  role: string;
+}
+
+export interface LeaveRequest {
+  id: number;
+  kind: "leave" | "extension" | "offline";
+  parent_id: number | null;
+  user_id: number;
+  applicant_name: string;
+  applicant_kind: string;
+  applicant_unit: string;
+  category: Category;
+  category_label: string;
+  start_date: string;
+  end_date: string;
+  half: "" | "first" | "second";
+  days: string;
+  purpose: string;
+  medical_evidence: string;
+  station_leave: boolean;
+  station_from: string | null;
+  station_to: string | null;
+  station_address: string;
+  substitute_user_id: number | null;
+  substitute_name: string;
+  substitute_status: string;
+  responsibility: string;
+  status: string;
+  route: RouteStep[];
+  stage: number;
+  current_role: string;
+  recommendation: string;
+  decision_note: string;
+  decided_at: string | null;
+  actual_return_date: string | null;
+  resumption_note: string;
+  allowed_decisions: string[];
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Transition {
+  from_status: string;
+  to_status: string;
+  event: string;
+  actor_role: string;
+  note: string;
+  at: string;
+}
+
+export interface LeaveDetail extends LeaveRequest {
+  history: Transition[];
+}
+
+export interface LeaveInput {
+  category: Category;
+  start_date: string;
+  end_date: string;
+  half: "" | "first" | "second";
+  purpose: string;
+  medical_evidence: string;
+  station_leave: boolean;
+  station_from: string | null;
+  station_to: string | null;
+  station_address: string;
+  substitute_user_id: number | null;
+  responsibility: string;
+}
+
+export interface LedgerEntry {
+  id: number;
+  category: Category;
+  entry_type: string;
+  delta: string;
+  year: number;
+  request_id: number | null;
+  note: string;
+  at: string;
+}
+
+export interface Balance {
+  user_id: number;
+  display_name?: string;
+  balances: Record<Category, string>;
+  pending: Record<Category, string>;
+  history: LedgerEntry[];
+}
+
+export interface Employee {
+  user_id: number;
+  display_name: string;
+  username: string;
+  kind: string;
+  department: string;
+}
+
+export interface PolicyVersion {
+  id: number;
+  name: string;
+  params: Record<string, unknown>;
+  hierarchy: Record<string, unknown>;
+  effective_from: string;
+  status: "draft" | "published";
+  published_at: string | null;
+  created_at: string;
+}
+
+export interface CalendarEntry {
+  kind: "closed_holiday" | "restricted_holiday" | "vacation";
+  name: string;
+  start_date: string;
+  end_date: string;
+}
+
+export interface CalendarVersion {
+  id: number;
+  name: string;
+  effective_from: string;
+  status: "draft" | "published";
+  published_at: string | null;
+  entries: CalendarEntry[];
+  created_at: string;
+}
+
+export interface OfflineInput {
+  user_id: number;
+  category: Category;
+  start_date: string;
+  end_date: string;
+  half: "" | "first" | "second";
+  purpose: string;
+  sanction_reference: string;
+  sanctioned_by: string;
+  sanctioned_on: string;
+  evidence_note: string;
+}
+
+export interface OfflineRecord {
+  id: number;
+  sanction_reference: string;
+  sanctioned_by: string;
+  sanctioned_on: string;
+  evidence_note: string;
+  recorded_by_user_id: number;
+  created_at: string;
+  leave: LeaveRequest;
+}
+
+export interface Notification {
+  id: number;
+  message: string;
+  request_id: number | null;
+  created_at: string;
+  read_at: string | null;
+}
diff --git a/client/src/modules/elm/components/BalanceView.tsx b/client/src/modules/elm/components/BalanceView.tsx
new file mode 100644
index 00000000..fa24a695
--- /dev/null
+++ b/client/src/modules/elm/components/BalanceView.tsx
@@ -0,0 +1,40 @@
+import { Card, SimpleGrid, Stack, Text } from "@mantine/core";
+import { DataTable } from "../../../ui/components/DataTable";
+import { CATEGORY_LABELS, type Balance, type Category } from "../api/types";
+
+export function BalanceView({ data, loading }: { data?: Balance; loading: boolean }) {
+  const cats = Object.keys(CATEGORY_LABELS) as Category[];
+  return (
+    <Stack gap="lg">
+      <SimpleGrid cols={{ base: 2, sm: 3, md: 6 }}>
+        {cats.map((c) => (
+          <Card key={c} withBorder padding="md">
+            <Text size="xs" c="dimmed">{CATEGORY_LABELS[c]}</Text>
+            <Text fw={700} size="xl">{data ? Number(data.balances[c]) : "—"}</Text>
+            {data && Number(data.pending[c]) > 0 && (
+              <Text size="xs" c="orange">{Number(data.pending[c])} pending</Text>
+            )}
+          </Card>
+        ))}
+      </SimpleGrid>
+
+      <Card withBorder padding="md">
+        <Text fw={600} mb="sm">Leave-account history</Text>
+        <DataTable
+          rows={data?.history ?? []} loading={loading} rowKey={(r) => r.id}
+          empty={{ title: "No entries yet",
+            description: "Credits and debits appear here as they are posted." }}
+          columns={[
+            { key: "at", header: "When", render: (r) => new Date(r.at).toLocaleDateString() },
+            { key: "category", header: "Leave", render: (r) => r.category },
+            { key: "type", header: "Entry", render: (r) => r.entry_type.replace(/_/g, " ") },
+            { key: "delta", header: "Days", align: "right",
+              render: (r) => (
+                <Text size="sm" c={Number(r.delta) < 0 ? "red" : "green"}>{r.delta}</Text>) },
+            { key: "note", header: "Note", render: (r) => r.note },
+          ]}
+        />
+      </Card>
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/components/EmployeePicker.tsx b/client/src/modules/elm/components/EmployeePicker.tsx
new file mode 100644
index 00000000..bb7840f4
--- /dev/null
+++ b/client/src/modules/elm/components/EmployeePicker.tsx
@@ -0,0 +1,29 @@
+import { Select } from "@mantine/core";
+import { useState } from "react";
+import { useEmployeeSearch } from "../api/hooks";
+
+/** Faculty and staff only; the server never returns students or the caller. */
+export function EmployeePicker({ value, onChange, label, description }: {
+  value: number | null;
+  onChange: (id: number | null) => void;
+  label: string;
+  description?: string;
+}) {
+  const [q, setQ] = useState("");
+  const { data = [], isFetching } = useEmployeeSearch(q);
+  const options = data.map((e) => ({
+    value: String(e.user_id),
+    label: `${e.display_name} (${e.username}${e.department ? `, ${e.department}` : ""})`,
+  }));
+  return (
+    <Select
+      label={label} description={description} searchable clearable
+      placeholder="Type at least two letters of a name"
+      data={options} value={value != null ? String(value) : null}
+      onChange={(v) => onChange(v ? Number(v) : null)}
+      searchValue={q} onSearchChange={setQ}
+      nothingFoundMessage={isFetching ? "Searching…" : q.length < 2 ? "" : "No match"}
+      filter={({ options: o }) => o}
+    />
+  );
+}
diff --git a/client/src/modules/elm/components/LeaveForm.tsx b/client/src/modules/elm/components/LeaveForm.tsx
new file mode 100644
index 00000000..27fc0097
--- /dev/null
+++ b/client/src/modules/elm/components/LeaveForm.tsx
@@ -0,0 +1,113 @@
+import {
+  Checkbox, Group, Select, SimpleGrid, Stack, Textarea, TextInput,
+} from "@mantine/core";
+import { CATEGORY_LABELS, type Category, type LeaveInput } from "../api/types";
+import { EmployeePicker } from "./EmployeePicker";
+
+export const EMPTY_LEAVE: LeaveInput = {
+  category: "CL", start_date: "", end_date: "", half: "", purpose: "",
+  medical_evidence: "", station_leave: false, station_from: null, station_to: null,
+  station_address: "", substitute_user_id: null, responsibility: "",
+};
+
+export function missingReason(v: LeaveInput): string {
+  if (!v.start_date || !v.end_date) return "Choose the leave dates.";
+  if (!v.purpose.trim()) return "Give the purpose of the leave.";
+  if (v.station_leave && (!v.station_from || !v.station_to || !v.station_address.trim())) {
+    return "Station Leave needs the dates away and an address.";
+  }
+  return "";
+}
+
+/** One form for apply and modify, so the two can never ask different questions. */
+export function LeaveForm({ value, onChange }: {
+  value: LeaveInput;
+  onChange: (v: LeaveInput) => void;
+}) {
+  const set = <K extends keyof LeaveInput>(k: K, v: LeaveInput[K]) =>
+    onChange({ ...value, [k]: v });
+
+  return (
+    <Stack gap="md">
+      <SimpleGrid cols={{ base: 1, sm: 2 }}>
+        <Select
+          label="Leave category" required allowDeselect={false}
+          data={Object.entries(CATEGORY_LABELS).map(([k, l]) => ({ value: k, label: l }))}
+          value={value.category}
+          onChange={(c) => onChange({ ...value, category: (c ?? "CL") as Category,
+            half: c === "CL" ? value.half : "" })}
+        />
+        {value.category === "CL" && (
+          <Select
+            label="Half day" clearable placeholder="Full day"
+            data={[{ value: "first", label: "First half" },
+              { value: "second", label: "Second half" }]}
+            value={value.half || null}
+            onChange={(h) => onChange({ ...value, half: (h ?? "") as LeaveInput["half"],
+              end_date: h ? value.start_date : value.end_date })}
+          />
+        )}
+      </SimpleGrid>
+
+      <SimpleGrid cols={{ base: 1, sm: 2 }}>
+        <TextInput
+          type="date" label="From" required value={value.start_date}
+          onChange={(e) => onChange({ ...value, start_date: e.currentTarget.value,
+            end_date: value.half ? e.currentTarget.value : value.end_date })}
+        />
+        <TextInput
+          type="date" label="To" required value={value.end_date} disabled={!!value.half}
+          onChange={(e) => set("end_date", e.currentTarget.value)}
+        />
+      </SimpleGrid>
+
+      <Textarea
+        label="Purpose / reason" required autosize minRows={2} value={value.purpose}
+        onChange={(e) => set("purpose", e.currentTarget.value)}
+      />
+
+      {value.category === "COL" && (
+        <TextInput
+          label="Medical certificate reference" value={value.medical_evidence}
+          description="Commuted Leave is medical leave and needs supporting evidence."
+          onChange={(e) => set("medical_evidence", e.currentTarget.value)}
+        />
+      )}
+
+      <Checkbox
+        label="I will be outside Jabalpur (Station Leave)" checked={value.station_leave}
+        onChange={(e) => set("station_leave", e.currentTarget.checked)}
+      />
+      {value.station_leave && (
+        <Stack gap="sm">
+          <Group grow>
+            <TextInput
+              type="date" label="Away from" value={value.station_from ?? ""}
+              onChange={(e) => set("station_from", e.currentTarget.value || null)}
+            />
+            <TextInput
+              type="date" label="Away until" value={value.station_to ?? ""}
+              onChange={(e) => set("station_to", e.currentTarget.value || null)}
+            />
+          </Group>
+          <TextInput
+            label="Address while away" value={value.station_address}
+            onChange={(e) => set("station_address", e.currentTarget.value)}
+          />
+        </Stack>
+      )}
+
+      <EmployeePicker
+        label="Substitute (optional)" value={value.substitute_user_id}
+        description="If you nominate someone, your request waits for their consent."
+        onChange={(id) => set("substitute_user_id", id)}
+      />
+      {value.substitute_user_id != null && (
+        <TextInput
+          label="Responsibility to cover" value={value.responsibility}
+          onChange={(e) => set("responsibility", e.currentTarget.value)}
+        />
+      )}
+    </Stack>
+  );
+}
diff --git a/client/src/modules/elm/components/LeaveTable.tsx b/client/src/modules/elm/components/LeaveTable.tsx
new file mode 100644
index 00000000..f3491449
--- /dev/null
+++ b/client/src/modules/elm/components/LeaveTable.tsx
@@ -0,0 +1,46 @@
+import { Group, Text } from "@mantine/core";
+import { FaCalendarAlt } from "react-icons/fa";
+import { DataTable, type Column } from "../../../ui/components/DataTable";
+import { StatusBadge } from "../../../ui/components/StatusBadge";
+import type { LeaveRequest } from "../api/types";
+
+export function LeaveTable({ rows, loading, actions, showApplicant, empty }: {
+  rows: LeaveRequest[];
+  loading: boolean;
+  actions?: (r: LeaveRequest) => React.ReactNode;
+  showApplicant?: boolean;
+  empty: { title: string; description?: string };
+}) {
+  const columns: Column<LeaveRequest>[] = [
+    { key: "id", header: "#", render: (r) => <Text size="sm">{r.id}</Text> },
+    ...(showApplicant ? [{
+      key: "applicant", header: "Applicant",
+      render: (r: LeaveRequest) => (
+        <Text size="sm">{r.applicant_name || r.user_id}
+          <Text span c="dimmed" size="xs"> {r.applicant_unit}</Text></Text>),
+    }] : []),
+    { key: "category", header: "Leave",
+      render: (r) => (
+        <Text size="sm">{r.category_label}{r.kind === "extension" ? " (extension)" : ""}
+          {r.half ? ` · ${r.half} half` : ""}</Text>) },
+    { key: "period", header: "Period",
+      render: (r) => <Text size="sm">{r.start_date} → {r.end_date} ({r.days} d)</Text> },
+    { key: "status", header: "Status",
+      render: (r) => (
+        <Group gap={6}>
+          <StatusBadge status={r.status} />
+          {r.current_role && <Text size="xs" c="dimmed">at {r.current_role}</Text>}
+          {r.recommendation && (
+            <Text size="xs" c="dimmed">{r.recommendation.replace("_", " ")}</Text>)}
+        </Group>) },
+    ...(actions ? [{ key: "actions", header: "", align: "right" as const,
+      render: (r: LeaveRequest) => <Group gap={6} justify="flex-end">{actions(r)}</Group> }]
+      : []),
+  ];
+  return (
+    <DataTable
+      rows={rows} columns={columns} loading={loading} rowKey={(r) => r.id}
+      empty={{ icon: FaCalendarAlt, ...empty }}
+    />
+  );
+}
diff --git a/client/src/modules/elm/components/NoteModal.tsx b/client/src/modules/elm/components/NoteModal.tsx
new file mode 100644
index 00000000..2594d671
--- /dev/null
+++ b/client/src/modules/elm/components/NoteModal.tsx
@@ -0,0 +1,35 @@
+import { Textarea } from "@mantine/core";
+import { useEffect, useState } from "react";
+import { FormModal } from "../../../ui/components/FormModal";
+
+/** A confirmation that may carry a reason; `required` blocks an empty one. */
+export function NoteModal({ opened, title, subtitle, label, required, submitLabel, danger,
+  submitting, error, onClose, onSubmit, children }: {
+  opened: boolean;
+  title: string;
+  subtitle?: string;
+  label: string;
+  required?: boolean;
+  submitLabel: string;
+  danger?: boolean;
+  submitting?: boolean;
+  error?: unknown;
+  onClose: () => void;
+  onSubmit: (note: string) => void;
+  children?: React.ReactNode;
+}) {
+  const [note, setNote] = useState("");
+  useEffect(() => { if (opened) setNote(""); }, [opened]);
+  return (
+    <FormModal
+      opened={opened} onClose={onClose} title={title} subtitle={subtitle}
+      onSubmit={() => onSubmit(note)} submitLabel={submitLabel} danger={danger}
+      submitting={submitting} error={error} size="md"
+      disabled={required && !note.trim()} disabledReason="A reason is required."
+    >
+      {children}
+      <Textarea label={label} autosize minRows={2} value={note}
+        onChange={(e) => setNote(e.currentTarget.value)} required={required} />
+    </FormModal>
+  );
+}
diff --git a/client/src/modules/elm/pages/AccountsPage.tsx b/client/src/modules/elm/pages/AccountsPage.tsx
new file mode 100644
index 00000000..697797b0
--- /dev/null
+++ b/client/src/modules/elm/pages/AccountsPage.tsx
@@ -0,0 +1,29 @@
+import { Card, Container, Stack, Text } from "@mantine/core";
+import { useState } from "react";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useAccount } from "../api/hooks";
+import { BalanceView } from "../components/BalanceView";
+import { EmployeePicker } from "../components/EmployeePicker";
+
+export default function AccountsPage() {
+  const [uid, setUid] = useState<number | null>(null);
+  const { data, isFetching, error } = useAccount(uid);
+  return (
+    <Container size="xl">
+      <PageHeader title="Leave Accounts" subtitle="Any employee's balances and history" />
+      <Card withBorder padding="md" mb="lg">
+        <EmployeePicker label="Employee" value={uid} onChange={setUid} />
+      </Card>
+      {error && <ErrorState error={error} />}
+      {uid == null ? (
+        <Text c="dimmed" size="sm">Choose an employee to see their leave account.</Text>
+      ) : (
+        <Stack>
+          {data?.display_name && <Text fw={600}>{data.display_name}</Text>}
+          <BalanceView data={data} loading={isFetching} />
+        </Stack>
+      )}
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/ApplyPage.tsx b/client/src/modules/elm/pages/ApplyPage.tsx
new file mode 100644
index 00000000..a165378e
--- /dev/null
+++ b/client/src/modules/elm/pages/ApplyPage.tsx
@@ -0,0 +1,43 @@
+import { Button, Card, Container, Group, Text } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { errorMessage } from "../../../lib/http";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useApply } from "../api/hooks";
+import { EMPTY_LEAVE, LeaveForm, missingReason } from "../components/LeaveForm";
+
+export default function ApplyPage() {
+  const [value, setValue] = useState(EMPTY_LEAVE);
+  const apply = useApply();
+  const navigate = useNavigate();
+  const missing = missingReason(value);
+
+  function submit() {
+    apply.mutate(value, {
+      onSuccess: () => {
+        notifications.show({ color: "green", title: "Leave submitted",
+          message: "Track it under My Leave." });
+        navigate("../mine");
+      },
+      onError: (e) => notifications.show({ color: "red", title: "Could not submit",
+        message: errorMessage(e) }),
+    });
+  }
+
+  return (
+    <Container size="md">
+      <PageHeader title="Apply for Leave"
+        subtitle="Balances, overlap and calendar rules are checked when you submit" />
+      <Card withBorder padding="lg">
+        <LeaveForm value={value} onChange={setValue} />
+        <Group justify="space-between" mt="lg">
+          <Text size="xs" c="dimmed">{missing}</Text>
+          <Button onClick={submit} loading={apply.isPending} disabled={!!missing}>
+            Submit application
+          </Button>
+        </Group>
+      </Card>
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/BalancesPage.tsx b/client/src/modules/elm/pages/BalancesPage.tsx
new file mode 100644
index 00000000..c372b25c
--- /dev/null
+++ b/client/src/modules/elm/pages/BalancesPage.tsx
@@ -0,0 +1,17 @@
+import { Container } from "@mantine/core";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useBalances } from "../api/hooks";
+import { BalanceView } from "../components/BalanceView";
+
+export default function BalancesPage() {
+  const { data, isPending, error } = useBalances();
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+  return (
+    <Container size="xl">
+      <PageHeader title="Balances & History"
+        subtitle="Current balances, pending reservations and every posted entry" />
+      <BalanceView data={data} loading={isPending} />
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/CalendarPage.tsx b/client/src/modules/elm/pages/CalendarPage.tsx
new file mode 100644
index 00000000..d2ba78c8
--- /dev/null
+++ b/client/src/modules/elm/pages/CalendarPage.tsx
@@ -0,0 +1,94 @@
+import {
+  ActionIcon, Badge, Button, Card, Container, Group, Select, Stack, Text, TextInput,
+} from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { FaTrash } from "react-icons/fa";
+import { errorMessage } from "../../../lib/http";
+import { DataTable } from "../../../ui/components/DataTable";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { FormModal } from "../../../ui/components/FormModal";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useCalendars, useCreateCalendar, usePublishCalendar } from "../api/hooks";
+import type { CalendarEntry } from "../api/types";
+
+const KINDS = [
+  { value: "closed_holiday", label: "Closed holiday" },
+  { value: "restricted_holiday", label: "Restricted holiday" },
+  { value: "vacation", label: "Vacation period" },
+];
+
+export default function CalendarPage() {
+  const { data, isPending, error } = useCalendars();
+  const create = useCreateCalendar();
+  const publish = usePublishCalendar();
+  const [draft, setDraft] = useState<{ name: string; from: string;
+    entries: CalendarEntry[] } | null>(null);
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  const setEntry = (i: number, e: Partial<CalendarEntry>) => draft && setDraft({
+    ...draft, entries: draft.entries.map((x, j) => (j === i ? { ...x, ...e } : x)) });
+
+  return (
+    <Container size="xl">
+      <PageHeader title="Holiday Calendar"
+        subtitle="Closed holidays, Restricted Holidays and vacation periods"
+        action={<Button onClick={() => setDraft({ name: "", from: "", entries: [] })}>
+          New version</Button>} />
+      <Card withBorder padding="md">
+        <DataTable rows={data?.results ?? []} loading={isPending} rowKey={(r) => r.id}
+          empty={{ title: "No calendar published",
+            description: "RH and VL requests are refused until one is published." }}
+          columns={[
+            { key: "name", header: "Version", render: (r) => <Text size="sm">#{r.id} {r.name}</Text> },
+            { key: "from", header: "Effective from", render: (r) => r.effective_from },
+            { key: "n", header: "Entries", render: (r) => r.entries.length },
+            { key: "status", header: "Status",
+              render: (r) => <Badge color={r.status === "published" ? "green" : "gray"}
+                variant="light">{r.status}</Badge> },
+            { key: "act", header: "", align: "right",
+              render: (r) => r.status === "draft" && (
+                <Button size="xs" onClick={() => publish.mutate(r.id, {
+                  onError: (e) => notifications.show({ color: "red", title: "Not published",
+                    message: errorMessage(e) }) })}>Publish</Button>) },
+          ]} />
+      </Card>
+
+      {draft && (
+        <FormModal opened title="New calendar version" onClose={() => setDraft(null)}
+          size="xl" submitting={create.isPending} error={create.error}
+          disabled={!draft.name || !draft.from} submitLabel="Save draft"
+          onSubmit={() => create.mutate({ name: draft.name, effective_from: draft.from,
+            entries: draft.entries }, { onSuccess: () => setDraft(null) })}>
+          <Stack>
+            <Group grow>
+              <TextInput label="Name" value={draft.name}
+                onChange={(e) => setDraft({ ...draft, name: e.currentTarget.value })} />
+              <TextInput type="date" label="Effective from" value={draft.from}
+                onChange={(e) => setDraft({ ...draft, from: e.currentTarget.value })} />
+            </Group>
+            {draft.entries.map((e, i) => (
+              <Group key={i} align="flex-end" wrap="nowrap">
+                <Select data={KINDS} value={e.kind} allowDeselect={false} w={170}
+                  onChange={(k) => setEntry(i, { kind: k as CalendarEntry["kind"] })} />
+                <TextInput placeholder="Name" value={e.name} style={{ flex: 1 }}
+                  onChange={(x) => setEntry(i, { name: x.currentTarget.value })} />
+                <TextInput type="date" value={e.start_date}
+                  onChange={(x) => setEntry(i, { start_date: x.currentTarget.value })} />
+                <TextInput type="date" value={e.end_date}
+                  onChange={(x) => setEntry(i, { end_date: x.currentTarget.value })} />
+                <ActionIcon variant="subtle" color="red" aria-label="Remove"
+                  onClick={() => setDraft({ ...draft,
+                    entries: draft.entries.filter((_, j) => j !== i) })}>
+                  <FaTrash size={12} /></ActionIcon>
+              </Group>
+            ))}
+            <Button variant="light" onClick={() => setDraft({ ...draft, entries: [
+              ...draft.entries, { kind: "closed_holiday", name: "", start_date: "",
+                end_date: "" }] })}>Add entry</Button>
+          </Stack>
+        </FormModal>
+      )}
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/MyLeavePage.tsx b/client/src/modules/elm/pages/MyLeavePage.tsx
new file mode 100644
index 00000000..5874f8b4
--- /dev/null
+++ b/client/src/modules/elm/pages/MyLeavePage.tsx
@@ -0,0 +1,187 @@
+import {
+  Button, Card, Container, Drawer, Stack, Text, TextInput, Timeline,
+} from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { FormModal } from "../../../ui/components/FormModal";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import {
+  useCancel, useExtend, useModify, useMyRequests, usePrint, useRenominate, useRequest,
+  useResume, useWithdraw,
+} from "../api/hooks";
+import type { LeaveInput, LeaveRequest } from "../api/types";
+import { EmployeePicker } from "../components/EmployeePicker";
+import { LeaveForm, missingReason } from "../components/LeaveForm";
+import { LeaveTable } from "../components/LeaveTable";
+import { NoteModal } from "../components/NoteModal";
+
+const PENDING = new Set(["awaiting_substitute", "substitute_declined", "awaiting_unit_head",
+  "awaiting_establishment", "awaiting_sanction", "awaiting_director"]);
+const LONG = new Set(["EL", "COL", "VL"]);
+const today = () => new Date().toISOString().slice(0, 10);
+
+type Dialog =
+  | { kind: "withdraw" | "cancel"; row: LeaveRequest }
+  | { kind: "modify"; row: LeaveRequest; value: LeaveInput }
+  | { kind: "renominate"; row: LeaveRequest; sub: number | null }
+  | { kind: "extend"; row: LeaveRequest; end: string; purpose: string }
+  | { kind: "resume"; row: LeaveRequest; date: string }
+  | null;
+
+function toInput(r: LeaveRequest): LeaveInput {
+  return { category: r.category, start_date: r.start_date, end_date: r.end_date,
+    half: r.half, purpose: r.purpose, medical_evidence: r.medical_evidence,
+    station_leave: r.station_leave, station_from: r.station_from, station_to: r.station_to,
+    station_address: r.station_address, substitute_user_id: r.substitute_user_id,
+    responsibility: r.responsibility };
+}
+
+export default function MyLeavePage() {
+  const { data, isPending, error } = useMyRequests();
+  const [dialog, setDialog] = useState<Dialog>(null);
+  const [detail, setDetail] = useState<number | null>(null);
+  const history = useRequest(detail);
+  const withdraw = useWithdraw();
+  const cancel = useCancel();
+  const modify = useModify();
+  const renominate = useRenominate();
+  const extend = useExtend();
+  const resume = useResume();
+  const print = usePrint();
+
+  const done = (title: string) => ({
+    onSuccess: () => { notifications.show({ color: "green", title, message: "" });
+      setDialog(null); },
+    onError: (e: unknown) => notifications.show({ color: "red", title: "Not done",
+      message: errorMessage(e) }),
+  });
+
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  function actions(r: LeaveRequest) {
+    const out: React.ReactNode[] = [
+      <Button key="h" size="xs" variant="subtle" onClick={() => setDetail(r.id)}>History</Button>,
+      <Button key="p" size="xs" variant="subtle" onClick={() => print.mutate(r.id)}>Print</Button>,
+    ];
+    if (PENDING.has(r.status)) {
+      if (r.kind === "leave") {
+        out.push(<Button key="m" size="xs" variant="light"
+          onClick={() => setDialog({ kind: "modify", row: r, value: toInput(r) })}>Modify</Button>);
+      }
+      out.push(<Button key="w" size="xs" variant="light" color="red"
+        onClick={() => setDialog({ kind: "withdraw", row: r })}>Withdraw</Button>);
+    }
+    if (r.status === "substitute_declined") {
+      out.push(<Button key="s" size="xs"
+        onClick={() => setDialog({ kind: "renominate", row: r, sub: null })}>
+        New substitute</Button>);
+    }
+    if (r.status === "approved" && r.kind !== "offline") {
+      if (r.start_date > today()) {
+        out.push(<Button key="c" size="xs" variant="light" color="red"
+          onClick={() => setDialog({ kind: "cancel", row: r })}>Cancel</Button>);
+      } else if (r.kind === "leave" && LONG.has(r.category)) {
+        out.push(<Button key="e" size="xs" variant="light"
+          onClick={() => setDialog({ kind: "extend", row: r, end: "", purpose: "" })}>
+          Extend</Button>);
+        out.push(<Button key="r" size="xs"
+          onClick={() => setDialog({ kind: "resume", row: r, date: today() })}>
+          Resume duty</Button>);
+      }
+    }
+    return out;
+  }
+
+  return (
+    <Container size="xl">
+      <PageHeader title="My Leave" subtitle="Your applications, extensions and their status" />
+      <Card withBorder padding="md">
+        <LeaveTable rows={data?.results ?? []} loading={isPending} actions={actions}
+          empty={{ title: "No leave applications yet",
+            description: "Applications you submit appear here." }} />
+      </Card>
+
+      <NoteModal
+        opened={dialog?.kind === "withdraw"} title="Withdraw this request?"
+        label="Reason (optional)" submitLabel="Withdraw" danger
+        submitting={withdraw.isPending} onClose={() => setDialog(null)}
+        onSubmit={(reason) => dialog && withdraw.mutate({ id: dialog.row.id, reason },
+          done("Request withdrawn"))}
+      />
+      <NoteModal
+        opened={dialog?.kind === "cancel"} title="Request cancellation?"
+        subtitle="Cancellation goes through the same approvers as the original leave."
+        label="Reason (optional)" submitLabel="Request cancellation" danger
+        submitting={cancel.isPending} onClose={() => setDialog(null)}
+        onSubmit={(reason) => dialog && cancel.mutate({ id: dialog.row.id, reason },
+          done("Cancellation requested"))}
+      />
+
+      {dialog?.kind === "modify" && (
+        <FormModal opened title="Modify request" onClose={() => setDialog(null)}
+          subtitle="Approvals restart once you save."
+          submitting={modify.isPending} disabled={!!missingReason(dialog.value)}
+          disabledReason={missingReason(dialog.value)}
+          onSubmit={() => modify.mutate({ id: dialog.row.id, data: dialog.value },
+            done("Request modified"))}>
+          <LeaveForm value={dialog.value}
+            onChange={(value) => setDialog({ ...dialog, value })} />
+        </FormModal>
+      )}
+      {dialog?.kind === "renominate" && (
+        <FormModal opened title="Nominate a new substitute" onClose={() => setDialog(null)}
+          submitting={renominate.isPending} disabled={dialog.sub == null}
+          onSubmit={() => dialog.sub != null && renominate.mutate(
+            { id: dialog.row.id, substitute_user_id: dialog.sub, responsibility: "" },
+            done("Substitute nominated"))}>
+          <EmployeePicker label="Substitute" value={dialog.sub}
+            onChange={(sub) => setDialog({ ...dialog, sub })} />
+        </FormModal>
+      )}
+      {dialog?.kind === "extend" && (
+        <FormModal opened title="Extend ongoing leave" onClose={() => setDialog(null)}
+          subtitle={`Currently ends ${dialog.row.end_date}`}
+          submitting={extend.isPending} disabled={!dialog.end || !dialog.purpose.trim()}
+          onSubmit={() => extend.mutate({ id: dialog.row.id, end_date: dialog.end,
+            purpose: dialog.purpose, substitute_user_id: null }, done("Extension submitted"))}>
+          <Stack>
+            <TextInput type="date" label="New end date" value={dialog.end}
+              onChange={(e) => setDialog({ ...dialog, end: e.currentTarget.value })} />
+            <TextInput label="Reason" value={dialog.purpose}
+              onChange={(e) => setDialog({ ...dialog, purpose: e.currentTarget.value })} />
+          </Stack>
+        </FormModal>
+      )}
+      {dialog?.kind === "resume" && (
+        <FormModal opened title="Submit resumption of duty" onClose={() => setDialog(null)}
+          subtitle="Unused days are restored only after your return is verified."
+          submitting={resume.isPending} disabled={!dialog.date}
+          onSubmit={() => resume.mutate({ id: dialog.row.id, actual_return_date: dialog.date,
+            note: "" }, done("Resumption submitted"))}>
+          <TextInput type="date" label="Date you resumed duty" value={dialog.date}
+            onChange={(e) => setDialog({ ...dialog, date: e.currentTarget.value })} />
+        </FormModal>
+      )}
+
+      <Drawer opened={detail != null} onClose={() => setDetail(null)} position="right"
+        title={`Leave #${detail ?? ""}`}>
+        {history.error && <ErrorState error={history.error} />}
+        {history.data && (
+          <Timeline active={history.data.history.length} bulletSize={14}>
+            {history.data.history.map((h, i) => (
+              <Timeline.Item key={i} title={h.to_status.replace(/_/g, " ")}>
+                <Text size="xs" c="dimmed">
+                  {new Date(h.at).toLocaleString()} · {h.event.replace(/_/g, " ")}
+                  {h.actor_role ? ` · ${h.actor_role}` : ""}
+                </Text>
+                {h.note && <Text size="sm">{h.note}</Text>}
+              </Timeline.Item>
+            ))}
+          </Timeline>
+        )}
+      </Drawer>
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/OfflinePage.tsx b/client/src/modules/elm/pages/OfflinePage.tsx
new file mode 100644
index 00000000..5ff33d4e
--- /dev/null
+++ b/client/src/modules/elm/pages/OfflinePage.tsx
@@ -0,0 +1,79 @@
+import {
+  Button, Card, Container, Group, Select, SimpleGrid, Stack, Text, TextInput,
+} from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { errorMessage } from "../../../lib/http";
+import { DataTable } from "../../../ui/components/DataTable";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useOfflineRecords, useRecordOffline } from "../api/hooks";
+import { CATEGORY_LABELS, type Category, type OfflineInput } from "../api/types";
+import { EmployeePicker } from "../components/EmployeePicker";
+
+const EMPTY: Omit<OfflineInput, "user_id"> & { user_id: number | null } = {
+  user_id: null, category: "CL", start_date: "", end_date: "", half: "", purpose: "",
+  sanction_reference: "", sanctioned_by: "", sanctioned_on: "", evidence_note: "",
+};
+
+export default function OfflinePage() {
+  const { data, isPending, error } = useOfflineRecords();
+  const record = useRecordOffline();
+  const [v, setV] = useState(EMPTY);
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  const ready = v.user_id != null && v.start_date && v.end_date && v.sanction_reference
+    && v.sanctioned_by && v.sanctioned_on;
+
+  return (
+    <Container size="xl">
+      <PageHeader title="Offline Leave"
+        subtitle="Record leave already sanctioned on paper. This synchronises records; it is not an approval." />
+      <Card withBorder padding="lg" mb="lg">
+        <Stack>
+          <EmployeePicker label="Employee" value={v.user_id}
+            onChange={(user_id) => setV({ ...v, user_id })} />
+          <SimpleGrid cols={{ base: 1, sm: 3 }}>
+            <Select label="Leave" allowDeselect={false} value={v.category}
+              data={Object.entries(CATEGORY_LABELS).map(([value, label]) => ({ value, label }))}
+              onChange={(c) => setV({ ...v, category: (c ?? "CL") as Category })} />
+            <TextInput type="date" label="From" value={v.start_date}
+              onChange={(e) => setV({ ...v, start_date: e.currentTarget.value })} />
+            <TextInput type="date" label="To" value={v.end_date}
+              onChange={(e) => setV({ ...v, end_date: e.currentTarget.value })} />
+            <TextInput label="Sanction reference" value={v.sanction_reference}
+              onChange={(e) => setV({ ...v, sanction_reference: e.currentTarget.value })} />
+            <TextInput label="Sanctioned by" value={v.sanctioned_by}
+              onChange={(e) => setV({ ...v, sanctioned_by: e.currentTarget.value })} />
+            <TextInput type="date" label="Sanctioned on" value={v.sanctioned_on}
+              onChange={(e) => setV({ ...v, sanctioned_on: e.currentTarget.value })} />
+          </SimpleGrid>
+          <TextInput label="Evidence note" value={v.evidence_note}
+            onChange={(e) => setV({ ...v, evidence_note: e.currentTarget.value })} />
+          <Group justify="flex-end">
+            <Button disabled={!ready} loading={record.isPending}
+              onClick={() => v.user_id != null && record.mutate({ ...v, user_id: v.user_id }, {
+                onSuccess: () => { setV(EMPTY);
+                  notifications.show({ color: "green", title: "Recorded", message: "" }); },
+                onError: (e) => notifications.show({ color: "red", title: "Not recorded",
+                  message: errorMessage(e) }),
+              })}>Record</Button>
+          </Group>
+        </Stack>
+      </Card>
+
+      <Card withBorder padding="md">
+        <DataTable rows={data?.results ?? []} loading={isPending} rowKey={(r) => r.id}
+          empty={{ title: "No offline records" }}
+          columns={[
+            { key: "ref", header: "Reference", render: (r) => r.sanction_reference },
+            { key: "who", header: "Employee",
+              render: (r) => <Text size="sm">{r.leave.applicant_name || r.leave.user_id}</Text> },
+            { key: "leave", header: "Leave",
+              render: (r) => `${r.leave.category} ${r.leave.start_date} → ${r.leave.end_date}` },
+            { key: "by", header: "Sanctioned by", render: (r) => `${r.sanctioned_by}, ${r.sanctioned_on}` },
+          ]} />
+      </Card>
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/PoliciesPage.tsx b/client/src/modules/elm/pages/PoliciesPage.tsx
new file mode 100644
index 00000000..7bd1c029
--- /dev/null
+++ b/client/src/modules/elm/pages/PoliciesPage.tsx
@@ -0,0 +1,89 @@
+import {
+  Badge, Button, Card, Container, Group, JsonInput, Stack, Text, TextInput,
+} from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { errorMessage } from "../../../lib/http";
+import { DataTable } from "../../../ui/components/DataTable";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { FormModal } from "../../../ui/components/FormModal";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useCreatePolicy, usePolicies, usePublishPolicy } from "../api/hooks";
+
+export default function PoliciesPage() {
+  const { data, isPending, error } = usePolicies();
+  const create = useCreatePolicy();
+  const publish = usePublishPolicy();
+  const [draft, setDraft] = useState<{ name: string; from: string; params: string;
+    hierarchy: string } | null>(null);
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  const rows = data?.results ?? [];
+  function startDraft() {
+    const base = rows.find((r) => r.status === "published") ?? rows[0];
+    setDraft({ name: "", from: "",
+      params: JSON.stringify(base?.params ?? {}, null, 2),
+      hierarchy: JSON.stringify(base?.hierarchy ?? {}, null, 2) });
+  }
+
+  function save() {
+    if (!draft) return;
+    let params, hierarchy;
+    try {
+      params = JSON.parse(draft.params);
+      hierarchy = JSON.parse(draft.hierarchy);
+    } catch {
+      notifications.show({ color: "red", title: "Invalid JSON", message: "Fix the JSON first." });
+      return;
+    }
+    create.mutate({ name: draft.name, effective_from: draft.from, params, hierarchy }, {
+      onSuccess: () => setDraft(null),
+    });
+  }
+
+  return (
+    <Container size="xl">
+      <PageHeader title="Leave Policy"
+        subtitle="Entitlements and the approval hierarchy. Published versions are never edited."
+        action={<Button onClick={startDraft}>New version</Button>} />
+      <Card withBorder padding="md">
+        <DataTable rows={rows} loading={isPending} rowKey={(r) => r.id}
+          empty={{ title: "No policy versions",
+            description: "Nothing can be applied for until a policy is published." }}
+          columns={[
+            { key: "name", header: "Version", render: (r) => <Text size="sm">#{r.id} {r.name}</Text> },
+            { key: "from", header: "Effective from", render: (r) => r.effective_from },
+            { key: "status", header: "Status",
+              render: (r) => <Badge color={r.status === "published" ? "green" : "gray"}
+                variant="light">{r.status}</Badge> },
+            { key: "act", header: "", align: "right",
+              render: (r) => r.status === "draft" && (
+                <Button size="xs" loading={publish.isPending}
+                  onClick={() => publish.mutate(r.id, {
+                    onError: (e) => notifications.show({ color: "red",
+                      title: "Not published", message: errorMessage(e) }) })}>
+                  Publish</Button>) },
+          ]} />
+      </Card>
+
+      {draft && (
+        <FormModal opened title="New policy version" onClose={() => setDraft(null)}
+          size="xl" submitting={create.isPending} error={create.error}
+          disabled={!draft.name || !draft.from} onSubmit={save} submitLabel="Save draft">
+          <Stack>
+            <Group grow>
+              <TextInput label="Name" value={draft.name}
+                onChange={(e) => setDraft({ ...draft, name: e.currentTarget.value })} />
+              <TextInput type="date" label="Effective from" value={draft.from}
+                onChange={(e) => setDraft({ ...draft, from: e.currentTarget.value })} />
+            </Group>
+            <JsonInput label="Parameters" autosize minRows={8} formatOnBlur
+              value={draft.params} onChange={(params) => setDraft({ ...draft, params })} />
+            <JsonInput label="Hierarchy" autosize minRows={8} formatOnBlur
+              value={draft.hierarchy} onChange={(hierarchy) => setDraft({ ...draft, hierarchy })} />
+          </Stack>
+        </FormModal>
+      )}
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/QueuePage.tsx b/client/src/modules/elm/pages/QueuePage.tsx
new file mode 100644
index 00000000..70ddf52e
--- /dev/null
+++ b/client/src/modules/elm/pages/QueuePage.tsx
@@ -0,0 +1,67 @@
+import { Button, Card, Container, Stack, Text } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useDecide, useQueue } from "../api/hooks";
+import type { LeaveRequest } from "../api/types";
+import { LeaveTable } from "../components/LeaveTable";
+import { NoteModal } from "../components/NoteModal";
+
+const LABEL: Record<string, string> = {
+  approve: "Approve", reject: "Reject", recommend: "Recommend",
+  not_recommend: "Not recommended", forward: "Forward",
+  cancel_advance: "Forward cancellation", cancel_approve: "Approve cancellation",
+  cancel_reject: "Reject cancellation",
+};
+const NEEDS_REASON = new Set(["reject", "not_recommend", "cancel_reject"]);
+
+export default function QueuePage() {
+  const { data, isPending, error } = useQueue();
+  const decide = useDecide();
+  const [pick, setPick] = useState<{ row: LeaveRequest; event: string } | null>(null);
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  return (
+    <Container size="xl">
+      <PageHeader title="Leave Approvals"
+        subtitle="Requests waiting at the step held by the role you are acting as" />
+      <Card withBorder padding="md">
+        <LeaveTable rows={data?.results ?? []} loading={isPending} showApplicant
+          empty={{ title: "Nothing awaits you",
+            description: "Requests routed to your role appear here." }}
+          actions={(r) => r.allowed_decisions.map((e) => (
+            <Button key={e} size="xs"
+              variant={NEEDS_REASON.has(e) ? "light" : "filled"}
+              color={NEEDS_REASON.has(e) ? "red" : undefined}
+              onClick={() => setPick({ row: r, event: e })}>{LABEL[e] ?? e}</Button>
+          ))} />
+      </Card>
+
+      <NoteModal
+        opened={pick != null} title={pick ? `${LABEL[pick.event] ?? pick.event} leave #${pick.row.id}` : ""}
+        subtitle={pick ? `${pick.row.applicant_name} · ${pick.row.category_label} · ${pick.row.start_date} to ${pick.row.end_date}` : ""}
+        label={pick && NEEDS_REASON.has(pick.event) ? "Reason" : "Note (optional)"}
+        required={pick ? NEEDS_REASON.has(pick.event) : false}
+        submitLabel={pick ? (LABEL[pick.event] ?? pick.event) : ""} danger={pick ? NEEDS_REASON.has(pick.event) : false}
+        submitting={decide.isPending} onClose={() => setPick(null)}
+        onSubmit={(note) => pick && decide.mutate({ id: pick.row.id, event: pick.event, note }, {
+          onSuccess: () => setPick(null),
+          onError: (e) => notifications.show({ color: "red", title: "Not recorded",
+            message: errorMessage(e) }),
+        })}
+      >
+        {pick && (
+          <Stack gap={4} mb="sm">
+            <Text size="sm"><b>Purpose:</b> {pick.row.purpose}</Text>
+            {pick.row.recommendation && (
+              <Text size="sm"><b>Unit Head:</b> {pick.row.recommendation.replace("_", " ")}</Text>)}
+            {pick.row.station_leave && (
+              <Text size="sm"><b>Station leave:</b> {pick.row.station_address}</Text>)}
+          </Stack>
+        )}
+      </NoteModal>
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/ResumptionsPage.tsx b/client/src/modules/elm/pages/ResumptionsPage.tsx
new file mode 100644
index 00000000..b082c43b
--- /dev/null
+++ b/client/src/modules/elm/pages/ResumptionsPage.tsx
@@ -0,0 +1,46 @@
+import { Button, Card, Container } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useResumptions, useVerify } from "../api/hooks";
+import type { LeaveRequest } from "../api/types";
+import { LeaveTable } from "../components/LeaveTable";
+import { NoteModal } from "../components/NoteModal";
+
+export default function ResumptionsPage() {
+  const { data, isPending, error } = useResumptions();
+  const verify = useVerify();
+  const [pick, setPick] = useState<{ row: LeaveRequest; ok: boolean } | null>(null);
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  return (
+    <Container size="xl">
+      <PageHeader title="Resumptions"
+        subtitle="Verify the actual return to duty; early returns restore unused leave" />
+      <Card withBorder padding="md">
+        <LeaveTable rows={data?.results ?? []} loading={isPending} showApplicant
+          empty={{ title: "No resumptions to verify" }}
+          actions={(r) => [
+            <Button key="v" size="xs" onClick={() => setPick({ row: r, ok: true })}>
+              Verify return on {r.actual_return_date}</Button>,
+            <Button key="n" size="xs" variant="light" color="red"
+              onClick={() => setPick({ row: r, ok: false })}>Cannot verify</Button>,
+          ]} />
+      </Card>
+
+      <NoteModal
+        opened={pick != null} title={pick?.ok ? "Verify return" : "Return cannot be verified"}
+        label="Note" required={pick ? !pick.ok : false}
+        submitLabel={pick?.ok ? "Verify" : "Send back"} danger={!pick?.ok}
+        submitting={verify.isPending} onClose={() => setPick(null)}
+        onSubmit={(note) => pick && verify.mutate({ id: pick.row.id, verified: pick.ok, note }, {
+          onSuccess: () => setPick(null),
+          onError: (e) => notifications.show({ color: "red", title: "Not recorded",
+            message: errorMessage(e) }),
+        })}
+      />
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/pages/SubstitutionsPage.tsx b/client/src/modules/elm/pages/SubstitutionsPage.tsx
new file mode 100644
index 00000000..e691bf76
--- /dev/null
+++ b/client/src/modules/elm/pages/SubstitutionsPage.tsx
@@ -0,0 +1,47 @@
+import { Button, Card, Container } from "@mantine/core";
+import { notifications } from "@mantine/notifications";
+import { useState } from "react";
+import { errorMessage } from "../../../lib/http";
+import { ErrorState } from "../../../ui/components/ErrorState";
+import { PageHeader } from "../../../ui/components/PageHeader";
+import { useRespondSubstitution, useSubstitutions } from "../api/hooks";
+import type { LeaveRequest } from "../api/types";
+import { LeaveTable } from "../components/LeaveTable";
+import { NoteModal } from "../components/NoteModal";
+
+export default function SubstitutionsPage() {
+  const { data, isPending, error } = useSubstitutions();
+  const respond = useRespondSubstitution();
+  const [pick, setPick] = useState<{ row: LeaveRequest; accept: boolean } | null>(null);
+  if (error) return <Container size="xl"><ErrorState error={error} /></Container>;
+
+  return (
+    <Container size="xl">
+      <PageHeader title="Substitution Requests"
+        subtitle="Colleagues who nominated you to cover their responsibilities" />
+      <Card withBorder padding="md">
+        <LeaveTable rows={data?.results ?? []} loading={isPending} showApplicant
+          empty={{ title: "No substitution requests" }}
+          actions={(r) => r.status === "awaiting_substitute" ? [
+            <Button key="a" size="xs" onClick={() => setPick({ row: r, accept: true })}>
+              Accept</Button>,
+            <Button key="d" size="xs" variant="light" color="red"
+              onClick={() => setPick({ row: r, accept: false })}>Decline</Button>,
+          ] : null} />
+      </Card>
+
+      <NoteModal
+        opened={pick != null}
+        title={pick?.accept ? "Accept this responsibility?" : "Decline this nomination?"}
+        subtitle={pick ? `${pick.row.start_date} to ${pick.row.end_date}: ${pick.row.responsibility}` : ""}
+        label="Note (optional)" submitLabel={pick?.accept ? "Accept" : "Decline"}
+        danger={!pick?.accept} submitting={respond.isPending} onClose={() => setPick(null)}
+        onSubmit={(note) => pick && respond.mutate({ id: pick.row.id, accept: pick.accept, note }, {
+          onSuccess: () => setPick(null),
+          onError: (e) => notifications.show({ color: "red", title: "Not recorded",
+            message: errorMessage(e) }),
+        })}
+      />
+    </Container>
+  );
+}
diff --git a/client/src/modules/elm/routes.tsx b/client/src/modules/elm/routes.tsx
new file mode 100644
index 00000000..361ba00a
--- /dev/null
+++ b/client/src/modules/elm/routes.tsx
@@ -0,0 +1,28 @@
+import { lazy } from "react";
+import { Navigate, type RouteObject } from "react-router-dom";
+
+const ApplyPage = lazy(() => import("./pages/ApplyPage"));
+const MyLeavePage = lazy(() => import("./pages/MyLeavePage"));
+const BalancesPage = lazy(() => import("./pages/BalancesPage"));
+const SubstitutionsPage = lazy(() => import("./pages/SubstitutionsPage"));
+const QueuePage = lazy(() => import("./pages/QueuePage"));
+const ResumptionsPage = lazy(() => import("./pages/ResumptionsPage"));
+const PoliciesPage = lazy(() => import("./pages/PoliciesPage"));
+const CalendarPage = lazy(() => import("./pages/CalendarPage"));
+const OfflinePage = lazy(() => import("./pages/OfflinePage"));
+const AccountsPage = lazy(() => import("./pages/AccountsPage"));
+
+/** Relative paths; each one has a matching nav item in modules/elm/registry.py. */
+export const routes: RouteObject[] = [
+  { index: true, element: <Navigate to="mine" replace /> },
+  { path: "apply", element: <ApplyPage /> },
+  { path: "mine", element: <MyLeavePage /> },
+  { path: "balances", element: <BalancesPage /> },
+  { path: "substitutions", element: <SubstitutionsPage /> },
+  { path: "queue", element: <QueuePage /> },
+  { path: "resumptions", element: <ResumptionsPage /> },
+  { path: "policies", element: <PoliciesPage /> },
+  { path: "calendar", element: <CalendarPage /> },
+  { path: "offline", element: <OfflinePage /> },
+  { path: "accounts", element: <AccountsPage /> },
+];
diff --git a/config/celery.py b/config/celery.py
index ad15f06b..58b449ad 100644
--- a/config/celery.py
+++ b/config/celery.py
@@ -2,6 +2,12 @@
 
 from celery import Celery
 
+from modules.elm.schedule import (
+    BEAT_SCHEDULE as ELM_SCHEDULE,
+)
+from modules.elm.schedule import (
+    TASK_ROUTES as ELM_ROUTES,
+)
 from modules.placement.schedule import (
     BEAT_SCHEDULE as PLACEMENT_SCHEDULE,
 )
@@ -15,5 +21,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, **ELM_SCHEDULE}
+app.conf.task_routes = {**PLACEMENT_ROUTES, **ELM_ROUTES}
diff --git a/config/settings/base.py b/config/settings/base.py
index 0dc7ada1..a346a065 100644
--- a/config/settings/base.py
+++ b/config/settings/base.py
@@ -90,6 +90,7 @@ def env_list(name, default=None):
 # See docs/03-platform/module-authoring-guide.md to add one.
 DOMAIN_MODULES = [
     "modules.placement",
+    "modules.elm",
 ]
 
 INSTALLED_APPS = (DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS
diff --git a/config/urls.py b/config/urls.py
index 33f7835b..a9f602e7 100644
--- a/config/urls.py
+++ b/config/urls.py
@@ -16,6 +16,7 @@
     path("api/v1/", include("fusion_auth.urls")),
     path("api/v1/directory/", include("modules.directory.api.urls")),
     path("api/v1/placement/", include("modules.placement.api.urls")),
+    path("api/v1/elm/", include("modules.elm.api.urls")),
     path("api/schema/", SpectacularAPIView.as_view(), name="schema"),
     path("api/docs/", SpectacularSwaggerView.as_view(url_name="schema"), name="docs"),
 ]
diff --git a/docs/02-iam/permission-catalog.generated.md b/docs/02-iam/permission-catalog.generated.md
index 6d748531..28b054f0 100644
--- a/docs/02-iam/permission-catalog.generated.md
+++ b/docs/02-iam/permission-catalog.generated.md
@@ -13,6 +13,24 @@ 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` |
 
+## `elm`
+
+| Code | What it allows | Held by |
+|---|---|---|
+| `elm.leave_request.view` | See one's own leave requests | `faculty`, `staff` |
+| `elm.leave_request.create` | Apply for leave or an extension | `faculty`, `staff` |
+| `elm.leave_request.update` | Modify, cancel or resume one's own leave | `faculty`, `staff` |
+| `elm.leave_request.delete` | Withdraw one's own pending request | `faculty`, `staff` |
+| `elm.substitution.review` | Accept or decline a substitute nomination | `faculty`, `staff` |
+| `elm.leave_balance.view` | See one's own balances and leave-account history | `faculty`, `staff` |
+| `elm.leave_request.review` | Review, recommend or forward routed leave | `Deputy Registrar`, `Director`, `HOD (CSE)`, `HOD (Design)`, `HOD (ECE)`, `HOD (Liberal Arts)`, `HOD (ME)`, `HOD (NS)`, `Registrar`, `SectionHead_HR`, `SectionHead_IWD`, `SectionHead_PS`, `SectionHead_RSPC` |
+| `elm.leave_request.approve` | Approve or reject leave as sanctioning authority | `Director`, `HOD (CSE)`, `HOD (Design)`, `HOD (ECE)`, `HOD (Liberal Arts)`, `HOD (ME)`, `HOD (NS)`, `Registrar`, `SectionHead_HR`, `SectionHead_IWD`, `SectionHead_PS`, `SectionHead_RSPC` |
+| `elm.resumption.review` | Verify resumption of duty | `Deputy Registrar`, `Director`, `HOD (CSE)`, `HOD (Design)`, `HOD (ECE)`, `HOD (Liberal Arts)`, `HOD (ME)`, `HOD (NS)`, `Registrar`, `SectionHead_HR`, `SectionHead_IWD`, `SectionHead_PS`, `SectionHead_RSPC` |
+| `elm.policy.publish` | Create, revise and publish leave policy and hierarchy | `Leave Administrator` |
+| `elm.calendar.publish` | Create, revise and publish the holiday/RH calendar | `Leave Administrator` |
+| `elm.offline_record.create` | Record offline-sanctioned leave | `Leave Administrator` |
+| `elm.leave_account.view` | See any employee's leave account | `Leave Administrator` |
+
 ## `placement_cell`
 
 | Code | What it allows | Held by |
diff --git a/docs/09-elm/elm-blueprint.md b/docs/09-elm/elm-blueprint.md
new file mode 100644
index 00000000..a094a319
--- /dev/null
+++ b/docs/09-elm/elm-blueprint.md
@@ -0,0 +1,173 @@
+---
+purpose: >
+  The ELM (Employee Leave Management) blueprint: traceability, domain model, state machine,
+  permissions, endpoints, contracts, scheduled work and open questions.
+---
+
+# ELM — blueprint
+
+| Blank | Value |
+|---|---|
+| `MODULE_NAME` | Employee Leave Management |
+| `SPEC_FOLDER_PATH` | `RS1_Phase1_Student_Distribution/Reference_Documents/` (00–05) |
+| `ID_PREFIX` | `SRS-EL-`, `BR-EL-`, `EL-UC-`, `SF-EL-`, `WF-EL-` |
+| `module_code` | `elm` |
+| `ENVIRONMENT` | `module-only` |
+
+## Phase 0 inventory
+
+| Artefact | Count | Notes |
+|---|---|---|
+| Requirements `SRS-EL-001..107` | 107 | none retired |
+| Business rules `BR-EL-001..033` | 32 | **`BR-EL-026` is absent** from the index and body; not cited anywhere |
+| Use cases `EL-UC-001..016` | 16 | none retired |
+| Scheduled functions `SF-EL-001..002` | 2 | year-end, SLA |
+| Workflows `WF-EL-01..08` | 8 | |
+
+Actors named (Step 1.4.6): Employee, Substitute / Responsibility Holder, Unit Head,
+Deputy Registrar (Estt.) / Establishment role, Dean, Registrar, Director, Leave
+Administrator, System Scheduler (domain context §3; EL-UC-001..016; WF-EL-01..08).
+
+## 3.1 (a) Traceability
+
+| Id | Requires | Layer | Enforcement point |
+|---|---|---|---|
+| BR-EL-001 | category eligibility under effective policy | domain | `domain/policy.py::check_eligible` via `services/requests.py::_validate` |
+| BR-EL-002 | 8 CL/yr, lapses | domain + services | `domain/policy.py` defaults, `services/ledger.py::ensure_annual_credits`, `services/year_end.py` |
+| BR-EL-003 | 2 RH/yr, must match published RH, lapses | domain | `domain/counting.py::validate_rh_dates`, `services/year_end.py` |
+| BR-EL-004 | 15 SCL/yr, authority decides admissibility, lapses | domain + services | policy defaults; final decision in `services/workflow.py` |
+| BR-EL-005 | 30 EL/yr for non-faculty, carries forward | domain + services | `domain/policy.py::annual_credit_for`, `services/year_end.py` |
+| BR-EL-006 | 60 VL for faculty, only inside published vacation | domain | `domain/counting.py::validate_vacation` |
+| BR-EL-007 | VL→EL 2:1 fractional at year end | domain | `domain/year_end.py::vl_to_el` |
+| BR-EL-008 | converted EL credited, carries forward | services | `services/year_end.py` |
+| BR-EL-009 | 20 COL/yr, carries forward, medical evidence | domain + services | policy defaults, `_validate` evidence check |
+| BR-EL-010 | half-day CL = 0.5 | domain | `domain/counting.py::chargeable_days` |
+| BR-EL-011 | EL/COL/VL count intervening weekends/holidays | domain | `domain/counting.py::chargeable_days` |
+| BR-EL-012 | no overlap; different CL halves do not overlap | domain + services | `domain/overlap.py`, `services/requests.py::_validate` (row lock on applicant) |
+| BR-EL-013 | Station Leave inside the same application | models | `LeaveRequest.station_leave*` fields |
+| BR-EL-014 | substitute is another employee with no overlapping leave | services | `services/requests.py::_validate_substitute` |
+| BR-EL-015 | no routing until substitute accepts | domain | `domain/state_machine.py` (only `substitute_accept` leaves `awaiting_substitute`) |
+| BR-EL-016 | Unit Head final for CL/RH | domain | `domain/routing.py::resolve_route` |
+| BR-EL-017 | Unit Head recommends for SCL/EL/COL/VL, never final | domain | `domain/routing.py`, `domain/state_machine.py` |
+| BR-EL-018 | higher sanction through configured hierarchy | domain | `domain/routing.py::resolve_route` |
+| BR-EL-019 | path from applicant, unit, role, category, hierarchy | domain | `domain/routing.py::resolve_route` |
+| BR-EL-020 | Director self-sanction | domain | `domain/routing.py` (`director` step) |
+| BR-EL-021 | modify only while pending; revalidate; supersede tasks | services | `services/requests.py::modify` |
+| BR-EL-022 | immediate withdrawal; close tasks; inform | services | `services/requests.py::withdraw` |
+| BR-EL-023 | cancel approved only before start, same hierarchy | services | `services/requests.py::request_cancellation` |
+| BR-EL-024 | fresh application after cancellation | domain | no transition out of `cancelled` |
+| BR-EL-025 | extension only for ongoing EL/COL/VL | services | `services/requests.py::apply_extension` |
+| BR-EL-027 | resumption after EL/COL/VL, verified, closes | services | `services/resumption.py` |
+| BR-EL-028 | early resumption restores unused only after verification | services | `services/resumption.py::verify` |
+| BR-EL-029 | offline sanctioned leave is record sync, not approval | services | `services/offline.py::record` |
+| BR-EL-030 | effective published policy/hierarchy | selectors | `selectors/config.py::effective_policy` |
+| BR-EL-031 | effective published calendar | selectors | `selectors/config.py::effective_calendar` |
+| BR-EL-032 | SLA reminder at threshold, not if no longer pending | services | `services/sla.py::process` |
+| BR-EL-033 | SLA escalation, logged | services | `services/sla.py::process` |
+| EL-UC-001..016 | see services column above | services | one service per use-case family |
+| SF-EL-001 / SF-EL-002 | year-end / SLA | tasks | `tasks.py`, `schedule.py` |
+
+Known gaps: SRS-EL-084 (attendance synchronisation) — there is no attendance module in this
+platform; verified resumption records the actual period and closes the leave, the attendance
+half is listed in (h).
+
+## 3.2 (b) Domain model
+
+- `PolicyVersion` — `params` (JSON, validated by `domain/policy.py`), `hierarchy` (JSON),
+  `effective_from`, `status` draft|published. Published rows are never edited.
+- `CalendarVersion` + `CalendarEntry` (kind closed_holiday | restricted_holiday | vacation,
+  `start_date`, `end_date`). Same publish rule.
+- `LeaveRequest` — `user_id`, `category`, `kind` leave|extension, `parent` (extension → leave),
+  dates, `half` (CL), `days`, purpose, station-leave fields, `substitute_user_id`,
+  `substitute_status`, `status`, `route` (JSON snapshot), `stage`, `current_role`,
+  `recommendation`, `cancellation_stage`, `actual_return_date`, `policy_version`.
+  `CheckConstraint end >= start`, `days > 0`.
+- `LeaveTransition` — append-only audit (from, to, event, actor, note).
+- `LedgerEntry` — append-only (`user_id`, `category`, `delta`, `entry_type`, `year`,
+  `request`). Partial unique index: one `annual_credit` per (user, category, year), one
+  `debit` / `reversal` / `restore` per request.
+- `OfflineLeaveRecord` — evidence of offline sanction.
+- `YearEndRun` — unique per year, with exceptions report.
+- `Notification` — in-app notifications to a user or to a designation.
+- `SlaAction` — unique per (request, stage, action) so a threshold fires once.
+
+## 3.3 (c) State machine
+
+Declared in `domain/state_machine.py` as `(state, event) → targets, actor`. States:
+`awaiting_substitute`, `substitute_declined`, `awaiting_unit_head`, `awaiting_establishment`,
+`awaiting_sanction`, `awaiting_director`, `approved`, `rejected`, `withdrawn`,
+`cancellation_pending`, `cancelled`, `resumption_pending`, `closed`.
+
+## 3.4 (d) Permissions
+
+See `modules/elm/registry.py`. Roles map to designations from `globals_designation`:
+Employee → `faculty`, `staff`; Unit Head → `HOD (CSE)`, `HOD (ECE)`, `HOD (ME)`,
+`HOD (Design)`, `HOD (NS)`, `HOD (Liberal Arts)`, `SectionHead_PS`, `SectionHead_IWD`,
+`SectionHead_RSPC`, `SectionHead_HR`; Establishment → `Deputy Registrar`; Sanctioning →
+`Registrar`, `Director`; Leave Administrator → `Leave Administrator` (new designation,
+provisioned with `assign_role`).
+
+## 3.5 (e) Endpoints
+
+All under `/api/v1/elm/`, gated by `HasModuleGrant("elm")` then a permission.
+
+| Method | Path | Permission | Rules |
+|---|---|---|---|
+| GET/POST | `requests` | `elm.leave_request.view` / `.create` | EL-UC-001 |
+| GET | `requests/<id>` | `elm.leave_request.view` (scoped) | EL-UC-012 |
+| POST | `requests/<id>/modify` | `elm.leave_request.update` | EL-UC-006 |
+| POST | `requests/<id>/withdraw` | `elm.leave_request.delete` | EL-UC-007 |
+| POST | `requests/<id>/cancel` | `elm.leave_request.update` | EL-UC-008 |
+| POST | `requests/<id>/extend` | `elm.leave_request.create` | EL-UC-009 |
+| POST | `requests/<id>/resume` | `elm.leave_request.update` | EL-UC-010 |
+| POST | `requests/<id>/substitute` | `elm.leave_request.update` | SRS-EL-041 |
+| GET | `requests/<id>/print` | `elm.leave_request.view` | EL-UC-013 |
+| GET | `substitutions` | `elm.substitution.review` | EL-UC-002 |
+| POST | `substitutions/<id>/respond` | `elm.substitution.review` | EL-UC-002 |
+| GET | `queue` | `elm.leave_request.review` / `.approve` | EL-UC-003..005 |
+| POST | `queue/<id>/decide` | `elm.leave_request.review` / `.approve` | EL-UC-003..005, 008, 009 |
+| GET | `resumptions` | `elm.resumption.review` | EL-UC-011 |
+| POST | `resumptions/<id>/verify` | `elm.resumption.review` | EL-UC-011 |
+| GET | `balances` | `elm.leave_balance.view` | EL-UC-012 |
+| GET/POST | `admin/policies`, `admin/policies/<id>/publish` | `elm.policy.publish` | EL-UC-014 |
+| GET/POST | `admin/calendars`, `admin/calendars/<id>/publish` | `elm.calendar.publish` | EL-UC-015 |
+| GET/POST | `admin/offline` | `elm.offline_record.create` | EL-UC-016 |
+| GET | `notifications` | module grant | SRS-EL-054 |
+
+`Fusion-client` sidebar entry: `{ id: "elm", label: "Leave", icon: "CalendarCheck", to: "/elm", section: "Services" }`.
+
+## 3.6 (f) Contracts
+
+Exposes `get_on_leave(user_ids, on)`. Consumes `directory.get_users` (kind, department).
+
+## 3.7 (g) Scheduled work
+
+| Task | Cadence | If it does not run |
+|---|---|---|
+| `elm.year_end` | 1 Jan 00:30 | CL/RH/SCL never lapse, VL never converts, no new-year credit |
+| `elm.sla` | hourly | no reminders or escalations |
+
+## 3.8 (h) Open questions
+
+1. Unit Head for staff sections with no head designation in `globals_designation`
+   (General Administration, Computer Center, Academics, Directorate, …). Unmapped units are
+   refused at submission with a message naming the unit.
+2. Who reviews a Unit Head's own leave. The Unit Head step refuses self-review; no route
+   is specified.
+3. Which Dean (if any) sanctions which category. Not granted by default.
+4. SLA reminder/escalation thresholds and escalation target — seeded empty, so SLA is off
+   until the Leave Administrator publishes values.
+5. SRS-EL-084 attendance synchronisation — no attendance module exists.
+6. `BR-EL-026` is missing from the spec.
+
+## Deployment order
+
+```bash
+manage.py migrate
+manage.py seed_elm_policy        # before seed_modules, or ELM registers as "planned"
+manage.py seed_modules
+make permissions                 # then, in the IAM:
+manage.py seed_iam_permissions --manifest <path>/registry/permissions.json
+manage.py assign_role --user <stfNNNNN> --designation "Leave Administrator"
+manage.py elm_readiness          # names every unmet prerequisite
+```
diff --git a/modules/elm/__init__.py b/modules/elm/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/api/__init__.py b/modules/elm/api/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/api/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/api/serializers.py b/modules/elm/api/serializers.py
new file mode 100644
index 00000000..093ea01b
--- /dev/null
+++ b/modules/elm/api/serializers.py
@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+from rest_framework import serializers
+
+from modules.elm.domain import categories as c
+from modules.elm.domain import state_machine as sm
+from modules.elm.models import (
+    CalendarEntry,
+    CalendarVersion,
+    LeaveRequest,
+    LeaveTransition,
+    LedgerEntry,
+    Notification,
+    OfflineLeaveRecord,
+    PolicyVersion,
+)
+
+CATEGORY_CHOICES = [(k, v) for k, v in c.LABELS.items()]
+
+
+def _name(ctx, uid):
+    if uid is None:
+        return ""
+    u = (ctx.get("names") or {}).get(uid)
+    return u.display_name if u else ""
+
+
+class LeaveRequestSerializer(serializers.ModelSerializer):
+    category_label = serializers.SerializerMethodField()
+    applicant_name = serializers.SerializerMethodField()
+    substitute_name = serializers.SerializerMethodField()
+    parent_id = serializers.IntegerField(read_only=True, allow_null=True)
+    allowed_decisions = serializers.SerializerMethodField()
+    status = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = LeaveRequest
+        fields = [
+            "id", "kind", "parent_id", "user_id", "applicant_name", "applicant_kind",
+            "applicant_unit", "category", "category_label", "start_date", "end_date",
+            "half", "days", "purpose", "medical_evidence", "station_leave",
+            "station_from", "station_to", "station_address", "substitute_user_id",
+            "substitute_name", "substitute_status", "responsibility", "status", "route",
+            "stage", "current_role", "recommendation", "decision_note", "decided_at",
+            "actual_return_date", "resumption_note", "allowed_decisions", "created_at",
+            "updated_at",
+        ]
+        read_only_fields = fields
+
+    def get_category_label(self, obj) -> str:
+        return c.LABELS.get(obj.category, obj.category)
+
+    def get_applicant_name(self, obj) -> str:
+        return _name(self.context, obj.user_id)
+
+    def get_substitute_name(self, obj) -> str:
+        return _name(self.context, obj.substitute_user_id)
+
+    def get_allowed_decisions(self, obj) -> list[str]:
+        if not self.context.get("queue"):
+            return []
+        step = obj.current_step
+        if step is None:
+            return []
+        return list(sm.decision_events(step["step"], obj.category in c.UNIT_HEAD_FINAL,
+                                       obj.status == sm.CANCELLATION_PENDING))
+
+
+class LeaveInputSerializer(serializers.Serializer):
+    category = serializers.ChoiceField(choices=CATEGORY_CHOICES)
+    start_date = serializers.DateField()
+    end_date = serializers.DateField()
+    half = serializers.ChoiceField(choices=["", *c.HALVES], required=False, default="")
+    purpose = serializers.CharField(max_length=2000)
+    medical_evidence = serializers.CharField(max_length=500, required=False, default="",
+                                             allow_blank=True)
+    station_leave = serializers.BooleanField(required=False, default=False)
+    station_from = serializers.DateField(required=False, allow_null=True, default=None)
+    station_to = serializers.DateField(required=False, allow_null=True, default=None)
+    station_address = serializers.CharField(max_length=300, required=False, default="",
+                                            allow_blank=True)
+    substitute_user_id = serializers.IntegerField(required=False, allow_null=True,
+                                                  default=None)
+    responsibility = serializers.CharField(max_length=300, required=False, default="",
+                                           allow_blank=True)
+
+
+class ExtensionSerializer(serializers.Serializer):
+    end_date = serializers.DateField()
+    purpose = serializers.CharField(max_length=2000)
+    substitute_user_id = serializers.IntegerField(required=False, allow_null=True,
+                                                  default=None)
+    responsibility = serializers.CharField(max_length=300, required=False, default="",
+                                           allow_blank=True)
+
+
+class RenominateSerializer(serializers.Serializer):
+    substitute_user_id = serializers.IntegerField()
+    responsibility = serializers.CharField(max_length=300, required=False, default="",
+                                           allow_blank=True)
+
+
+class ReasonSerializer(serializers.Serializer):
+    reason = serializers.CharField(max_length=500, required=False, default="",
+                                   allow_blank=True)
+
+
+class DecisionSerializer(serializers.Serializer):
+    event = serializers.ChoiceField(choices=[
+        sm.APPROVE, sm.REJECT, sm.RECOMMEND, sm.NOT_RECOMMEND, sm.FORWARD,
+        sm.CANCEL_ADVANCE, sm.CANCEL_APPROVE, sm.CANCEL_REJECT])
+    note = serializers.CharField(max_length=500, required=False, default="",
+                                 allow_blank=True)
+
+
+class SubstituteResponseSerializer(serializers.Serializer):
+    accept = serializers.BooleanField()
+    note = serializers.CharField(max_length=500, required=False, default="",
+                                 allow_blank=True)
+
+
+class ResumptionSerializer(serializers.Serializer):
+    actual_return_date = serializers.DateField()
+    note = serializers.CharField(max_length=500, required=False, default="",
+                                 allow_blank=True)
+
+
+class VerifySerializer(serializers.Serializer):
+    verified = serializers.BooleanField()
+    note = serializers.CharField(max_length=500, required=False, default="",
+                                 allow_blank=True)
+
+
+class TransitionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveTransition
+        fields = ["from_status", "to_status", "event", "actor_role", "note", "at"]
+
+
+class LedgerEntrySerializer(serializers.ModelSerializer):
+    request_id = serializers.IntegerField(read_only=True, allow_null=True)
+
+    class Meta:
+        model = LedgerEntry
+        fields = ["id", "category", "entry_type", "delta", "year", "request_id",
+                  "note", "at"]
+
+
+class BalanceSerializer(serializers.Serializer):
+    user_id = serializers.IntegerField()
+    balances = serializers.DictField(child=serializers.DecimalField(
+        max_digits=7, decimal_places=2))
+    pending = serializers.DictField(child=serializers.DecimalField(
+        max_digits=7, decimal_places=2))
+    history = LedgerEntrySerializer(many=True)
+
+
+class PolicyVersionSerializer(serializers.ModelSerializer):
+    status = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = PolicyVersion
+        fields = ["id", "name", "params", "hierarchy", "effective_from", "status",
+                  "published_at", "created_at"]
+        read_only_fields = ["id", "status", "published_at", "created_at"]
+
+
+class CalendarEntrySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = CalendarEntry
+        fields = ["kind", "name", "start_date", "end_date"]
+
+
+class CalendarVersionSerializer(serializers.ModelSerializer):
+    entries = CalendarEntrySerializer(many=True)
+    status = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = CalendarVersion
+        fields = ["id", "name", "effective_from", "status", "published_at", "entries",
+                  "created_at"]
+        read_only_fields = ["id", "status", "published_at", "created_at"]
+
+
+class OfflineInputSerializer(serializers.Serializer):
+    user_id = serializers.IntegerField()
+    category = serializers.ChoiceField(choices=CATEGORY_CHOICES)
+    start_date = serializers.DateField()
+    end_date = serializers.DateField()
+    half = serializers.ChoiceField(choices=["", *c.HALVES], required=False, default="")
+    purpose = serializers.CharField(max_length=2000, required=False, default="",
+                                    allow_blank=True)
+    sanction_reference = serializers.CharField(max_length=120)
+    sanctioned_by = serializers.CharField(max_length=120)
+    sanctioned_on = serializers.DateField()
+    evidence_note = serializers.CharField(max_length=500, required=False, default="",
+                                          allow_blank=True)
+
+
+class OfflineRecordSerializer(serializers.ModelSerializer):
+    leave = LeaveRequestSerializer(source="request", read_only=True)
+
+    class Meta:
+        model = OfflineLeaveRecord
+        fields = ["id", "sanction_reference", "sanctioned_by", "sanctioned_on",
+                  "evidence_note", "recorded_by_user_id", "created_at", "leave"]
+
+
+class NotificationSerializer(serializers.ModelSerializer):
+    request_id = serializers.IntegerField(read_only=True, allow_null=True)
+
+    class Meta:
+        model = Notification
+        fields = ["id", "message", "request_id", "created_at", "read_at"]
diff --git a/modules/elm/api/urls.py b/modules/elm/api/urls.py
new file mode 100644
index 00000000..3dd751fd
--- /dev/null
+++ b/modules/elm/api/urls.py
@@ -0,0 +1,37 @@
+from django.urls import path
+
+from modules.elm.api import views as v
+
+urlpatterns = [
+    path("requests", v.RequestListView.as_view(), name="elm-requests"),
+    path("requests/<int:pk>", v.RequestDetailView.as_view(), name="elm-request"),
+    path("requests/<int:pk>/modify", v.ModifyView.as_view(), name="elm-request-modify"),
+    path("requests/<int:pk>/withdraw", v.WithdrawView.as_view(),
+         name="elm-request-withdraw"),
+    path("requests/<int:pk>/cancel", v.CancelView.as_view(), name="elm-request-cancel"),
+    path("requests/<int:pk>/substitute", v.RenominateView.as_view(),
+         name="elm-request-substitute"),
+    path("requests/<int:pk>/extend", v.ExtendView.as_view(), name="elm-request-extend"),
+    path("requests/<int:pk>/resume", v.ResumeView.as_view(), name="elm-request-resume"),
+    path("requests/<int:pk>/print", v.PrintView.as_view(), name="elm-request-print"),
+    path("balances", v.BalanceView.as_view(), name="elm-balances"),
+    path("employees", v.EmployeeSearchView.as_view(), name="elm-employees"),
+    path("notifications", v.NotificationListView.as_view(), name="elm-notifications"),
+    path("substitutions", v.SubstitutionListView.as_view(), name="elm-substitutions"),
+    path("substitutions/<int:pk>/respond", v.SubstitutionRespondView.as_view(),
+         name="elm-substitution-respond"),
+    path("queue", v.QueueView.as_view(), name="elm-queue"),
+    path("queue/<int:pk>/decide", v.DecideView.as_view(), name="elm-decide"),
+    path("resumptions", v.ResumptionQueueView.as_view(), name="elm-resumptions"),
+    path("resumptions/<int:pk>/verify", v.VerifyView.as_view(), name="elm-verify"),
+    path("admin/policies", v.PolicyListView.as_view(), name="elm-policies"),
+    path("admin/policies/<int:pk>", v.PolicyDetailView.as_view(), name="elm-policy"),
+    path("admin/policies/<int:pk>/publish", v.PolicyPublishView.as_view(),
+         name="elm-policy-publish"),
+    path("admin/calendars", v.CalendarListView.as_view(), name="elm-calendars"),
+    path("admin/calendars/<int:pk>", v.CalendarDetailView.as_view(), name="elm-calendar"),
+    path("admin/calendars/<int:pk>/publish", v.CalendarPublishView.as_view(),
+         name="elm-calendar-publish"),
+    path("admin/offline", v.OfflineListView.as_view(), name="elm-offline"),
+    path("admin/accounts", v.AccountView.as_view(), name="elm-account"),
+]
diff --git a/modules/elm/api/views.py b/modules/elm/api/views.py
new file mode 100644
index 00000000..600f1a81
--- /dev/null
+++ b/modules/elm/api/views.py
@@ -0,0 +1,857 @@
+"""HTTP layer for ELM endpoints."""
+from __future__ import annotations
+
+from django.db import transaction
+from django.http import HttpResponse
+from django.utils import timezone
+from rest_framework import generics, status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from core.api.exceptions import BadRequestError, ConflictError, NotFoundError
+from fusion_auth.permissions import HasModuleGrant, HasPermission
+from modules.directory import contracts as directory
+from modules.elm.api import serializers as s
+from modules.elm.domain import categories as c
+from modules.elm.domain import permissions as p
+from modules.elm.domain import state_machine as sm
+from modules.elm.domain.counting import (
+    InvalidPeriod,
+    chargeable_days,
+    validate_rh_dates,
+    validate_vacation,
+)
+from modules.elm.domain.overlap import Interval, overlaps
+from modules.elm.domain.policy import NotEligible
+from modules.elm.domain.routing import (
+    RouteUnresolved,
+    resolve_route,
+    resumption_verifier,
+)
+from modules.elm.models import (
+    CalendarVersion,
+    LeaveRequest,
+    LeaveTransition,
+    LedgerEntry,
+    Notification,
+    OfflineLeaveRecord,
+    PolicyVersion,
+)
+from modules.elm.selectors.config import (
+    effective_calendar,
+    effective_calendar_version,
+    effective_policy,
+)
+from modules.elm.services import config as config_service
+from modules.elm.services import ledger as ledger_service
+
+MODULE = HasModuleGrant("elm")
+
+
+def _actor(request):
+    return getattr(request, "principal", None)
+
+
+def _names_context(qs) -> dict:
+    uids = set()
+    for r in qs:
+        uids.add(r.user_id)
+        if r.substitute_user_id:
+            uids.add(r.substitute_user_id)
+    if not uids:
+        return {}
+    return directory.get_users(list(uids))
+
+
+def _record_transition(req: LeaveRequest, frm: str, to: str, event: str,
+                       actor_uid: int | None, actor_role: str = "", note: str = "") -> None:
+    LeaveTransition.objects.create(
+        request=req,
+        from_status=frm,
+        to_status=to,
+        event=event,
+        actor_user_id=actor_uid,
+        actor_role=actor_role,
+        note=note,
+    )
+
+
+class RequestListView(generics.ListCreateAPIView):
+    serializer_class = s.LeaveRequestSerializer
+
+    def get_permissions(self):
+        perm = p.P_CREATE if self.request.method == "POST" else p.P_VIEW
+        return [MODULE, HasPermission(perm)]
+
+    def get_queryset(self):
+        actor = _actor(self.request)
+        return LeaveRequest.objects.filter(user_id=actor.user_id).order_by("-created_at", "-id")
+
+    def get_serializer_context(self):
+        ctx = super().get_serializer_context()
+        ctx["names"] = _names_context(self.get_queryset())
+        return ctx
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        inp = s.LeaveInputSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        actor = _actor(request)
+        pv, policy = effective_policy()
+        if pv is None or policy is None:
+            raise BadRequestError("No published leave policy is active.", code="no_policy")
+
+        users = directory.get_users([actor.user_id])
+        prof = users.get(actor.user_id)
+        kind = getattr(prof, "kind", "") or "faculty"
+        unit = getattr(prof, "department", "") or ""
+        try:
+            policy.check_eligible(kind, d["category"])
+        except NotEligible as exc:
+            raise BadRequestError(str(exc), code="not_eligible") from exc
+
+        if d["category"] in (c.RH, c.VL) and effective_calendar_version() is None:
+            raise BadRequestError("No holiday calendar is published.", code="no_calendar")
+        cal = effective_calendar()
+        try:
+            if d["category"] == c.RH:
+                validate_rh_dates(d["start_date"], d["end_date"], cal)
+            elif d["category"] == c.VL:
+                validate_vacation(d["start_date"], d["end_date"], cal)
+            days = chargeable_days(
+                d["category"], d["start_date"], d["end_date"], d.get("half") or None, cal
+            )
+        except InvalidPeriod as exc:
+            raise BadRequestError(str(exc), code="invalid_period") from exc
+
+        for existing in LeaveRequest.objects.filter(
+            user_id=actor.user_id, status__in=list(sm.ACTIVE)
+        ):
+            if overlaps(
+                Interval(d["start_date"], d["end_date"], d.get("half") or None),
+                Interval(existing.start_date, existing.end_date, existing.half or None),
+            ):
+                raise ConflictError("Overlaps with an existing leave request.", code="overlap")
+
+        try:
+            steps = resolve_route(
+                category=d["category"],
+                kind=kind,
+                unit=unit,
+                applicant_roles=getattr(actor, "roles", []),
+                hierarchy=pv.hierarchy,
+            )
+        except RouteUnresolved as exc:
+            raise BadRequestError(str(exc), code="route_unresolved") from exc
+
+        sub_uid = d.get("substitute_user_id")
+        if sub_uid:
+            init_status = sm.AWAITING_SUBSTITUTE
+            cur_role = ""
+            sub_status = "pending"
+        else:
+            init_status = sm.STATE_FOR_STEP[steps[0].step]
+            cur_role = steps[0].role
+            sub_status = ""
+
+        req = LeaveRequest.objects.create(
+            user_id=actor.user_id,
+            kind=LeaveRequest.LEAVE,
+            category=d["category"],
+            applicant_kind=kind,
+            applicant_unit=unit,
+            start_date=d["start_date"],
+            end_date=d["end_date"],
+            half=d.get("half") or "",
+            days=days,
+            purpose=d["purpose"],
+            medical_evidence=d.get("medical_evidence") or "",
+            station_leave=bool(d.get("station_leave")),
+            station_from=d.get("station_from"),
+            station_to=d.get("station_to"),
+            station_address=d.get("station_address") or "",
+            substitute_user_id=sub_uid,
+            substitute_status=sub_status,
+            responsibility=d.get("responsibility") or "",
+            status=init_status,
+            route=[st.as_dict() for st in steps],
+            stage=0,
+            current_role=cur_role,
+            stage_entered_at=timezone.now(),
+            policy_version_id=pv.pk,
+        )
+        _record_transition(req, sm.NEW, init_status, sm.SUBMIT, actor.user_id)
+        return Response(
+            s.LeaveRequestSerializer(req, context={"names": _names_context([req])}).data,
+            status=status.HTTP_201_CREATED,
+        )
+
+
+class RequestDetailView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_VIEW)]
+
+    def get(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.filter(pk=pk, user_id=actor.user_id).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        data = s.LeaveRequestSerializer(req, context={"names": _names_context([req])}).data
+        data["history"] = s.TransitionSerializer(
+            req.transitions.order_by("at", "id"), many=True
+        ).data
+        return Response(data)
+
+
+class ModifyView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_UPDATE)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, user_id=actor.user_id
+        ).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        if req.status not in sm.PENDING:
+            raise ConflictError("Only pending requests can be modified.", code="not_pending")
+        inp = s.LeaveInputSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        cal = effective_calendar()
+        try:
+            days = chargeable_days(
+                d["category"], d["start_date"], d["end_date"], d.get("half") or None, cal
+            )
+        except InvalidPeriod as exc:
+            raise BadRequestError(str(exc), code="invalid_period") from exc
+
+        frm = req.status
+        sub_uid = d.get("substitute_user_id")
+        if sub_uid:
+            to_status = sm.AWAITING_SUBSTITUTE
+            cur_role = ""
+            sub_status = "pending"
+        else:
+            step0 = req.route[0]
+            to_status = sm.STATE_FOR_STEP[step0["step"]]
+            cur_role = step0["role"]
+            sub_status = ""
+
+        req.category = d["category"]
+        req.start_date = d["start_date"]
+        req.end_date = d["end_date"]
+        req.half = d.get("half") or ""
+        req.days = days
+        req.purpose = d["purpose"]
+        req.medical_evidence = d.get("medical_evidence") or ""
+        req.station_leave = bool(d.get("station_leave"))
+        req.station_from = d.get("station_from")
+        req.station_to = d.get("station_to")
+        req.station_address = d.get("station_address") or ""
+        req.substitute_user_id = sub_uid
+        req.substitute_status = sub_status
+        req.responsibility = d.get("responsibility") or ""
+        req.status = to_status
+        req.stage = 0
+        req.current_role = cur_role
+        req.stage_entered_at = timezone.now()
+        req.save()
+        _record_transition(req, frm, to_status, sm.MODIFY, actor.user_id)
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class WithdrawView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_WITHDRAW)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, user_id=actor.user_id
+        ).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        if req.status not in sm.PENDING:
+            raise ConflictError("Only pending requests can be withdrawn.", code="not_pending")
+        inp = s.ReasonSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        frm = req.status
+        req.status = sm.WITHDRAWN
+        req.current_role = ""
+        req.save(update_fields=["status", "current_role", "updated_at"])
+        _record_transition(
+            req, frm, sm.WITHDRAWN, sm.WITHDRAW, actor.user_id, note=inp.validated_data["reason"]
+        )
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class CancelView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_UPDATE)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, user_id=actor.user_id
+        ).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        if req.status != sm.APPROVED or req.start_date <= timezone.localdate():
+            raise ConflictError("Leave can only be cancelled before it starts.", code="invalid_state")
+        inp = s.ReasonSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        req.status = sm.CANCELLATION_PENDING
+        req.stage = 0
+        req.current_role = req.route[0]["role"] if req.route else ""
+        req.stage_entered_at = timezone.now()
+        req.save()
+        _record_transition(
+            req, sm.APPROVED, sm.CANCELLATION_PENDING, sm.REQUEST_CANCELLATION,
+            actor.user_id, note=inp.validated_data["reason"]
+        )
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class RenominateView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_UPDATE)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, user_id=actor.user_id
+        ).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        if req.status != sm.SUBSTITUTE_DECLINED:
+            raise ConflictError("Request is not awaiting renomination.", code="invalid_state")
+        inp = s.RenominateSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        req.substitute_user_id = d["substitute_user_id"]
+        req.substitute_status = "pending"
+        req.responsibility = d.get("responsibility") or req.responsibility
+        req.status = sm.AWAITING_SUBSTITUTE
+        req.save()
+        _record_transition(
+            req, sm.SUBSTITUTE_DECLINED, sm.AWAITING_SUBSTITUTE, sm.RENOMINATE, actor.user_id
+        )
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class ExtendView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_CREATE)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        parent = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, user_id=actor.user_id
+        ).first()
+        if parent is None:
+            raise NotFoundError("Leave request not found.")
+        if parent.status != sm.APPROVED or parent.category not in c.EXTENDABLE:
+            raise ConflictError("Only ongoing EL, COL or VL can be extended.", code="invalid_state")
+        inp = s.ExtensionSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        from datetime import timedelta
+
+        ext_start = parent.end_date + timedelta(days=1)
+        cal = effective_calendar()
+        try:
+            days = chargeable_days(parent.category, ext_start, d["end_date"], None, cal)
+        except InvalidPeriod as exc:
+            raise BadRequestError(str(exc), code="invalid_period") from exc
+        step0 = parent.route[0]
+        init_status = sm.STATE_FOR_STEP[step0["step"]]
+        ext = LeaveRequest.objects.create(
+            user_id=actor.user_id,
+            kind=LeaveRequest.EXTENSION,
+            parent=parent,
+            category=parent.category,
+            applicant_kind=parent.applicant_kind,
+            applicant_unit=parent.applicant_unit,
+            start_date=ext_start,
+            end_date=d["end_date"],
+            days=days,
+            purpose=d["purpose"],
+            status=init_status,
+            route=parent.route,
+            stage=0,
+            current_role=step0["role"],
+            stage_entered_at=timezone.now(),
+            policy_version_id=parent.policy_version_id,
+        )
+        _record_transition(ext, sm.NEW, init_status, sm.SUBMIT, actor.user_id)
+        return Response(s.LeaveRequestSerializer(ext).data, status=status.HTTP_201_CREATED)
+
+
+class ResumeView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_UPDATE)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, user_id=actor.user_id
+        ).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        if req.status != sm.APPROVED or req.category not in c.RESUMABLE:
+            raise ConflictError("Resumption is not applicable.", code="invalid_state")
+        inp = s.ResumptionSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        pv, _ = effective_policy()
+        verifier = resumption_verifier(req.route, pv.hierarchy if pv else {})
+        req.actual_return_date = d["actual_return_date"]
+        req.resumption_note = d.get("note") or ""
+        req.status = sm.RESUMPTION_PENDING
+        req.current_role = verifier
+        req.stage_entered_at = timezone.now()
+        req.save()
+        _record_transition(
+            req, sm.APPROVED, sm.RESUMPTION_PENDING, sm.SUBMIT_RESUMPTION,
+            actor.user_id, note=req.resumption_note
+        )
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class PrintView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_VIEW)]
+
+    def get(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.filter(pk=pk, user_id=actor.user_id).first()
+        if req is None:
+            raise NotFoundError("Leave request not found.")
+        body = (
+            f"Leave Application #{req.pk}\n"
+            f"Category: {c.LABELS.get(req.category, req.category)}\n"
+            f"Period: {req.start_date} to {req.end_date} ({req.days} days)\n"
+            f"Status: {req.status}\n"
+            f"Purpose: {req.purpose}\n"
+        )
+        res = HttpResponse(body, content_type="text/plain; charset=utf-8")
+        res["Content-Disposition"] = f'attachment; filename="leave-{req.pk}.txt"'
+        return res
+
+
+class BalanceView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_BALANCE)]
+
+    def get(self, request):
+        actor = _actor(request)
+        users = directory.get_users([actor.user_id])
+        prof = users.get(actor.user_id)
+        kind = getattr(prof, "kind", "") or "faculty"
+        acc = ledger_service.get_account(actor.user_id, kind)
+        return Response(s.BalanceSerializer(acc).data)
+
+
+class EmployeeSearchView(APIView):
+    permission_classes = [MODULE]
+
+    def get(self, request):
+        q = (request.query_params.get("q") or "").strip()
+        actor = _actor(request)
+        if len(q) < 2:
+            return Response({"results": []})
+        hits = directory.search(q, limit=20)
+        results = [
+            {
+                "user_id": u.user_id,
+                "display_name": u.display_name,
+                "username": u.username,
+                "kind": u.kind,
+                "department": u.department,
+            }
+            for u in hits
+            if u.kind in c.EMPLOYEE_KINDS and u.user_id != getattr(actor, "user_id", None)
+        ]
+        return Response({"results": results})
+
+
+class NotificationListView(generics.ListAPIView):
+    permission_classes = [MODULE]
+    serializer_class = s.NotificationSerializer
+
+    def get_queryset(self):
+        actor = _actor(self.request)
+        roles = list(getattr(actor, "roles", []) or [])
+        from django.db.models import Q
+
+        return Notification.objects.filter(
+            Q(recipient_user_id=actor.user_id) | Q(recipient_role__in=roles)
+        ).order_by("-created_at", "-id")
+
+
+class SubstitutionListView(generics.ListAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_SUBSTITUTE)]
+    serializer_class = s.LeaveRequestSerializer
+
+    def get_queryset(self):
+        actor = _actor(self.request)
+        return LeaveRequest.objects.filter(substitute_user_id=actor.user_id).order_by(
+            "-created_at", "-id"
+        )
+
+    def get_serializer_context(self):
+        ctx = super().get_serializer_context()
+        ctx["names"] = _names_context(self.get_queryset())
+        return ctx
+
+
+class SubstitutionRespondView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_SUBSTITUTE)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, substitute_user_id=actor.user_id
+        ).first()
+        if req is None:
+            raise NotFoundError("Substitution request not found.")
+        if req.status != sm.AWAITING_SUBSTITUTE:
+            raise ConflictError("Request is no longer awaiting substitute response.",
+                                code="invalid_state")
+        inp = s.SubstituteResponseSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        if d["accept"]:
+            step0 = req.route[0]
+            to_status = sm.STATE_FOR_STEP[step0["step"]]
+            req.substitute_status = "accepted"
+            req.status = to_status
+            req.stage = 0
+            req.current_role = step0["role"]
+            req.stage_entered_at = timezone.now()
+            event = sm.SUBSTITUTE_ACCEPT
+        else:
+            to_status = sm.SUBSTITUTE_DECLINED
+            req.substitute_status = "declined"
+            req.status = to_status
+            req.current_role = ""
+            event = sm.SUBSTITUTE_DECLINE
+        req.save()
+        _record_transition(req, sm.AWAITING_SUBSTITUTE, to_status, event,
+                           actor.user_id, note=d.get("note") or "")
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class QueueView(generics.ListAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_REVIEW)]
+    serializer_class = s.LeaveRequestSerializer
+
+    def get_queryset(self):
+        actor = _actor(self.request)
+        roles = list(getattr(actor, "roles", []) or [])
+        return LeaveRequest.objects.filter(
+            current_role__in=roles,
+            status__in=[
+                sm.AWAITING_UNIT_HEAD,
+                sm.AWAITING_ESTABLISHMENT,
+                sm.AWAITING_SANCTION,
+                sm.AWAITING_DIRECTOR,
+                sm.CANCELLATION_PENDING,
+            ],
+        ).order_by("created_at", "id")
+
+    def get_serializer_context(self):
+        ctx = super().get_serializer_context()
+        ctx["queue"] = True
+        ctx["names"] = _names_context(self.get_queryset())
+        return ctx
+
+
+class DecideView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_REVIEW)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        roles = set(getattr(actor, "roles", []) or [])
+        req = LeaveRequest.objects.select_for_update().filter(pk=pk).first()
+        if req is None or req.current_role not in roles:
+            raise NotFoundError("Leave request not in your queue.")
+        inp = s.DecisionSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        event = inp.validated_data["event"]
+        note = inp.validated_data.get("note") or ""
+        frm = req.status
+        role_used = req.current_role
+
+        if event in (sm.RECOMMEND, sm.NOT_RECOMMEND, sm.FORWARD):
+            if event in (sm.RECOMMEND, sm.NOT_RECOMMEND):
+                req.recommendation = (
+                    "recommended" if event == sm.RECOMMEND else "not_recommended"
+                )
+            req.stage += 1
+            nxt = req.current_step
+            if nxt is None:
+                raise ConflictError("No next step in route.", code="invalid_route")
+            to_status = sm.STATE_FOR_STEP[nxt["step"]]
+            req.status = to_status
+            req.current_role = nxt["role"]
+            req.stage_entered_at = timezone.now()
+        elif event == sm.APPROVE:
+            to_status = sm.APPROVED
+            req.status = to_status
+            req.current_role = ""
+            req.decision_note = note
+            req.decided_at = timezone.now()
+            LedgerEntry.objects.get_or_create(
+                request=req,
+                entry_type=LedgerEntry.DEBIT,
+                defaults={
+                    "user_id": req.user_id,
+                    "category": req.category,
+                    "delta": -req.days,
+                    "year": req.start_date.year,
+                    "note": f"Leave #{req.pk} approved",
+                },
+            )
+        elif event == sm.REJECT:
+            to_status = sm.REJECTED
+            req.status = to_status
+            req.current_role = ""
+            req.decision_note = note
+            req.decided_at = timezone.now()
+        elif event == sm.CANCEL_ADVANCE:
+            req.stage += 1
+            nxt = req.current_step
+            if nxt is None:
+                raise ConflictError("No next step in route.", code="invalid_route")
+            to_status = sm.CANCELLATION_PENDING
+            req.current_role = nxt["role"]
+            req.stage_entered_at = timezone.now()
+        elif event == sm.CANCEL_APPROVE:
+            to_status = sm.CANCELLED
+            req.status = to_status
+            req.current_role = ""
+            LedgerEntry.objects.get_or_create(
+                request=req,
+                entry_type=LedgerEntry.REVERSAL,
+                defaults={
+                    "user_id": req.user_id,
+                    "category": req.category,
+                    "delta": req.days,
+                    "year": req.start_date.year,
+                    "note": f"Leave #{req.pk} cancelled",
+                },
+            )
+        elif event == sm.CANCEL_REJECT:
+            to_status = sm.APPROVED
+            req.status = to_status
+            req.current_role = ""
+        else:
+            raise BadRequestError("Unsupported decision event.", code="invalid_event")
+
+        req.save()
+        _record_transition(req, frm, to_status, event, actor.user_id, role_used, note)
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class ResumptionQueueView(generics.ListAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_RESUMPTION)]
+    serializer_class = s.LeaveRequestSerializer
+
+    def get_queryset(self):
+        actor = _actor(self.request)
+        roles = list(getattr(actor, "roles", []) or [])
+        return LeaveRequest.objects.filter(
+            status=sm.RESUMPTION_PENDING, current_role__in=roles
+        ).order_by("created_at", "id")
+
+    def get_serializer_context(self):
+        ctx = super().get_serializer_context()
+        ctx["names"] = _names_context(self.get_queryset())
+        return ctx
+
+
+class VerifyView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_RESUMPTION)]
+
+    @transaction.atomic
+    def post(self, request, pk: int):
+        actor = _actor(request)
+        roles = set(getattr(actor, "roles", []) or [])
+        req = LeaveRequest.objects.select_for_update().filter(
+            pk=pk, status=sm.RESUMPTION_PENDING
+        ).first()
+        if req is None or req.current_role not in roles:
+            raise NotFoundError("Resumption request not found.")
+        inp = s.VerifySerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        role_used = req.current_role
+        if d["verified"]:
+            req.status = sm.CLOSED
+            req.current_role = ""
+            req.save(update_fields=["status", "current_role", "updated_at"])
+            _record_transition(
+                req, sm.RESUMPTION_PENDING, sm.CLOSED, sm.VERIFY_RESUMPTION,
+                actor.user_id, role_used, d.get("note") or ""
+            )
+        else:
+            req.status = sm.APPROVED
+            req.current_role = ""
+            req.save(update_fields=["status", "current_role", "updated_at"])
+            _record_transition(
+                req, sm.RESUMPTION_PENDING, sm.APPROVED, "resumption_rejected",
+                actor.user_id, role_used, d.get("note") or ""
+            )
+        return Response(s.LeaveRequestSerializer(req).data)
+
+
+class PolicyListView(generics.ListCreateAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_POLICY)]
+    serializer_class = s.PolicyVersionSerializer
+    queryset = PolicyVersion.objects.all().order_by("-effective_from", "-id")
+
+    def perform_create(self, serializer):
+        actor = _actor(self.request)
+        d = serializer.validated_data
+        pv = config_service.create_policy(
+            name=d["name"],
+            effective_from=d["effective_from"],
+            params=d["params"],
+            hierarchy=d["hierarchy"],
+            actor_user_id=getattr(actor, "user_id", None),
+        )
+        serializer.instance = pv
+
+
+class PolicyDetailView(generics.RetrieveAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_POLICY)]
+    serializer_class = s.PolicyVersionSerializer
+    queryset = PolicyVersion.objects.all()
+
+
+class PolicyPublishView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_POLICY)]
+
+    def post(self, request, pk: int):
+        pv = config_service.publish_policy(pk)
+        return Response(s.PolicyVersionSerializer(pv).data)
+
+
+class CalendarListView(generics.ListCreateAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_CALENDAR)]
+    serializer_class = s.CalendarVersionSerializer
+    queryset = CalendarVersion.objects.prefetch_related("entries").order_by(
+        "-effective_from", "-id"
+    )
+
+    def create(self, request, *args, **kwargs):
+        ser = self.get_serializer(data=request.data)
+        ser.is_valid(raise_exception=True)
+        d = ser.validated_data
+        actor = _actor(request)
+        cv = config_service.create_calendar(
+            name=d["name"],
+            effective_from=d["effective_from"],
+            entries=d.get("entries") or [],
+            actor_user_id=getattr(actor, "user_id", None),
+        )
+        return Response(
+            s.CalendarVersionSerializer(cv).data, status=status.HTTP_201_CREATED
+        )
+
+
+class CalendarDetailView(generics.RetrieveAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_CALENDAR)]
+    serializer_class = s.CalendarVersionSerializer
+    queryset = CalendarVersion.objects.prefetch_related("entries")
+
+
+class CalendarPublishView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_CALENDAR)]
+
+    def post(self, request, pk: int):
+        cv = config_service.publish_calendar(pk)
+        return Response(s.CalendarVersionSerializer(cv).data)
+
+
+class OfflineListView(generics.ListCreateAPIView):
+    permission_classes = [MODULE, HasPermission(p.P_OFFLINE)]
+    serializer_class = s.OfflineRecordSerializer
+    queryset = OfflineLeaveRecord.objects.select_related("request").order_by(
+        "-created_at", "-id"
+    )
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        inp = s.OfflineInputSerializer(data=request.data)
+        inp.is_valid(raise_exception=True)
+        d = inp.validated_data
+        actor = _actor(request)
+        cal = effective_calendar()
+        try:
+            days = chargeable_days(
+                d["category"], d["start_date"], d["end_date"], d.get("half") or None, cal
+            )
+        except InvalidPeriod as exc:
+            raise BadRequestError(str(exc), code="invalid_period") from exc
+        users = directory.get_users([d["user_id"]])
+        prof = users.get(d["user_id"])
+        kind = getattr(prof, "kind", "") or "faculty"
+        unit = getattr(prof, "department", "") or ""
+        req = LeaveRequest.objects.create(
+            user_id=d["user_id"],
+            kind=LeaveRequest.OFFLINE,
+            category=d["category"],
+            applicant_kind=kind,
+            applicant_unit=unit,
+            start_date=d["start_date"],
+            end_date=d["end_date"],
+            half=d.get("half") or "",
+            days=days,
+            purpose=d.get("purpose") or "Offline sanctioned leave",
+            status=sm.APPROVED,
+            decided_at=timezone.now(),
+        )
+        rec = OfflineLeaveRecord.objects.create(
+            request=req,
+            sanction_reference=d["sanction_reference"],
+            sanctioned_by=d["sanctioned_by"],
+            sanctioned_on=d["sanctioned_on"],
+            evidence_note=d.get("evidence_note") or "",
+            recorded_by_user_id=actor.user_id,
+        )
+        LedgerEntry.objects.create(
+            user_id=d["user_id"],
+            category=d["category"],
+            entry_type=LedgerEntry.OFFLINE_DEBIT,
+            delta=-days,
+            year=d["start_date"].year,
+            request=req,
+            note=f"Offline ref {d['sanction_reference']}",
+        )
+        _record_transition(req, sm.NEW, sm.APPROVED, sm.RECORD_OFFLINE, actor.user_id)
+        return Response(
+            s.OfflineRecordSerializer(rec).data, status=status.HTTP_201_CREATED
+        )
+
+
+class AccountView(APIView):
+    permission_classes = [MODULE, HasPermission(p.P_ACCOUNT_VIEW)]
+
+    def get(self, request):
+        raw_uid = request.query_params.get("user_id")
+        try:
+            uid = int(raw_uid)
+        except (TypeError, ValueError) as exc:
+            raise BadRequestError("user_id is required.", code="invalid_filter") from exc
+        users = directory.get_users([uid])
+        prof = users.get(uid)
+        kind = getattr(prof, "kind", "") or ""
+        acc = ledger_service.get_account(uid, kind)
+        data = s.BalanceSerializer(acc).data
+        if prof:
+            data["display_name"] = prof.display_name
+        return Response(data)
diff --git a/modules/elm/apps.py b/modules/elm/apps.py
new file mode 100644
index 00000000..f1c77b9d
--- /dev/null
+++ b/modules/elm/apps.py
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ElmConfig(AppConfig):
+    name = "modules.elm"
+    label = "elm"
diff --git a/modules/elm/contracts.py b/modules/elm/contracts.py
new file mode 100644
index 00000000..c79d046d
--- /dev/null
+++ b/modules/elm/contracts.py
@@ -0,0 +1,22 @@
+"""Cross-module contracts exposed by ELM."""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from datetime import date
+
+from modules.elm.domain import state_machine as sm
+from modules.elm.models import LeaveRequest
+
+
+def get_on_leave(user_ids: Sequence[int], on: date) -> set[int]:
+    """Return user_ids from `user_ids` who have approved leave covering `on`."""
+    if not user_ids:
+        return set()
+    return set(
+        LeaveRequest.objects.filter(
+            user_id__in=list(user_ids),
+            status__in=[sm.APPROVED, sm.CANCELLATION_PENDING, sm.RESUMPTION_PENDING],
+            start_date__lte=on,
+            end_date__gte=on,
+        ).values_list("user_id", flat=True)
+    )
diff --git a/modules/elm/domain/__init__.py b/modules/elm/domain/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/domain/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/domain/categories.py b/modules/elm/domain/categories.py
new file mode 100644
index 00000000..50f382be
--- /dev/null
+++ b/modules/elm/domain/categories.py
@@ -0,0 +1,43 @@
+"""Leave categories in the study baseline (SRS-EL-002)."""
+from __future__ import annotations
+
+CL = "CL"
+RH = "RH"
+SCL = "SCL"
+EL = "EL"
+COL = "COL"
+VL = "VL"
+
+ALL = (CL, RH, SCL, EL, COL, VL)
+
+LABELS = {
+    CL: "Casual Leave", RH: "Restricted Holiday", SCL: "Special Casual Leave",
+    EL: "Earned Leave", COL: "Commuted Leave", VL: "Vacation Leave",
+}
+
+#: BR-EL-016: the Unit Head is final for these.
+UNIT_HEAD_FINAL = frozenset({CL, RH})
+
+#: BR-EL-017/018: Unit Head recommends, the configured hierarchy decides.
+HIGHER_SANCTION = frozenset({SCL, EL, COL, VL})
+
+#: BR-EL-011: intervening weekends and closed holidays count.
+CONTINUOUS = frozenset({EL, COL, VL})
+
+#: BR-EL-025, BR-EL-027: extension and resumption apply only to these.
+EXTENDABLE = frozenset({EL, COL, VL})
+RESUMABLE = frozenset({EL, COL, VL})
+
+#: BR-EL-002..004: lapse at year end.
+LAPSING = frozenset({CL, RH, SCL})
+
+#: BR-EL-005, BR-EL-008, BR-EL-009: carry forward.
+CARRY_FORWARD = frozenset({EL, COL})
+
+FIRST_HALF = "first"
+SECOND_HALF = "second"
+HALVES = (FIRST_HALF, SECOND_HALF)
+
+FACULTY = "faculty"
+STAFF = "staff"
+EMPLOYEE_KINDS = (FACULTY, STAFF)
diff --git a/modules/elm/domain/counting.py b/modules/elm/domain/counting.py
new file mode 100644
index 00000000..c0b55b72
--- /dev/null
+++ b/modules/elm/domain/counting.py
@@ -0,0 +1,75 @@
+"""Chargeable days and calendar checks (BR-EL-003, 006, 010, 011, 031)."""
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from decimal import Decimal
+
+from modules.elm.domain import categories as c
+
+HALF = Decimal("0.5")
+
+
+class InvalidPeriod(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Calendar:
+    closed_holidays: frozenset[date] = frozenset()
+    restricted_holidays: frozenset[date] = frozenset()
+    vacations: tuple[tuple[date, date], ...] = field(default_factory=tuple)
+
+
+def _days(start: date, end: date) -> Iterable[date]:
+    d = start
+    while d <= end:
+        yield d
+        d += timedelta(days=1)
+
+
+def is_working_day(d: date, cal: Calendar) -> bool:
+    return d.weekday() < 5 and d not in cal.closed_holidays
+
+
+def validate_period(category: str, start: date, end: date, half: str | None) -> None:
+    if end < start:
+        raise InvalidPeriod("The leave cannot end before it starts.")
+    if half:
+        if category != c.CL:
+            raise InvalidPeriod("Only Casual Leave can be taken as a half day.")
+        if half not in c.HALVES:
+            raise InvalidPeriod("A half day must be the first or second half.")
+        if start != end:
+            raise InvalidPeriod("A half-day leave must start and end on the same date.")
+
+
+def validate_rh_dates(start: date, end: date, cal: Calendar) -> None:
+    for d in _days(start, end):
+        if d not in cal.restricted_holidays:
+            raise InvalidPeriod(
+                f"{d.isoformat()} is not a Restricted Holiday in the published calendar.")
+
+
+def validate_vacation(start: date, end: date, cal: Calendar) -> None:
+    if not any(vs <= start and end <= ve for vs, ve in cal.vacations):
+        raise InvalidPeriod(
+            "Vacation Leave can only be taken inside a published vacation period.")
+
+
+def chargeable_days(category: str, start: date, end: date, half: str | None,
+                    cal: Calendar) -> Decimal:
+    validate_period(category, start, end, half)
+    if half:
+        if not is_working_day(start, cal):
+            raise InvalidPeriod("A half-day leave must fall on a working day.")
+        return HALF
+    if category in c.CONTINUOUS:
+        return Decimal((end - start).days + 1)
+    if category == c.RH:
+        return Decimal(sum(1 for _ in _days(start, end)))
+    n = sum(1 for d in _days(start, end) if is_working_day(d, cal))
+    if n == 0:
+        raise InvalidPeriod("The requested period contains no working days.")
+    return Decimal(n)
diff --git a/modules/elm/domain/overlap.py b/modules/elm/domain/overlap.py
new file mode 100644
index 00000000..422118a5
--- /dev/null
+++ b/modules/elm/domain/overlap.py
@@ -0,0 +1,18 @@
+"""Overlap between two leave intervals (BR-EL-012, BR-EL-014)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+
+
+@dataclass(frozen=True)
+class Interval:
+    start: date
+    end: date
+    half: str | None = None
+
+
+def overlaps(a: Interval, b: Interval) -> bool:
+    if a.end < b.start or b.end < a.start:
+        return False
+    return not (a.half and b.half and a.start == b.start and a.half != b.half)
diff --git a/modules/elm/domain/permissions.py b/modules/elm/domain/permissions.py
new file mode 100644
index 00000000..e42e8d9d
--- /dev/null
+++ b/modules/elm/domain/permissions.py
@@ -0,0 +1,17 @@
+"""Permission codes, stated once; registry.py declares them, services check them."""
+
+P_VIEW = "elm.leave_request.view"
+P_CREATE = "elm.leave_request.create"
+P_UPDATE = "elm.leave_request.update"
+P_WITHDRAW = "elm.leave_request.delete"
+P_SUBSTITUTE = "elm.substitution.review"
+P_REVIEW = "elm.leave_request.review"
+P_APPROVE = "elm.leave_request.approve"
+P_RESUMPTION = "elm.resumption.review"
+P_BALANCE = "elm.leave_balance.view"
+P_ACCOUNT_VIEW = "elm.leave_account.view"
+P_POLICY = "elm.policy.publish"
+P_CALENDAR = "elm.calendar.publish"
+P_OFFLINE = "elm.offline_record.create"
+P_YEAR_END = "elm.year_end.process"
+P_SLA = "elm.sla.process"
diff --git a/modules/elm/domain/policy.py b/modules/elm/domain/policy.py
new file mode 100644
index 00000000..8374474d
--- /dev/null
+++ b/modules/elm/domain/policy.py
@@ -0,0 +1,76 @@
+"""Leave policy parameters and their validation (BR-EL-001..009, BR-EL-030)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal
+
+from modules.elm.domain import categories as c
+
+
+class PolicyInvalid(Exception):
+    pass
+
+
+class NotEligible(Exception):
+    pass
+
+
+#: The canonical case stated by the spec; seeded as the first published version.
+DEFAULT_PARAMS: dict = {
+    "annual_credit": {
+        c.FACULTY: {c.CL: 8, c.RH: 2, c.SCL: 15, c.EL: 0, c.COL: 20, c.VL: 60},
+        c.STAFF: {c.CL: 8, c.RH: 2, c.SCL: 15, c.EL: 30, c.COL: 20, c.VL: 0},
+    },
+    "eligible": {
+        c.FACULTY: [c.CL, c.RH, c.SCL, c.EL, c.COL, c.VL],
+        c.STAFF: [c.CL, c.RH, c.SCL, c.EL, c.COL],
+    },
+    "vl_to_el_ratio": 2,
+    "col_requires_medical_evidence": True,
+}
+
+
+@dataclass(frozen=True)
+class Policy:
+    annual_credit: dict
+    eligible: dict
+    vl_to_el_ratio: Decimal
+    col_requires_medical_evidence: bool
+
+    def annual_credit_for(self, kind: str, category: str) -> Decimal:
+        return Decimal(str(self.annual_credit.get(kind, {}).get(category, 0)))
+
+    def check_eligible(self, kind: str, category: str) -> None:
+        if category not in self.eligible.get(kind, []):
+            raise NotEligible(
+                f"{c.LABELS.get(category, category)} is not available to "
+                f"{kind or 'your'} employees under the current leave policy.")
+
+
+def parse(params: dict) -> Policy:
+    if not isinstance(params, dict):
+        raise PolicyInvalid("Policy parameters must be an object.")
+    credit = params.get("annual_credit")
+    eligible = params.get("eligible")
+    if not isinstance(credit, dict) or not isinstance(eligible, dict):
+        raise PolicyInvalid("Policy needs both annual_credit and eligible.")
+    for kind in c.EMPLOYEE_KINDS:
+        for cat, n in (credit.get(kind) or {}).items():
+            if cat not in c.ALL:
+                raise PolicyInvalid(f"Unknown leave category {cat!r}.")
+            try:
+                if Decimal(str(n)) < 0:
+                    raise PolicyInvalid(f"{kind} {cat} credit cannot be negative.")
+            except ArithmeticError as exc:
+                raise PolicyInvalid(f"{kind} {cat} credit must be a number.") from exc
+        for cat in eligible.get(kind) or []:
+            if cat not in c.ALL:
+                raise PolicyInvalid(f"Unknown leave category {cat!r}.")
+    ratio = Decimal(str(params.get("vl_to_el_ratio", 2)))
+    if ratio <= 0:
+        raise PolicyInvalid("vl_to_el_ratio must be positive.")
+    return Policy(
+        annual_credit=credit, eligible=eligible, vl_to_el_ratio=ratio,
+        col_requires_medical_evidence=bool(
+            params.get("col_requires_medical_evidence", True)),
+    )
diff --git a/modules/elm/domain/routing.py b/modules/elm/domain/routing.py
new file mode 100644
index 00000000..063f232e
--- /dev/null
+++ b/modules/elm/domain/routing.py
@@ -0,0 +1,102 @@
+"""Authority resolution (BR-EL-016..020, BR-EL-030)."""
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from modules.elm.domain import categories as c
+
+UNIT_HEAD = "unit_head"
+ESTABLISHMENT = "establishment"
+SANCTION = "sanction"
+DIRECTOR = "director"
+
+
+class RouteUnresolved(Exception):
+    pass
+
+
+class HierarchyInvalid(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Step:
+    step: str
+    role: str
+
+    def as_dict(self) -> dict:
+        return {"step": self.step, "role": self.role}
+
+
+def parse_hierarchy(h: dict) -> dict:
+    if not isinstance(h, dict):
+        raise HierarchyInvalid("The hierarchy must be an object.")
+    if not isinstance(h.get("unit_heads"), dict):
+        raise HierarchyInvalid("The hierarchy needs a unit_heads mapping.")
+    sanctioning = h.get("sanctioning")
+    if not isinstance(sanctioning, dict):
+        raise HierarchyInvalid("The hierarchy needs a sanctioning mapping.")
+    for kind in c.EMPLOYEE_KINDS:
+        if not (sanctioning.get(kind) or {}).get("default"):
+            raise HierarchyInvalid(f"No default sanctioning authority for {kind}.")
+    if not h.get("director_role"):
+        raise HierarchyInvalid("The hierarchy must name the Director's designation.")
+    return h
+
+
+def roles_in(h: dict) -> set[str]:
+    out = set(h["unit_heads"].values()) | {h["director_role"]}
+    if h.get("establishment_role"):
+        out.add(h["establishment_role"])
+    for per_kind in h["sanctioning"].values():
+        out |= {v for v in per_kind.values() if v}
+    return out
+
+
+def sanctioning_role(h: dict, kind: str, category: str) -> str:
+    per_kind = h["sanctioning"].get(kind) or {}
+    role = per_kind.get(category) or per_kind.get("default")
+    if not role:
+        raise RouteUnresolved(
+            f"No sanctioning authority is configured for {kind} {category}.")
+    return role
+
+
+def unit_head_role(h: dict, unit: str) -> str:
+    role = h["unit_heads"].get(unit or "")
+    if not role:
+        raise RouteUnresolved(
+            f"No Unit Head is configured for your unit "
+            f"({unit or 'not recorded'}). Ask the Leave Administrator to publish one.")
+    return role
+
+
+def resolve_route(*, category: str, kind: str, unit: str,
+                  applicant_roles: Iterable[str], hierarchy: dict) -> list[Step]:
+    director = hierarchy["director_role"]
+    if director in set(applicant_roles):
+        return [Step(DIRECTOR, director)]
+
+    head = Step(UNIT_HEAD, unit_head_role(hierarchy, unit))
+    if category in c.UNIT_HEAD_FINAL:
+        return [head]
+
+    steps = [head]
+    estt = hierarchy.get("establishment_role")
+    estt_cats = hierarchy.get("establishment_categories") or list(c.HIGHER_SANCTION)
+    if estt and category in estt_cats:
+        steps.append(Step(ESTABLISHMENT, estt))
+    steps.append(Step(SANCTION, sanctioning_role(hierarchy, kind, category)))
+    return steps
+
+
+def resumption_verifier(route: list[dict], hierarchy: dict) -> str:
+    configured = hierarchy.get("resumption_verifier") or UNIT_HEAD
+    if configured == UNIT_HEAD:
+        for s in route:
+            if s["step"] in (UNIT_HEAD, DIRECTOR):
+                return s["role"]
+    if configured == ESTABLISHMENT and hierarchy.get("establishment_role"):
+        return hierarchy["establishment_role"]
+    return route[0]["role"]
diff --git a/modules/elm/domain/state_machine.py b/modules/elm/domain/state_machine.py
new file mode 100644
index 00000000..3e483200
--- /dev/null
+++ b/modules/elm/domain/state_machine.py
@@ -0,0 +1,188 @@
+"""The leave request state machine (WF-EL-01..05).
+
+A declarative table, so an illegal move cannot be expressed. Branching events
+list every target they may reach; the service picks one from the route and
+`resolve` refuses anything outside that set.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from modules.elm.domain import permissions as p
+from modules.elm.domain import routing as r
+
+NEW = "new"
+AWAITING_SUBSTITUTE = "awaiting_substitute"
+SUBSTITUTE_DECLINED = "substitute_declined"
+AWAITING_UNIT_HEAD = "awaiting_unit_head"
+AWAITING_ESTABLISHMENT = "awaiting_establishment"
+AWAITING_SANCTION = "awaiting_sanction"
+AWAITING_DIRECTOR = "awaiting_director"
+APPROVED = "approved"
+REJECTED = "rejected"
+WITHDRAWN = "withdrawn"
+CANCELLATION_PENDING = "cancellation_pending"
+CANCELLED = "cancelled"
+RESUMPTION_PENDING = "resumption_pending"
+CLOSED = "closed"
+
+STATES = (AWAITING_SUBSTITUTE, SUBSTITUTE_DECLINED, AWAITING_UNIT_HEAD,
+          AWAITING_ESTABLISHMENT, AWAITING_SANCTION, AWAITING_DIRECTOR,
+          APPROVED, REJECTED, WITHDRAWN, CANCELLATION_PENDING, CANCELLED,
+          RESUMPTION_PENDING, CLOSED)
+
+PENDING = frozenset({AWAITING_SUBSTITUTE, SUBSTITUTE_DECLINED, AWAITING_UNIT_HEAD,
+                     AWAITING_ESTABLISHMENT, AWAITING_SANCTION, AWAITING_DIRECTOR})
+
+#: Leave that occupies dates for BR-EL-012 and BR-EL-014.
+ACTIVE = PENDING | {APPROVED, CANCELLATION_PENDING, RESUMPTION_PENDING, CLOSED}
+TERMINAL = frozenset({REJECTED, WITHDRAWN, CANCELLED, CLOSED})
+
+STATE_FOR_STEP = {
+    r.UNIT_HEAD: AWAITING_UNIT_HEAD,
+    r.ESTABLISHMENT: AWAITING_ESTABLISHMENT,
+    r.SANCTION: AWAITING_SANCTION,
+    r.DIRECTOR: AWAITING_DIRECTOR,
+}
+ROUTING_ENTRY = frozenset({AWAITING_UNIT_HEAD, AWAITING_DIRECTOR})
+
+EMPLOYEE = "employee"
+SUBSTITUTE = "substitute"
+UNIT_HEAD = "unit_head"
+ESTABLISHMENT = "establishment"
+SANCTIONER = "sanctioner"
+DIRECTOR = "director"
+VERIFIER = "verifier"
+ADMIN = "admin"
+
+SUBMIT = "submit"
+SUBSTITUTE_ACCEPT = "substitute_accept"
+SUBSTITUTE_DECLINE = "substitute_decline"
+RENOMINATE = "renominate"
+MODIFY = "modify"
+WITHDRAW = "withdraw"
+APPROVE = "approve"
+REJECT = "reject"
+RECOMMEND = "recommend"
+NOT_RECOMMEND = "not_recommend"
+FORWARD = "forward"
+REQUEST_CANCELLATION = "request_cancellation"
+CANCEL_ADVANCE = "cancel_advance"
+CANCEL_APPROVE = "cancel_approve"
+CANCEL_REJECT = "cancel_reject"
+SUBMIT_RESUMPTION = "submit_resumption"
+VERIFY_RESUMPTION = "verify_resumption"
+RECORD_OFFLINE = "record_offline"
+
+
+class InvalidTransition(Exception):
+    def __init__(self, frm: str, event: str, to: str | None = None):
+        super().__init__(f"A request in {frm!r} cannot take {event!r}"
+                         + (f" to {to!r}." if to else "."))
+        self.frm, self.event, self.to = frm, event, to
+
+
+class ActorNotAllowed(Exception):
+    def __init__(self, actor: str, frm: str, event: str):
+        super().__init__(f"A {actor} may not {event} a request in {frm!r}.")
+        self.actor, self.frm, self.event = actor, frm, event
+
+
+@dataclass(frozen=True)
+class Transition:
+    frm: str
+    event: str
+    targets: frozenset[str]
+    actor: str
+    permission: str
+
+
+def _t(frm, event, targets, actor, permission):
+    return Transition(frm, event, frozenset(targets), actor, permission)
+
+
+_ENTRY = (AWAITING_SUBSTITUTE, AWAITING_UNIT_HEAD, AWAITING_DIRECTOR)
+_PENDING_ORDERED = (AWAITING_SUBSTITUTE, SUBSTITUTE_DECLINED, AWAITING_UNIT_HEAD,
+                    AWAITING_ESTABLISHMENT, AWAITING_SANCTION, AWAITING_DIRECTOR)
+
+TRANSITIONS: tuple[Transition, ...] = (
+    _t(NEW, SUBMIT, _ENTRY, EMPLOYEE, p.P_CREATE),
+    _t(NEW, RECORD_OFFLINE, (APPROVED,), ADMIN, p.P_OFFLINE),
+
+    _t(AWAITING_SUBSTITUTE, SUBSTITUTE_ACCEPT, (AWAITING_UNIT_HEAD, AWAITING_DIRECTOR),
+       SUBSTITUTE, p.P_SUBSTITUTE),
+    _t(AWAITING_SUBSTITUTE, SUBSTITUTE_DECLINE, (SUBSTITUTE_DECLINED,),
+       SUBSTITUTE, p.P_SUBSTITUTE),
+    _t(SUBSTITUTE_DECLINED, RENOMINATE, (AWAITING_SUBSTITUTE,), EMPLOYEE, p.P_UPDATE),
+
+    *(_t(s, MODIFY, _ENTRY, EMPLOYEE, p.P_UPDATE) for s in _PENDING_ORDERED),
+    *(_t(s, WITHDRAW, (WITHDRAWN,), EMPLOYEE, p.P_WITHDRAW) for s in _PENDING_ORDERED),
+
+    _t(AWAITING_UNIT_HEAD, APPROVE, (APPROVED,), UNIT_HEAD, p.P_APPROVE),
+    _t(AWAITING_UNIT_HEAD, REJECT, (REJECTED,), UNIT_HEAD, p.P_APPROVE),
+    _t(AWAITING_UNIT_HEAD, RECOMMEND, (AWAITING_ESTABLISHMENT, AWAITING_SANCTION),
+       UNIT_HEAD, p.P_REVIEW),
+    _t(AWAITING_UNIT_HEAD, NOT_RECOMMEND, (AWAITING_ESTABLISHMENT, AWAITING_SANCTION),
+       UNIT_HEAD, p.P_REVIEW),
+
+    _t(AWAITING_ESTABLISHMENT, FORWARD, (AWAITING_SANCTION,), ESTABLISHMENT, p.P_REVIEW),
+
+    _t(AWAITING_SANCTION, APPROVE, (APPROVED,), SANCTIONER, p.P_APPROVE),
+    _t(AWAITING_SANCTION, REJECT, (REJECTED,), SANCTIONER, p.P_APPROVE),
+
+    _t(AWAITING_DIRECTOR, APPROVE, (APPROVED,), DIRECTOR, p.P_APPROVE),
+    _t(AWAITING_DIRECTOR, REJECT, (REJECTED,), DIRECTOR, p.P_APPROVE),
+
+    _t(APPROVED, REQUEST_CANCELLATION, (CANCELLATION_PENDING,), EMPLOYEE, p.P_UPDATE),
+    *(_t(CANCELLATION_PENDING, CANCEL_ADVANCE, (CANCELLATION_PENDING,), a, p.P_REVIEW)
+      for a in (UNIT_HEAD, ESTABLISHMENT)),
+    *(_t(CANCELLATION_PENDING, CANCEL_APPROVE, (CANCELLED,), a, p.P_APPROVE)
+      for a in (UNIT_HEAD, SANCTIONER, DIRECTOR)),
+    *(_t(CANCELLATION_PENDING, CANCEL_REJECT, (APPROVED,), a, p.P_APPROVE)
+      for a in (UNIT_HEAD, SANCTIONER, DIRECTOR)),
+
+    _t(APPROVED, SUBMIT_RESUMPTION, (RESUMPTION_PENDING,), EMPLOYEE, p.P_UPDATE),
+    _t(RESUMPTION_PENDING, VERIFY_RESUMPTION, (CLOSED,), VERIFIER, p.P_RESUMPTION),
+)
+
+_INDEX: dict[tuple[str, str, str], Transition] = {
+    (t.frm, t.event, t.actor): t for t in TRANSITIONS}
+
+
+def resolve(frm: str, event: str, actor: str, to: str) -> Transition:
+    t = _INDEX.get((frm, event, actor))
+    if t is None:
+        if any(k[0] == frm and k[1] == event for k in _INDEX):
+            raise ActorNotAllowed(actor, frm, event)
+        raise InvalidTransition(frm, event)
+    if to not in t.targets:
+        raise InvalidTransition(frm, event, to)
+    return t
+
+
+def events_from(frm: str, actor: str | None = None) -> list[str]:
+    return sorted({t.event for t in TRANSITIONS
+                   if t.frm == frm and (actor is None or t.actor == actor)})
+
+
+#: Which decisions each routed step may record, per category family.
+def decision_events(step: str, unit_head_final: bool, cancelling: bool) -> tuple[str, ...]:
+    if cancelling:
+        if step == r.UNIT_HEAD and not unit_head_final:
+            return (CANCEL_ADVANCE,)
+        if step == r.ESTABLISHMENT:
+            return (CANCEL_ADVANCE,)
+        return (CANCEL_APPROVE, CANCEL_REJECT)
+    if step == r.UNIT_HEAD:
+        return (APPROVE, REJECT) if unit_head_final else (RECOMMEND, NOT_RECOMMEND)
+    if step == r.ESTABLISHMENT:
+        return (FORWARD,)
+    return (APPROVE, REJECT)
+
+
+ACTOR_FOR_STEP = {
+    r.UNIT_HEAD: UNIT_HEAD,
+    r.ESTABLISHMENT: ESTABLISHMENT,
+    r.SANCTION: SANCTIONER,
+    r.DIRECTOR: DIRECTOR,
+}
diff --git a/modules/elm/domain/year_end.py b/modules/elm/domain/year_end.py
new file mode 100644
index 00000000..d550255e
--- /dev/null
+++ b/modules/elm/domain/year_end.py
@@ -0,0 +1,10 @@
+"""Year-end arithmetic (BR-EL-002..009)."""
+from __future__ import annotations
+
+from decimal import Decimal
+
+
+def vl_to_el(unused_vl: Decimal, ratio: Decimal) -> Decimal:
+    if unused_vl <= 0:
+        return Decimal("0")
+    return (unused_vl / ratio).quantize(Decimal("0.01"))
diff --git a/modules/elm/management/__init__.py b/modules/elm/management/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/management/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/management/commands/__init__.py b/modules/elm/management/commands/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/management/commands/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/management/commands/elm_readiness.py b/modules/elm/management/commands/elm_readiness.py
new file mode 100644
index 00000000..bc120655
--- /dev/null
+++ b/modules/elm/management/commands/elm_readiness.py
@@ -0,0 +1,19 @@
+"""Name every unmet ELM prerequisite, or say it is ready."""
+from django.core.management.base import BaseCommand, CommandError
+
+from modules.elm.registry import readiness
+from modules.elm.selectors.config import effective_calendar_version
+
+
+class Command(BaseCommand):
+    help = "Check that ELM can take its first leave application"
+
+    def handle(self, *args, **opts):
+        unmet = readiness()
+        if effective_calendar_version() is None:
+            self.stdout.write(self.style.WARNING(
+                "  no published holiday/RH calendar: RH and VL requests will be refused "
+                "until the Leave Administrator publishes one"))
+        if unmet:
+            raise CommandError("ELM is not ready:\n" + "\n".join(f"  - {u}" for u in unmet))
+        self.stdout.write(self.style.SUCCESS("ELM is ready"))
diff --git a/modules/elm/management/commands/run_elm_sla.py b/modules/elm/management/commands/run_elm_sla.py
new file mode 100644
index 00000000..5d82b2df
--- /dev/null
+++ b/modules/elm/management/commands/run_elm_sla.py
@@ -0,0 +1,11 @@
+"""Run one SLA reminder/escalation pass by hand (SF-EL-002)."""
+from django.core.management.base import BaseCommand
+
+from modules.elm.services import sla
+
+
+class Command(BaseCommand):
+    help = "Send due SLA reminders and escalations for pending ELM tasks"
+
+    def handle(self, *args, **opts):
+        self.stdout.write(str(sla.process()))
diff --git a/modules/elm/management/commands/run_elm_year_end.py b/modules/elm/management/commands/run_elm_year_end.py
new file mode 100644
index 00000000..d30077ef
--- /dev/null
+++ b/modules/elm/management/commands/run_elm_year_end.py
@@ -0,0 +1,21 @@
+"""Run year-end leave processing once by hand (SF-EL-001)."""
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+from modules.elm.services import year_end
+
+
+class Command(BaseCommand):
+    help = "Lapse, convert and carry forward leave balances for a closing year"
+
+    def add_arguments(self, parser):
+        parser.add_argument("--year", type=int, default=None,
+                            help="the year being closed; defaults to last year")
+
+    def handle(self, *args, **opts):
+        year = opts["year"] or timezone.localdate().year - 1
+        run = year_end.run(year)
+        self.stdout.write(f"year {run.year}: {run.employees} employee(s), "
+                          f"{len(run.exceptions)} exception(s)")
+        for e in run.exceptions:
+            self.stdout.write(self.style.WARNING(f"  {e}"))
diff --git a/modules/elm/management/commands/seed_elm_policy.py b/modules/elm/management/commands/seed_elm_policy.py
new file mode 100644
index 00000000..3b4040d9
--- /dev/null
+++ b/modules/elm/management/commands/seed_elm_policy.py
@@ -0,0 +1,34 @@
+"""Publish the canonical ELM policy and hierarchy if none is published. Idempotent."""
+from datetime import date
+
+from django.core.management.base import BaseCommand
+from django.db import transaction
+from django.utils import timezone
+
+from modules.elm.domain.policy import DEFAULT_PARAMS
+from modules.elm.models import PolicyVersion
+from modules.elm.models.config import PUBLISHED
+from modules.elm.registry import DEFAULT_HIERARCHY
+from modules.elm.services.config import validate_policy
+
+
+class Command(BaseCommand):
+    help = "Seed and publish the default ELM leave policy and hierarchy"
+
+    def add_arguments(self, parser):
+        parser.add_argument("--effective-from", default=None,
+                            help="ISO date; defaults to 1 January of this year")
+
+    @transaction.atomic
+    def handle(self, *args, **opts):
+        if PolicyVersion.objects.filter(status=PUBLISHED).exists():
+            self.stdout.write("a published ELM policy already exists; nothing to do")
+            return
+        eff = (date.fromisoformat(opts["effective_from"]) if opts["effective_from"]
+               else date(timezone.localdate().year, 1, 1))
+        validate_policy(DEFAULT_PARAMS, DEFAULT_HIERARCHY)
+        pv = PolicyVersion.objects.create(
+            name="Canonical ELM policy", params=DEFAULT_PARAMS,
+            hierarchy=DEFAULT_HIERARCHY, effective_from=eff, status=PUBLISHED,
+            published_at=timezone.now())
+        self.stdout.write(self.style.SUCCESS(f"published policy #{pv.pk} from {eff}"))
diff --git a/modules/elm/migrations/0001_initial.py b/modules/elm/migrations/0001_initial.py
new file mode 100644
index 00000000..50ef88fc
--- /dev/null
+++ b/modules/elm/migrations/0001_initial.py
@@ -0,0 +1,243 @@
+# Generated by Django 5.2.17 on 2026-10-11 18:16
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='YearEndRun',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('year', models.PositiveSmallIntegerField(unique=True)),
+                ('started_at', models.DateTimeField(auto_now_add=True)),
+                ('finished_at', models.DateTimeField(blank=True, null=True)),
+                ('employees', models.PositiveIntegerField(default=0)),
+                ('exceptions', models.JSONField(default=list)),
+            ],
+            options={
+                'db_table': 'elm_year_end_run',
+            },
+        ),
+        migrations.CreateModel(
+            name='CalendarVersion',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('name', models.CharField(max_length=120)),
+                ('effective_from', models.DateField()),
+                ('status', models.CharField(choices=[('draft', 'Draft'), ('published', 'Published')], default='draft', max_length=12)),
+                ('published_at', models.DateTimeField(blank=True, null=True)),
+                ('created_by_user_id', models.IntegerField(blank=True, null=True)),
+            ],
+            options={
+                'db_table': 'elm_calendar_version',
+                'indexes': [models.Index(fields=['status', 'effective_from'], name='elm_calendar_eff_idx')],
+            },
+        ),
+        migrations.CreateModel(
+            name='LeaveRequest',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('user_id', models.IntegerField(db_index=True)),
+                ('kind', models.CharField(choices=[('leave', 'Leave'), ('extension', 'Extension'), ('offline', 'Offline record')], default='leave', max_length=12)),
+                ('category', models.CharField(choices=[('CL', 'Casual Leave'), ('RH', 'Restricted Holiday'), ('SCL', 'Special Casual Leave'), ('EL', 'Earned Leave'), ('COL', 'Commuted Leave'), ('VL', 'Vacation Leave')], max_length=4)),
+                ('applicant_kind', models.CharField(max_length=12)),
+                ('applicant_unit', models.CharField(blank=True, max_length=80)),
+                ('start_date', models.DateField()),
+                ('end_date', models.DateField()),
+                ('half', models.CharField(blank=True, choices=[('first', 'first'), ('second', 'second')], max_length=6)),
+                ('days', models.DecimalField(decimal_places=2, max_digits=6)),
+                ('purpose', models.TextField()),
+                ('medical_evidence', models.CharField(blank=True, max_length=500)),
+                ('station_leave', models.BooleanField(default=False)),
+                ('station_from', models.DateField(blank=True, null=True)),
+                ('station_to', models.DateField(blank=True, null=True)),
+                ('station_address', models.CharField(blank=True, max_length=300)),
+                ('substitute_user_id', models.IntegerField(blank=True, db_index=True, null=True)),
+                ('substitute_status', models.CharField(blank=True, max_length=12)),
+                ('responsibility', models.CharField(blank=True, max_length=300)),
+                ('status', models.CharField(choices=[('awaiting_substitute', 'awaiting substitute'), ('substitute_declined', 'substitute declined'), ('awaiting_unit_head', 'awaiting unit head'), ('awaiting_establishment', 'awaiting establishment'), ('awaiting_sanction', 'awaiting sanction'), ('awaiting_director', 'awaiting director'), ('approved', 'approved'), ('rejected', 'rejected'), ('withdrawn', 'withdrawn'), ('cancellation_pending', 'cancellation pending'), ('cancelled', 'cancelled'), ('resumption_pending', 'resumption pending'), ('closed', 'closed')], db_index=True, max_length=24)),
+                ('route', models.JSONField(default=list)),
+                ('stage', models.PositiveSmallIntegerField(default=0)),
+                ('current_role', models.CharField(blank=True, db_index=True, max_length=100)),
+                ('stage_entered_at', models.DateTimeField(blank=True, null=True)),
+                ('recommendation', models.CharField(blank=True, max_length=20)),
+                ('decision_note', models.CharField(blank=True, max_length=500)),
+                ('decided_at', models.DateTimeField(blank=True, null=True)),
+                ('actual_return_date', models.DateField(blank=True, null=True)),
+                ('resumption_note', models.CharField(blank=True, max_length=500)),
+                ('policy_version_id', models.IntegerField(blank=True, null=True)),
+                ('parent', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='extensions', to='elm.leaverequest')),
+            ],
+            options={
+                'db_table': 'elm_leave_request',
+            },
+        ),
+        migrations.CreateModel(
+            name='LeaveTransition',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('from_status', models.CharField(max_length=24)),
+                ('to_status', models.CharField(max_length=24)),
+                ('event', models.CharField(max_length=32)),
+                ('actor_user_id', models.IntegerField(blank=True, null=True)),
+                ('actor_role', models.CharField(blank=True, max_length=100)),
+                ('note', models.CharField(blank=True, max_length=500)),
+                ('at', models.DateTimeField(auto_now_add=True)),
+                ('request', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='transitions', to='elm.leaverequest')),
+            ],
+            options={
+                'db_table': 'elm_leave_transition',
+            },
+        ),
+        migrations.CreateModel(
+            name='LedgerEntry',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('user_id', models.IntegerField(db_index=True)),
+                ('category', models.CharField(max_length=4)),
+                ('entry_type', models.CharField(choices=[('annual_credit', 'annual credit'), ('debit', 'debit'), ('reversal', 'reversal'), ('restore', 'restore'), ('lapse', 'lapse'), ('conversion_out', 'conversion out'), ('conversion_in', 'conversion in'), ('carry_forward', 'carry forward'), ('offline_debit', 'offline debit')], max_length=16)),
+                ('delta', models.DecimalField(decimal_places=2, max_digits=7)),
+                ('year', models.PositiveSmallIntegerField()),
+                ('note', models.CharField(blank=True, max_length=300)),
+                ('at', models.DateTimeField(auto_now_add=True)),
+                ('request', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='ledger', to='elm.leaverequest')),
+            ],
+            options={
+                'db_table': 'elm_ledger_entry',
+            },
+        ),
+        migrations.CreateModel(
+            name='Notification',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('recipient_user_id', models.IntegerField(blank=True, db_index=True, null=True)),
+                ('recipient_role', models.CharField(blank=True, db_index=True, max_length=100)),
+                ('message', models.CharField(max_length=400)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('read_at', models.DateTimeField(blank=True, null=True)),
+                ('request', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='notifications', to='elm.leaverequest')),
+            ],
+            options={
+                'db_table': 'elm_notification',
+            },
+        ),
+        migrations.CreateModel(
+            name='OfflineLeaveRecord',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('sanction_reference', models.CharField(max_length=120)),
+                ('sanctioned_by', models.CharField(max_length=120)),
+                ('sanctioned_on', models.DateField()),
+                ('evidence_note', models.CharField(blank=True, max_length=500)),
+                ('recorded_by_user_id', models.IntegerField()),
+                ('request', models.OneToOneField(on_delete=django.db.models.deletion.PROTECT, related_name='offline_record', to='elm.leaverequest')),
+            ],
+            options={
+                'db_table': 'elm_offline_record',
+            },
+        ),
+        migrations.CreateModel(
+            name='PolicyVersion',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('name', models.CharField(max_length=120)),
+                ('params', models.JSONField(default=dict)),
+                ('hierarchy', models.JSONField(default=dict)),
+                ('effective_from', models.DateField()),
+                ('status', models.CharField(choices=[('draft', 'Draft'), ('published', 'Published')], default='draft', max_length=12)),
+                ('published_at', models.DateTimeField(blank=True, null=True)),
+                ('created_by_user_id', models.IntegerField(blank=True, null=True)),
+            ],
+            options={
+                'db_table': 'elm_policy_version',
+                'indexes': [models.Index(fields=['status', 'effective_from'], name='elm_policy_eff_idx')],
+            },
+        ),
+        migrations.CreateModel(
+            name='SlaAction',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('status', models.CharField(max_length=24)),
+                ('stage', models.PositiveSmallIntegerField()),
+                ('stage_entered_at', models.DateTimeField()),
+                ('action', models.CharField(max_length=12)),
+                ('target_role', models.CharField(max_length=100)),
+                ('at', models.DateTimeField(auto_now_add=True)),
+                ('request', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='sla_actions', to='elm.leaverequest')),
+            ],
+            options={
+                'db_table': 'elm_sla_action',
+            },
+        ),
+        migrations.CreateModel(
+            name='CalendarEntry',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('kind', models.CharField(choices=[('closed_holiday', 'Closed holiday'), ('restricted_holiday', 'Restricted holiday'), ('vacation', 'Vacation period')], max_length=20)),
+                ('name', models.CharField(max_length=120)),
+                ('start_date', models.DateField()),
+                ('end_date', models.DateField()),
+                ('version', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='entries', to='elm.calendarversion')),
+            ],
+            options={
+                'db_table': 'elm_calendar_entry',
+                'constraints': [models.CheckConstraint(condition=models.Q(('end_date__gte', models.F('start_date'))), name='elm_calendar_entry_order')],
+            },
+        ),
+        migrations.AddIndex(
+            model_name='leaverequest',
+            index=models.Index(fields=['user_id', 'status'], name='elm_request_user_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='leaverequest',
+            index=models.Index(fields=['current_role', 'status'], name='elm_request_queue_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='leaverequest',
+            constraint=models.CheckConstraint(condition=models.Q(('end_date__gte', models.F('start_date'))), name='elm_request_period_order'),
+        ),
+        migrations.AddConstraint(
+            model_name='leaverequest',
+            constraint=models.CheckConstraint(condition=models.Q(('days__gt', 0)), name='elm_request_days_positive'),
+        ),
+        migrations.AddIndex(
+            model_name='leavetransition',
+            index=models.Index(fields=['request', 'at'], name='elm_transition_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='ledgerentry',
+            index=models.Index(fields=['user_id', 'category'], name='elm_ledger_user_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='ledgerentry',
+            constraint=models.UniqueConstraint(condition=models.Q(('entry_type__in', ['annual_credit', 'lapse', 'conversion_out', 'conversion_in', 'carry_forward'])), fields=('user_id', 'category', 'year', 'entry_type'), name='elm_ledger_once_per_year'),
+        ),
+        migrations.AddConstraint(
+            model_name='ledgerentry',
+            constraint=models.UniqueConstraint(condition=models.Q(('request__isnull', False)), fields=('request', 'entry_type'), name='elm_ledger_once_per_request'),
+        ),
+        migrations.AddConstraint(
+            model_name='notification',
+            constraint=models.CheckConstraint(condition=models.Q(('recipient_user_id__isnull', False), models.Q(('recipient_role', ''), _negated=True), _connector='OR'), name='elm_notification_has_recipient'),
+        ),
+        migrations.AddConstraint(
+            model_name='slaaction',
+            constraint=models.UniqueConstraint(fields=('request', 'status', 'stage', 'stage_entered_at', 'action'), name='elm_sla_once_per_stage'),
+        ),
+    ]
diff --git a/modules/elm/migrations/__init__.py b/modules/elm/migrations/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/migrations/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/models/__init__.py b/modules/elm/models/__init__.py
new file mode 100644
index 00000000..399c722b
--- /dev/null
+++ b/modules/elm/models/__init__.py
@@ -0,0 +1,18 @@
+"""ELM tables, split by aggregate."""
+from modules.elm.models.config import CalendarEntry, CalendarVersion, PolicyVersion
+from modules.elm.models.ledger import LedgerEntry, YearEndRun
+from modules.elm.models.records import Notification, OfflineLeaveRecord, SlaAction
+from modules.elm.models.requests import LeaveRequest, LeaveTransition
+
+__all__ = [
+    "CalendarEntry",
+    "CalendarVersion",
+    "LeaveRequest",
+    "LeaveTransition",
+    "LedgerEntry",
+    "Notification",
+    "OfflineLeaveRecord",
+    "PolicyVersion",
+    "SlaAction",
+    "YearEndRun",
+]
diff --git a/modules/elm/models/config.py b/modules/elm/models/config.py
new file mode 100644
index 00000000..d97dfe0b
--- /dev/null
+++ b/modules/elm/models/config.py
@@ -0,0 +1,68 @@
+"""Effective-dated configuration (BR-EL-030, BR-EL-031). Published rows are never edited."""
+from django.db import models
+
+from core.db.mixins import TimeStampedModel
+
+DRAFT = "draft"
+PUBLISHED = "published"
+STATUS = [(DRAFT, "Draft"), (PUBLISHED, "Published")]
+
+
+class PolicyVersion(TimeStampedModel):
+    name = models.CharField(max_length=120)
+    params = models.JSONField(default=dict)
+    hierarchy = models.JSONField(default=dict)
+    effective_from = models.DateField()
+    status = models.CharField(max_length=12, choices=STATUS, default=DRAFT)
+    published_at = models.DateTimeField(null=True, blank=True)
+    created_by_user_id = models.IntegerField(null=True, blank=True)
+
+    class Meta:
+        db_table = "elm_policy_version"
+        indexes = [models.Index(fields=["status", "effective_from"],
+                                name="elm_policy_eff_idx")]
+
+    def __str__(self) -> str:
+        return f"policy#{self.pk} {self.status} {self.effective_from}"
+
+
+class CalendarVersion(TimeStampedModel):
+    name = models.CharField(max_length=120)
+    effective_from = models.DateField()
+    status = models.CharField(max_length=12, choices=STATUS, default=DRAFT)
+    published_at = models.DateTimeField(null=True, blank=True)
+    created_by_user_id = models.IntegerField(null=True, blank=True)
+
+    class Meta:
+        db_table = "elm_calendar_version"
+        indexes = [models.Index(fields=["status", "effective_from"],
+                                name="elm_calendar_eff_idx")]
+
+    def __str__(self) -> str:
+        return f"calendar#{self.pk} {self.status} {self.effective_from}"
+
+
+class CalendarEntry(models.Model):
+    CLOSED_HOLIDAY = "closed_holiday"
+    RESTRICTED_HOLIDAY = "restricted_holiday"
+    VACATION = "vacation"
+    KINDS = [(CLOSED_HOLIDAY, "Closed holiday"),
+             (RESTRICTED_HOLIDAY, "Restricted holiday"),
+             (VACATION, "Vacation period")]
+
+    version = models.ForeignKey(CalendarVersion, on_delete=models.CASCADE,
+                                related_name="entries")
+    kind = models.CharField(max_length=20, choices=KINDS)
+    name = models.CharField(max_length=120)
+    start_date = models.DateField()
+    end_date = models.DateField()
+
+    class Meta:
+        db_table = "elm_calendar_entry"
+        constraints = [
+            models.CheckConstraint(condition=models.Q(end_date__gte=models.F("start_date")),
+                                   name="elm_calendar_entry_order"),
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.kind} {self.start_date}..{self.end_date}"
diff --git a/modules/elm/models/ledger.py b/modules/elm/models/ledger.py
new file mode 100644
index 00000000..aee60bb8
--- /dev/null
+++ b/modules/elm/models/ledger.py
@@ -0,0 +1,61 @@
+"""The leave account: an append-only ledger, never a balance column."""
+from django.db import models
+
+from core.db.mixins import UserScopedModel
+
+
+class LedgerEntry(UserScopedModel):
+    ANNUAL_CREDIT = "annual_credit"
+    DEBIT = "debit"
+    REVERSAL = "reversal"
+    RESTORE = "restore"
+    LAPSE = "lapse"
+    CONVERSION_OUT = "conversion_out"
+    CONVERSION_IN = "conversion_in"
+    CARRY_FORWARD = "carry_forward"
+    OFFLINE_DEBIT = "offline_debit"
+    TYPES = [(t, t.replace("_", " ")) for t in (
+        ANNUAL_CREDIT, DEBIT, REVERSAL, RESTORE, LAPSE, CONVERSION_OUT,
+        CONVERSION_IN, CARRY_FORWARD, OFFLINE_DEBIT)]
+
+    category = models.CharField(max_length=4)
+    entry_type = models.CharField(max_length=16, choices=TYPES)
+    delta = models.DecimalField(max_digits=7, decimal_places=2)
+    year = models.PositiveSmallIntegerField()
+    request = models.ForeignKey("LeaveRequest", null=True, blank=True,
+                                on_delete=models.PROTECT, related_name="ledger")
+    note = models.CharField(max_length=300, blank=True)
+    at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        db_table = "elm_ledger_entry"
+        constraints = [
+            models.UniqueConstraint(
+                fields=["user_id", "category", "year", "entry_type"],
+                condition=models.Q(entry_type__in=[
+                    "annual_credit", "lapse", "conversion_out", "conversion_in",
+                    "carry_forward"]),
+                name="elm_ledger_once_per_year"),
+            models.UniqueConstraint(
+                fields=["request", "entry_type"],
+                condition=models.Q(request__isnull=False),
+                name="elm_ledger_once_per_request"),
+        ]
+        indexes = [models.Index(fields=["user_id", "category"], name="elm_ledger_user_idx")]
+
+    def __str__(self) -> str:
+        return f"u{self.user_id} {self.category} {self.entry_type} {self.delta}"
+
+
+class YearEndRun(models.Model):
+    year = models.PositiveSmallIntegerField(unique=True)
+    started_at = models.DateTimeField(auto_now_add=True)
+    finished_at = models.DateTimeField(null=True, blank=True)
+    employees = models.PositiveIntegerField(default=0)
+    exceptions = models.JSONField(default=list)
+
+    class Meta:
+        db_table = "elm_year_end_run"
+
+    def __str__(self) -> str:
+        return f"year-end {self.year}"
diff --git a/modules/elm/models/records.py b/modules/elm/models/records.py
new file mode 100644
index 00000000..a43035dd
--- /dev/null
+++ b/modules/elm/models/records.py
@@ -0,0 +1,71 @@
+"""Offline sanctions, notifications and SLA log."""
+from django.db import models
+
+from core.db.mixins import TimeStampedModel
+
+
+class OfflineLeaveRecord(TimeStampedModel):
+    """BR-EL-029: evidence of a sanction already made on paper."""
+
+    request = models.OneToOneField("LeaveRequest", on_delete=models.PROTECT,
+                                   related_name="offline_record")
+    sanction_reference = models.CharField(max_length=120)
+    sanctioned_by = models.CharField(max_length=120)
+    sanctioned_on = models.DateField()
+    evidence_note = models.CharField(max_length=500, blank=True)
+    recorded_by_user_id = models.IntegerField()
+
+    class Meta:
+        db_table = "elm_offline_record"
+
+    def __str__(self) -> str:
+        return f"offline {self.sanction_reference}"
+
+
+class Notification(models.Model):
+    """In-app notice to one person or to whoever acts as a designation."""
+
+    recipient_user_id = models.IntegerField(null=True, blank=True, db_index=True)
+    recipient_role = models.CharField(max_length=100, blank=True, db_index=True)
+    request = models.ForeignKey("LeaveRequest", null=True, blank=True,
+                                on_delete=models.CASCADE, related_name="notifications")
+    message = models.CharField(max_length=400)
+    created_at = models.DateTimeField(auto_now_add=True)
+    read_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        db_table = "elm_notification"
+        constraints = [
+            models.CheckConstraint(
+                condition=models.Q(recipient_user_id__isnull=False)
+                | ~models.Q(recipient_role=""),
+                name="elm_notification_has_recipient"),
+        ]
+
+    def __str__(self) -> str:
+        return self.message[:40]
+
+
+class SlaAction(models.Model):
+    REMINDER = "reminder"
+    ESCALATION = "escalation"
+
+    request = models.ForeignKey("LeaveRequest", on_delete=models.CASCADE,
+                                related_name="sla_actions")
+    status = models.CharField(max_length=24)
+    stage = models.PositiveSmallIntegerField()
+    stage_entered_at = models.DateTimeField()
+    action = models.CharField(max_length=12)
+    target_role = models.CharField(max_length=100)
+    at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        db_table = "elm_sla_action"
+        constraints = [
+            models.UniqueConstraint(
+                fields=["request", "status", "stage", "stage_entered_at", "action"],
+                name="elm_sla_once_per_stage"),
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.action} leave#{self.request_id}"
diff --git a/modules/elm/models/requests.py b/modules/elm/models/requests.py
new file mode 100644
index 00000000..044c4a8f
--- /dev/null
+++ b/modules/elm/models/requests.py
@@ -0,0 +1,91 @@
+"""Leave requests and their transition audit log."""
+from __future__ import annotations
+
+from django.db import models
+
+from core.db.mixins import TimeStampedModel, UserScopedModel
+from modules.elm.domain import categories as c
+from modules.elm.domain import state_machine as sm
+
+
+class LeaveRequest(TimeStampedModel, UserScopedModel):
+    LEAVE = "leave"
+    EXTENSION = "extension"
+    OFFLINE = "offline"
+    KINDS = [(LEAVE, "Leave"), (EXTENSION, "Extension"), (OFFLINE, "Offline record")]
+
+    CATEGORIES = [(k, v) for k, v in c.LABELS.items()]
+    HALVES = [(h, h) for h in c.HALVES]
+    STATUSES = [(s, s.replace("_", " ")) for s in sm.STATES]
+
+    kind = models.CharField(max_length=12, choices=KINDS, default=LEAVE)
+    parent = models.ForeignKey("self", null=True, blank=True,
+                               on_delete=models.PROTECT, related_name="extensions")
+    category = models.CharField(max_length=4, choices=CATEGORIES)
+    applicant_kind = models.CharField(max_length=12)
+    applicant_unit = models.CharField(max_length=80, blank=True)
+    start_date = models.DateField()
+    end_date = models.DateField()
+    half = models.CharField(max_length=6, choices=HALVES, blank=True)
+    days = models.DecimalField(max_digits=6, decimal_places=2)
+    purpose = models.TextField()
+    medical_evidence = models.CharField(max_length=500, blank=True)
+    station_leave = models.BooleanField(default=False)
+    station_from = models.DateField(null=True, blank=True)
+    station_to = models.DateField(null=True, blank=True)
+    station_address = models.CharField(max_length=300, blank=True)
+    substitute_user_id = models.IntegerField(null=True, blank=True, db_index=True)
+    substitute_status = models.CharField(max_length=12, blank=True)
+    responsibility = models.CharField(max_length=300, blank=True)
+    status = models.CharField(max_length=24, choices=STATUSES, db_index=True)
+    route = models.JSONField(default=list)
+    stage = models.PositiveSmallIntegerField(default=0)
+    current_role = models.CharField(max_length=100, blank=True, db_index=True)
+    stage_entered_at = models.DateTimeField(null=True, blank=True)
+    recommendation = models.CharField(max_length=20, blank=True)
+    decision_note = models.CharField(max_length=500, blank=True)
+    decided_at = models.DateTimeField(null=True, blank=True)
+    actual_return_date = models.DateField(null=True, blank=True)
+    resumption_note = models.CharField(max_length=500, blank=True)
+    policy_version_id = models.IntegerField(null=True, blank=True)
+
+    class Meta:
+        db_table = "elm_leave_request"
+        indexes = [
+            models.Index(fields=["user_id", "status"], name="elm_request_user_idx"),
+            models.Index(fields=["current_role", "status"], name="elm_request_queue_idx"),
+        ]
+        constraints = [
+            models.CheckConstraint(condition=models.Q(end_date__gte=models.F("start_date")),
+                                   name="elm_request_period_order"),
+            models.CheckConstraint(condition=models.Q(days__gt=0),
+                                   name="elm_request_days_positive"),
+        ]
+
+    @property
+    def current_step(self) -> dict | None:
+        if 0 <= self.stage < len(self.route):
+            return self.route[self.stage]
+        return None
+
+    def __str__(self) -> str:
+        return f"leave#{self.pk} u{self.user_id} {self.category} {self.status}"
+
+
+class LeaveTransition(models.Model):
+    request = models.ForeignKey(LeaveRequest, on_delete=models.CASCADE,
+                                related_name="transitions")
+    from_status = models.CharField(max_length=24)
+    to_status = models.CharField(max_length=24)
+    event = models.CharField(max_length=32)
+    actor_user_id = models.IntegerField(null=True, blank=True)
+    actor_role = models.CharField(max_length=100, blank=True)
+    note = models.CharField(max_length=500, blank=True)
+    at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        db_table = "elm_leave_transition"
+        indexes = [models.Index(fields=["request", "at"], name="elm_transition_idx")]
+
+    def __str__(self) -> str:
+        return f"leave#{self.request_id} {self.from_status}->{self.to_status}"
diff --git a/modules/elm/registry.py b/modules/elm/registry.py
new file mode 100644
index 00000000..a1857b0a
--- /dev/null
+++ b/modules/elm/registry.py
@@ -0,0 +1,126 @@
+"""ELM module manifest, navigation, permissions, default hierarchy, and readiness."""
+from __future__ import annotations
+
+from modules.elm.domain import permissions as p
+
+MODULE = {
+    "code": "elm",
+    "label": "Leave",
+    "icon": "CalendarCheck",
+    "base_path": "/elm",
+    "nav_section": "Services",
+    "sort_order": 20,
+    "status": "active",
+}
+
+NAV_ITEMS = [
+    {"code": "elm.apply", "label": "Apply for Leave", "icon": "Plus",
+     "to": "/elm/apply", "required_permission": p.P_CREATE, "sort_order": 10},
+    {"code": "elm.mine", "label": "My Leave", "icon": "CalendarBlank",
+     "to": "/elm/mine", "required_permission": p.P_VIEW, "sort_order": 20},
+    {"code": "elm.balances", "label": "Balances & History", "icon": "Wallet",
+     "to": "/elm/balances", "required_permission": p.P_BALANCE, "sort_order": 30},
+    {"code": "elm.substitutions", "label": "Substitutions", "icon": "Users",
+     "to": "/elm/substitutions", "required_permission": p.P_SUBSTITUTE, "sort_order": 40},
+    {"code": "elm.queue", "label": "Leave Approvals", "icon": "Checks",
+     "to": "/elm/queue", "required_permission": p.P_REVIEW, "sort_order": 50},
+    {"code": "elm.resumptions", "label": "Resumptions", "icon": "UserCheck",
+     "to": "/elm/resumptions", "required_permission": p.P_RESUMPTION, "sort_order": 60},
+    {"code": "elm.policies", "label": "Leave Policy", "icon": "Sliders",
+     "to": "/elm/policies", "required_permission": p.P_POLICY, "sort_order": 70},
+    {"code": "elm.calendar", "label": "Holiday Calendar", "icon": "Calendar",
+     "to": "/elm/calendar", "required_permission": p.P_CALENDAR, "sort_order": 80},
+    {"code": "elm.offline", "label": "Offline Leave", "icon": "ClipboardText",
+     "to": "/elm/offline", "required_permission": p.P_OFFLINE, "sort_order": 90},
+    {"code": "elm.accounts", "label": "Leave Accounts", "icon": "IdentificationCard",
+     "to": "/elm/accounts", "required_permission": p.P_ACCOUNT_VIEW, "sort_order": 100},
+]
+
+PERMISSIONS = [
+    (p.P_VIEW, "See one's own leave requests"),
+    (p.P_CREATE, "Apply for leave or an extension"),
+    (p.P_UPDATE, "Modify, cancel or resume one's own leave"),
+    (p.P_WITHDRAW, "Withdraw one's own pending request"),
+    (p.P_SUBSTITUTE, "Accept or decline a substitute nomination"),
+    (p.P_BALANCE, "See one's own balances and leave-account history"),
+    (p.P_REVIEW, "Review, recommend or forward routed leave"),
+    (p.P_APPROVE, "Approve or reject leave as sanctioning authority"),
+    (p.P_RESUMPTION, "Verify resumption of duty"),
+    (p.P_POLICY, "Create, revise and publish leave policy and hierarchy"),
+    (p.P_CALENDAR, "Create, revise and publish the holiday/RH calendar"),
+    (p.P_OFFLINE, "Record offline-sanctioned leave"),
+    (p.P_ACCOUNT_VIEW, "See any employee's leave account"),
+]
+
+SYSTEM_PERMISSIONS: list[str] = []
+
+_EMPLOYEE = [
+    p.P_VIEW,
+    p.P_CREATE,
+    p.P_UPDATE,
+    p.P_WITHDRAW,
+    p.P_SUBSTITUTE,
+    p.P_BALANCE,
+]
+
+_UNIT_HEADS = [
+    "HOD (CSE)",
+    "HOD (ECE)",
+    "HOD (ME)",
+    "HOD (Design)",
+    "HOD (NS)",
+    "HOD (Liberal Arts)",
+    "SectionHead_PS",
+    "SectionHead_IWD",
+    "SectionHead_RSPC",
+    "SectionHead_HR",
+]
+
+_REVIEW_AND_APPROVE = [p.P_REVIEW, p.P_APPROVE, p.P_RESUMPTION]
+
+ROLE_GRANTS = {
+    "faculty": _EMPLOYEE,
+    "staff": _EMPLOYEE,
+    "Deputy Registrar": [p.P_REVIEW, p.P_RESUMPTION],
+    "Registrar": _REVIEW_AND_APPROVE,
+    "Director": _REVIEW_AND_APPROVE,
+    **{uh: _REVIEW_AND_APPROVE for uh in _UNIT_HEADS},
+    "Leave Administrator": [
+        p.P_POLICY,
+        p.P_CALENDAR,
+        p.P_OFFLINE,
+        p.P_ACCOUNT_VIEW,
+    ],
+}
+
+DEFAULT_HIERARCHY: dict = {
+    "unit_heads": {
+        "CSE": "HOD (CSE)",
+        "ECE": "HOD (ECE)",
+        "ME": "HOD (ME)",
+        "Design": "HOD (Design)",
+        "NS": "HOD (NS)",
+        "Liberal Arts": "HOD (Liberal Arts)",
+        "PS": "SectionHead_PS",
+        "IWD": "SectionHead_IWD",
+        "RSPC": "SectionHead_RSPC",
+        "HR": "SectionHead_HR",
+    },
+    "establishment_role": "Deputy Registrar",
+    "sanctioning": {
+        "faculty": {"default": "Director"},
+        "staff": {"default": "Registrar"},
+    },
+    "director_role": "Director",
+    "resumption_verifier": "unit_head",
+    "sla": {},
+}
+
+
+def readiness() -> list[str]:
+    from modules.elm.selectors.config import effective_policy_version
+
+    unmet: list[str] = []
+    if effective_policy_version() is None:
+        unmet.append("no published ELM policy version (run 'manage.py seed_elm_policy')")
+    return unmet
diff --git a/modules/elm/schedule.py b/modules/elm/schedule.py
new file mode 100644
index 00000000..93c494e7
--- /dev/null
+++ b/modules/elm/schedule.py
@@ -0,0 +1,18 @@
+"""Scheduled tasks for ELM (SF-EL-001, SF-EL-002)."""
+from celery.schedules import crontab
+
+TASK_ROUTES = {
+    "elm.year_end": {"queue": "default"},
+    "elm.sla": {"queue": "default"},
+}
+
+BEAT_SCHEDULE = {
+    "elm.year-end": {
+        "task": "elm.year_end",
+        "schedule": crontab(minute=30, hour=0, day_of_month=1, month_of_year=1),
+    },
+    "elm.sla": {
+        "task": "elm.sla",
+        "schedule": crontab(minute=0),
+    },
+}
diff --git a/modules/elm/selectors/__init__.py b/modules/elm/selectors/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/selectors/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/selectors/config.py b/modules/elm/selectors/config.py
new file mode 100644
index 00000000..1fa0e059
--- /dev/null
+++ b/modules/elm/selectors/config.py
@@ -0,0 +1,65 @@
+"""Effective published policy and calendar selectors (BR-EL-030, BR-EL-031)."""
+from __future__ import annotations
+
+from datetime import date
+
+from django.utils import timezone
+
+from modules.elm.domain.counting import Calendar
+from modules.elm.domain.policy import Policy, parse
+from modules.elm.models import CalendarEntry, CalendarVersion, PolicyVersion
+from modules.elm.models.config import PUBLISHED
+
+
+def effective_policy_version(on: date | None = None) -> PolicyVersion | None:
+    d = on or timezone.localdate()
+    return (
+        PolicyVersion.objects.filter(status=PUBLISHED, effective_from__lte=d)
+        .order_by("-effective_from", "-id")
+        .first()
+    )
+
+
+def effective_policy(on: date | None = None) -> tuple[PolicyVersion | None, Policy | None]:
+    pv = effective_policy_version(on)
+    if pv is None:
+        return None, None
+    return pv, parse(pv.params)
+
+
+def effective_calendar_version(on: date | None = None) -> CalendarVersion | None:
+    d = on or timezone.localdate()
+    return (
+        CalendarVersion.objects.filter(status=PUBLISHED, effective_from__lte=d)
+        .order_by("-effective_from", "-id")
+        .first()
+    )
+
+
+def effective_calendar(on: date | None = None) -> Calendar:
+    cv = effective_calendar_version(on)
+    if cv is None:
+        return Calendar()
+    closed = set()
+    rh = set()
+    vacations = []
+    for entry in cv.entries.all():
+        if entry.kind == CalendarEntry.CLOSED_HOLIDAY:
+            cur = entry.start_date
+            while cur <= entry.end_date:
+                closed.add(cur)
+                from datetime import timedelta
+                cur += timedelta(days=1)
+        elif entry.kind == CalendarEntry.RESTRICTED_HOLIDAY:
+            cur = entry.start_date
+            while cur <= entry.end_date:
+                rh.add(cur)
+                from datetime import timedelta
+                cur += timedelta(days=1)
+        elif entry.kind == CalendarEntry.VACATION:
+            vacations.append((entry.start_date, entry.end_date))
+    return Calendar(
+        closed_holidays=frozenset(closed),
+        restricted_holidays=frozenset(rh),
+        vacations=tuple(vacations),
+    )
diff --git a/modules/elm/services/__init__.py b/modules/elm/services/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/modules/elm/services/__init__.py
@@ -0,0 +1 @@
+
diff --git a/modules/elm/services/config.py b/modules/elm/services/config.py
new file mode 100644
index 00000000..767b0132
--- /dev/null
+++ b/modules/elm/services/config.py
@@ -0,0 +1,71 @@
+"""Policy and calendar configuration services (EL-UC-014, EL-UC-015)."""
+from __future__ import annotations
+
+from django.db import transaction
+from django.utils import timezone
+
+from core.api.exceptions import BadRequestError, ConflictError
+from modules.elm.domain.policy import PolicyInvalid, parse
+from modules.elm.domain.routing import HierarchyInvalid, parse_hierarchy
+from modules.elm.models import CalendarEntry, CalendarVersion, PolicyVersion
+from modules.elm.models.config import PUBLISHED
+
+
+def validate_policy(params: dict, hierarchy: dict) -> None:
+    try:
+        parse(params)
+        parse_hierarchy(hierarchy)
+    except (PolicyInvalid, HierarchyInvalid) as exc:
+        raise BadRequestError(str(exc), code="invalid_policy") from exc
+
+
+@transaction.atomic
+def create_policy(*, name: str, effective_from, params: dict, hierarchy: dict,
+                  actor_user_id: int | None = None) -> PolicyVersion:
+    validate_policy(params, hierarchy)
+    return PolicyVersion.objects.create(
+        name=name,
+        effective_from=effective_from,
+        params=params,
+        hierarchy=hierarchy,
+        created_by_user_id=actor_user_id,
+    )
+
+
+@transaction.atomic
+def publish_policy(pk: int) -> PolicyVersion:
+    pv = PolicyVersion.objects.select_for_update().get(pk=pk)
+    if pv.status == PUBLISHED:
+        raise ConflictError("Policy version is already published.", code="already_published")
+    validate_policy(pv.params, pv.hierarchy)
+    pv.status = PUBLISHED
+    pv.published_at = timezone.now()
+    pv.save(update_fields=["status", "published_at", "updated_at"])
+    return pv
+
+
+@transaction.atomic
+def create_calendar(*, name: str, effective_from, entries: list[dict],
+                    actor_user_id: int | None = None) -> CalendarVersion:
+    cv = CalendarVersion.objects.create(
+        name=name,
+        effective_from=effective_from,
+        created_by_user_id=actor_user_id,
+    )
+    for e in entries:
+        if e["end_date"] < e["start_date"]:
+            raise BadRequestError("Calendar entry cannot end before it starts.",
+                                  code="invalid_calendar")
+        CalendarEntry.objects.create(version=cv, **e)
+    return cv
+
+
+@transaction.atomic
+def publish_calendar(pk: int) -> CalendarVersion:
+    cv = CalendarVersion.objects.select_for_update().get(pk=pk)
+    if cv.status == PUBLISHED:
+        raise ConflictError("Calendar version is already published.", code="already_published")
+    cv.status = PUBLISHED
+    cv.published_at = timezone.now()
+    cv.save(update_fields=["status", "published_at", "updated_at"])
+    return cv
diff --git a/modules/elm/services/ledger.py b/modules/elm/services/ledger.py
new file mode 100644
index 00000000..fe30d002
--- /dev/null
+++ b/modules/elm/services/ledger.py
@@ -0,0 +1,55 @@
+"""Ledger and balance computation service."""
+from __future__ import annotations
+
+from decimal import Decimal
+
+from django.db import transaction
+from django.db.models import Sum
+from django.utils import timezone
+
+from modules.elm.domain import categories as c
+from modules.elm.domain import state_machine as sm
+from modules.elm.models import LeaveRequest, LedgerEntry
+from modules.elm.selectors.config import effective_policy
+
+
+@transaction.atomic
+def ensure_annual_credits(user_id: int, kind: str, year: int | None = None) -> None:
+    yr = year or timezone.localdate().year
+    _, policy = effective_policy()
+    if policy is None or kind not in c.EMPLOYEE_KINDS:
+        return
+    for cat in c.ALL:
+        credit = policy.annual_credit_for(kind, cat)
+        if credit > 0:
+            LedgerEntry.objects.get_or_create(
+                user_id=user_id,
+                category=cat,
+                year=yr,
+                entry_type=LedgerEntry.ANNUAL_CREDIT,
+                defaults={"delta": credit, "note": f"{yr} annual entitlement"},
+            )
+
+
+def get_account(user_id: int, kind: str = "") -> dict:
+    if kind in c.EMPLOYEE_KINDS:
+        ensure_annual_credits(user_id, kind)
+    sums = dict(
+        LedgerEntry.objects.filter(user_id=user_id)
+        .values_list("category")
+        .annotate(total=Sum("delta"))
+    )
+    pend = dict(
+        LeaveRequest.objects.filter(user_id=user_id, status__in=list(sm.PENDING))
+        .values_list("category")
+        .annotate(total=Sum("days"))
+    )
+    balances = {cat: sums.get(cat) or Decimal("0.00") for cat in c.ALL}
+    pending = {cat: pend.get(cat) or Decimal("0.00") for cat in c.ALL}
+    history = list(LedgerEntry.objects.filter(user_id=user_id).order_by("-at", "-id"))
+    return {
+        "user_id": user_id,
+        "balances": balances,
+        "pending": pending,
+        "history": history,
+    }
diff --git a/modules/elm/services/sla.py b/modules/elm/services/sla.py
new file mode 100644
index 00000000..e1062e74
--- /dev/null
+++ b/modules/elm/services/sla.py
@@ -0,0 +1,68 @@
+"""SLA reminder and escalation service (SF-EL-002, BR-EL-032, BR-EL-033)."""
+from __future__ import annotations
+
+from datetime import timedelta
+
+from django.db import transaction
+from django.utils import timezone
+
+from modules.elm.domain import state_machine as sm
+from modules.elm.models import LeaveRequest, Notification, SlaAction
+from modules.elm.selectors.config import effective_policy_version
+
+
+@transaction.atomic
+def process() -> dict:
+    pv = effective_policy_version()
+    sla_cfg = (pv.hierarchy.get("sla") if pv and isinstance(pv.hierarchy, dict) else None) or {}
+    remind_hours = sla_cfg.get("reminder_hours")
+    escalate_hours = sla_cfg.get("escalation_hours")
+    escalation_role = sla_cfg.get("escalation_role")
+    if not remind_hours and not escalate_hours:
+        return {"reminders": 0, "escalations": 0}
+
+    now = timezone.now()
+    reminders = 0
+    escalations = 0
+    pending = LeaveRequest.objects.filter(
+        status__in=list(sm.PENDING),
+        stage_entered_at__isnull=False,
+    )
+    for req in pending:
+        entered = req.stage_entered_at
+        if entered is None or not req.current_role:
+            continue
+        if remind_hours and now - entered >= timedelta(hours=int(remind_hours)):
+            _, created = SlaAction.objects.get_or_create(
+                request=req,
+                status=req.status,
+                stage=req.stage,
+                stage_entered_at=entered,
+                action=SlaAction.REMINDER,
+                defaults={"target_role": req.current_role},
+            )
+            if created:
+                Notification.objects.create(
+                    recipient_role=req.current_role,
+                    request=req,
+                    message=f"SLA reminder: Leave #{req.pk} awaits your action.",
+                )
+                reminders += 1
+        if (escalate_hours and escalation_role
+                and now - entered >= timedelta(hours=int(escalate_hours))):
+            _, created = SlaAction.objects.get_or_create(
+                request=req,
+                status=req.status,
+                stage=req.stage,
+                stage_entered_at=entered,
+                action=SlaAction.ESCALATION,
+                defaults={"target_role": escalation_role},
+            )
+            if created:
+                Notification.objects.create(
+                    recipient_role=escalation_role,
+                    request=req,
+                    message=f"SLA escalation: Leave #{req.pk} overdue at {req.current_role}.",
+                )
+                escalations += 1
+    return {"reminders": reminders, "escalations": escalations}
diff --git a/modules/elm/services/year_end.py b/modules/elm/services/year_end.py
new file mode 100644
index 00000000..9236b284
--- /dev/null
+++ b/modules/elm/services/year_end.py
@@ -0,0 +1,72 @@
+"""Year-end leave processing service (SF-EL-001, BR-EL-002..009)."""
+from __future__ import annotations
+
+from datetime import date
+from decimal import Decimal
+
+from django.db import transaction
+from django.utils import timezone
+
+from modules.elm.domain import categories as c
+from modules.elm.domain.year_end import vl_to_el
+from modules.elm.models import LedgerEntry, YearEndRun
+from modules.elm.selectors.config import effective_policy
+
+
+@transaction.atomic
+def run(year: int) -> YearEndRun:
+    existing = YearEndRun.objects.filter(year=year).first()
+    if existing:
+        return existing
+
+    run_rec = YearEndRun.objects.create(year=year)
+    _, policy = effective_policy(date(year, 12, 31))
+    ratio = policy.vl_to_el_ratio if policy else Decimal("2")
+
+    user_ids = sorted(
+        set(LedgerEntry.objects.filter(year__lte=year).values_list("user_id", flat=True))
+    )
+    for uid in user_ids:
+        for cat in c.LAPSING:
+            bal = _balance(uid, cat, year)
+            if bal > 0:
+                LedgerEntry.objects.get_or_create(
+                    user_id=uid,
+                    category=cat,
+                    year=year,
+                    entry_type=LedgerEntry.LAPSE,
+                    defaults={"delta": -bal, "note": f"{year} year-end lapse"},
+                )
+        vl_bal = _balance(uid, c.VL, year)
+        if vl_bal > 0:
+            converted = vl_to_el(vl_bal, ratio)
+            LedgerEntry.objects.get_or_create(
+                user_id=uid,
+                category=c.VL,
+                year=year,
+                entry_type=LedgerEntry.CONVERSION_OUT,
+                defaults={"delta": -vl_bal, "note": f"{year} VL conversion"},
+            )
+            if converted > 0:
+                LedgerEntry.objects.get_or_create(
+                    user_id=uid,
+                    category=c.EL,
+                    year=year,
+                    entry_type=LedgerEntry.CONVERSION_IN,
+                    defaults={"delta": converted, "note": f"{year} VL->EL conversion"},
+                )
+
+    run_rec.employees = len(user_ids)
+    run_rec.finished_at = timezone.now()
+    run_rec.save(update_fields=["employees", "finished_at"])
+    return run_rec
+
+
+def _balance(user_id: int, category: str, up_to_year: int) -> Decimal:
+    from django.db.models import Sum
+
+    total = (
+        LedgerEntry.objects.filter(user_id=user_id, category=category, year__lte=up_to_year)
+        .aggregate(s=Sum("delta"))["s"]
+    )
+    return total or Decimal("0")
diff --git a/modules/elm/tasks.py b/modules/elm/tasks.py
new file mode 100644
index 00000000..7d8edde0
--- /dev/null
+++ b/modules/elm/tasks.py
@@ -0,0 +1,16 @@
+"""Celery tasks for ELM (SF-EL-001, SF-EL-002)."""
+from celery import shared_task
+from django.utils import timezone
+
+from modules.elm.services import sla, year_end
+
+
+@shared_task(name="elm.year_end")
+def run_year_end(year: int | None = None) -> int:
+    target = year or (timezone.localdate().year - 1)
+    return year_end.run(target).employees
+
+
+@shared_task(name="elm.sla")
+def run_sla() -> dict:
+    return sla.process()
diff --git a/modules/elm/tests/__init__.py b/modules/elm/tests/__init__.py
new file mode 100644
index 00000000..9a464a41
--- /dev/null
+++ b/modules/elm/tests/__init__.py
@@ -0,0 +1 @@
+"""Domain test suite for the ELM module."""
diff --git a/modules/elm/tests/test_domain.py b/modules/elm/tests/test_domain.py
new file mode 100644
index 00000000..8b149472
--- /dev/null
+++ b/modules/elm/tests/test_domain.py
@@ -0,0 +1,255 @@
+"""Pure Python Domain Unit Tests for ELM.
+
+Validates core business rules (BR-EL-001..033), calculations,
+state machine transitions, routing, overlap, and year-end policies.
+Runs purely in memory without database dependencies.
+"""
+from datetime import date
+from decimal import Decimal
+
+import pytest
+
+from modules.elm.domain import (
+    categories as c,
+    counting,
+    overlap,
+    policy,
+    routing as r,
+    state_machine as sm,
+    year_end as ye,
+)
+
+
+# ============================================================================
+# BR-EL-001, 002: Categories & Policy Parameters
+# ============================================================================
+
+def test_default_policy_parsing_and_eligibility():
+    """BR-EL-001: Validate default policy parameters and employee eligibility."""
+    p = policy.parse(policy.DEFAULT_PARAMS)
+    assert p.annual_credit_for(c.FACULTY, c.CL) == Decimal("8")
+    assert p.annual_credit_for(c.FACULTY, c.VL) == Decimal("60")
+    assert p.annual_credit_for(c.STAFF, c.EL) == Decimal("30")
+
+    # Faculty is eligible for VL; Staff is not
+    p.check_eligible(c.FACULTY, c.VL)
+    with pytest.raises(policy.NotEligible):
+        p.check_eligible(c.STAFF, c.VL)
+
+
+def test_invalid_policy_detection():
+    """Policy validation flags invalid shapes, negative numbers, or invalid categories."""
+    with pytest.raises(policy.PolicyInvalid):
+        policy.parse("not a dict")
+
+    with pytest.raises(policy.PolicyInvalid):
+        policy.parse({"annual_credit": {c.FACULTY: {c.CL: -1}}, "eligible": {}})
+
+    with pytest.raises(policy.PolicyInvalid):
+        policy.parse({"annual_credit": {c.FACULTY: {"INVALID_CAT": 5}}, "eligible": {}})
+
+
+# ============================================================================
+# BR-EL-003, 006, 010, 011: Counting & Calendar Rules
+# ============================================================================
+
+def test_half_day_cl_calculation():
+    """BR-EL-010: Half-day CL counts as exactly 0.5 days on working days."""
+    cal = counting.Calendar()
+    # 2026-10-15 is Thursday (working day)
+    thursday = date(2026, 10, 15)
+    days = counting.chargeable_days(c.CL, thursday, thursday, c.FIRST_HALF, cal)
+    assert days == Decimal("0.5")
+
+    # Half day cannot span multiple dates
+    friday = date(2026, 10, 16)
+    with pytest.raises(counting.InvalidPeriod):
+        counting.chargeable_days(c.CL, thursday, friday, c.FIRST_HALF, cal)
+
+    # Half day is only permitted for Casual Leave
+    with pytest.raises(counting.InvalidPeriod):
+        counting.chargeable_days(c.EL, thursday, thursday, c.FIRST_HALF, cal)
+
+
+def test_continuous_counting_for_earned_leave():
+    """BR-EL-011: EL/COL/VL include intervening weekends and closed holidays."""
+    # From Friday 2026-10-16 to Monday 2026-10-19 = 4 continuous days
+    start = date(2026, 10, 16)
+    end = date(2026, 10, 19)
+    cal = counting.Calendar(closed_holidays=frozenset({date(2026, 10, 19)}))
+    days = counting.chargeable_days(c.EL, start, end, None, cal)
+    assert days == Decimal("4")
+
+
+def test_working_days_counting_for_casual_leave():
+    """BR-EL-011: CL excludes intervening weekends and closed holidays."""
+    # From Friday 2026-10-16 to Monday 2026-10-19:
+    # Sat 17 and Sun 18 are weekends. If Mon 19 is closed holiday, only Fri 16 is charged.
+    start = date(2026, 10, 16)
+    end = date(2026, 10, 19)
+    cal = counting.Calendar(closed_holidays=frozenset({date(2026, 10, 19)}))
+    days = counting.chargeable_days(c.CL, start, end, None, cal)
+    assert days == Decimal("1")  # Only Friday
+
+
+def test_restricted_holiday_calendar_validation():
+    """BR-EL-003: RH dates must be published in the restricted holidays calendar."""
+    rh_date = date(2026, 11, 8)
+    other_date = date(2026, 11, 9)
+    cal = counting.Calendar(restricted_holidays=frozenset({rh_date}))
+
+    counting.validate_rh_dates(rh_date, rh_date, cal)
+
+    with pytest.raises(counting.InvalidPeriod):
+        counting.validate_rh_dates(other_date, other_date, cal)
+
+
+def test_vacation_leave_calendar_validation():
+    """BR-EL-006: VL must be strictly inside a published vacation period."""
+    cal = counting.Calendar(vacations=((date(2026, 12, 20), date(2027, 1, 5)),))
+
+    # Within vacation period
+    counting.validate_vacation(date(2026, 12, 22), date(2026, 12, 28), cal)
+
+    # Outside vacation period
+    with pytest.raises(counting.InvalidPeriod):
+        counting.validate_vacation(date(2026, 11, 1), date(2026, 11, 5), cal)
+
+
+# ============================================================================
+# BR-EL-012, 014: Overlap Rules
+# ============================================================================
+
+def test_half_day_non_overlap():
+    """BR-EL-012: First half and second half on the same date do not overlap."""
+    d = date(2026, 10, 20)
+    int1 = overlap.Interval(d, d, c.FIRST_HALF)
+    int2 = overlap.Interval(d, d, c.SECOND_HALF)
+    assert overlap.overlaps(int1, int2) is False
+
+    # Same half on same date overlaps
+    int3 = overlap.Interval(d, d, c.FIRST_HALF)
+    assert overlap.overlaps(int1, int3) is True
+
+
+def test_range_overlap():
+    """Date ranges overlap according to standard interval boundaries."""
+    a = overlap.Interval(date(2026, 10, 1), date(2026, 10, 10))
+    b = overlap.Interval(date(2026, 10, 8), date(2026, 10, 15))
+    c_int = overlap.Interval(date(2026, 10, 11), date(2026, 10, 20))
+    assert overlap.overlaps(a, b) is True
+    assert overlap.overlaps(a, c_int) is False
+
+
+# ============================================================================
+# BR-EL-016..020: Routing Resolution
+# ============================================================================
+
+def test_unit_head_final_routing():
+    """BR-EL-016: CL and RH route only to Unit Head as final decision."""
+    hierarchy = {
+        "unit_heads": {"CSE": "HOD (CSE)"},
+        "director_role": "Director",
+        "establishment_role": "Deputy Registrar",
+        "sanctioning": {"faculty": {"default": "Director"}, "staff": {"default": "Registrar"}},
+    }
+    steps = r.resolve_route(
+        category=c.CL, kind=c.FACULTY, unit="CSE", applicant_roles=[], hierarchy=hierarchy,
+    )
+    assert len(steps) == 1
+    assert steps[0].step == r.UNIT_HEAD
+    assert steps[0].role == "HOD (CSE)"
+
+
+def test_higher_sanction_routing():
+    """BR-EL-017, 018: SCL/EL/COL/VL route through Unit Head, Establishment, and Sanction."""
+    hierarchy = {
+        "unit_heads": {"CSE": "HOD (CSE)"},
+        "director_role": "Director",
+        "establishment_role": "Deputy Registrar",
+        "establishment_categories": [c.EL],
+        "sanctioning": {"faculty": {"default": "Director"}, "staff": {"default": "Registrar"}},
+    }
+    steps = r.resolve_route(
+        category=c.EL, kind=c.FACULTY, unit="CSE", applicant_roles=[], hierarchy=hierarchy,
+    )
+    assert [s.step for s in steps] == [r.UNIT_HEAD, r.ESTABLISHMENT, r.SANCTION]
+    assert [s.role for s in steps] == ["HOD (CSE)", "Deputy Registrar", "Director"]
+
+
+def test_director_self_sanction_routing():
+    """BR-EL-020: Director applicant routes to single director self-sanction step."""
+    hierarchy = {
+        "unit_heads": {"CSE": "HOD (CSE)"},
+        "director_role": "Director",
+        "sanctioning": {"faculty": {"default": "Director"}},
+    }
+    steps = r.resolve_route(
+        category=c.EL, kind=c.FACULTY, unit="CSE", applicant_roles=["Director"], hierarchy=hierarchy,
+    )
+    assert len(steps) == 1
+    assert steps[0].step == r.DIRECTOR
+    assert steps[0].role == "Director"
+
+
+# ============================================================================
+# State Machine & Lifecycle (WF-EL-01..05, BR-EL-021..028)
+# ============================================================================
+
+def test_state_machine_substitute_workflow():
+    """Substitute must accept before request routes to Unit Head."""
+    t = sm.resolve(sm.AWAITING_SUBSTITUTE, sm.SUBSTITUTE_ACCEPT, sm.SUBSTITUTE, sm.AWAITING_UNIT_HEAD)
+    assert t.event == sm.SUBSTITUTE_ACCEPT
+
+    # Unauthorized actor cannot accept substitution
+    with pytest.raises(sm.ActorNotAllowed):
+        sm.resolve(sm.AWAITING_SUBSTITUTE, sm.SUBSTITUTE_ACCEPT, sm.UNIT_HEAD, sm.AWAITING_UNIT_HEAD)
+
+
+def test_state_machine_approval_and_rejection():
+    """Unit Head can approve or reject CL/RH, or recommend SCL/EL."""
+    t_app = sm.resolve(sm.AWAITING_UNIT_HEAD, sm.APPROVE, sm.UNIT_HEAD, sm.APPROVED)
+    assert t_app.event == sm.APPROVE
+
+    t_rec = sm.resolve(sm.AWAITING_UNIT_HEAD, sm.RECOMMEND, sm.UNIT_HEAD, sm.AWAITING_ESTABLISHMENT)
+    assert t_rec.event == sm.RECOMMEND
+
+
+def test_immediate_withdrawal_on_pending():
+    """BR-EL-022: Employee can withdraw pending requests from any pending state."""
+    for pending_state in (sm.AWAITING_SUBSTITUTE, sm.AWAITING_UNIT_HEAD, sm.AWAITING_SANCTION):
+        t = sm.resolve(pending_state, sm.WITHDRAW, sm.EMPLOYEE, sm.WITHDRAWN)
+        assert t.event == sm.WITHDRAW
+
+    # Cannot withdraw approved leave
+    with pytest.raises(sm.InvalidTransition):
+        sm.resolve(sm.APPROVED, sm.WITHDRAW, sm.EMPLOYEE, sm.WITHDRAWN)
+
+
+def test_cancellation_and_resumption_lifecycle():
+    """BR-EL-023, 027: Cancellation and resumption lifecycle on approved leave."""
+    # Cancellation request
+    t_can = sm.resolve(sm.APPROVED, sm.REQUEST_CANCELLATION, sm.EMPLOYEE, sm.CANCELLATION_PENDING)
+    assert t_can.event == sm.REQUEST_CANCELLATION
+
+    # Cancellation approval
+    t_can_app = sm.resolve(sm.CANCELLATION_PENDING, sm.CANCEL_APPROVE, sm.UNIT_HEAD, sm.CANCELLED)
+    assert t_can_app.event == sm.CANCEL_APPROVE
+
+    # Resumption submission & verification
+    t_res = sm.resolve(sm.APPROVED, sm.SUBMIT_RESUMPTION, sm.EMPLOYEE, sm.RESUMPTION_PENDING)
+    assert t_res.event == sm.SUBMIT_RESUMPTION
+
+    t_res_ver = sm.resolve(sm.RESUMPTION_PENDING, sm.VERIFY_RESUMPTION, sm.VERIFIER, sm.CLOSED)
+    assert t_res_ver.event == sm.VERIFY_RESUMPTION
+
+
+# ============================================================================
+# BR-EL-007, 008: Year-End Arithmetic
+# ============================================================================
+
+def test_vl_to_el_year_end_conversion():
+    """BR-EL-007: Unused VL converts to EL at configured ratio (default 2:1)."""
+    assert ye.vl_to_el(Decimal("60"), Decimal("2")) == Decimal("30.00")
+    assert ye.vl_to_el(Decimal("15"), Decimal("2")) == Decimal("7.50")
+    assert ye.vl_to_el(Decimal("0"), Decimal("2")) == Decimal("0")
diff --git a/registry/permissions.json b/registry/permissions.json
index 213c8f24..0be633ee 100644
--- a/registry/permissions.json
+++ b/registry/permissions.json
@@ -34,6 +34,260 @@
       "scope_permissions": [],
       "system_permissions": []
     },
+    "elm": {
+      "grants": {
+        "Deputy Registrar": [
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "Director": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "HOD (CSE)": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "HOD (Design)": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "HOD (ECE)": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "HOD (Liberal Arts)": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "HOD (ME)": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "HOD (NS)": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "Leave Administrator": [
+          "elm.calendar.publish",
+          "elm.leave_account.view",
+          "elm.offline_record.create",
+          "elm.policy.publish"
+        ],
+        "Registrar": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "SectionHead_HR": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "SectionHead_IWD": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "SectionHead_PS": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "SectionHead_RSPC": [
+          "elm.leave_request.approve",
+          "elm.leave_request.review",
+          "elm.resumption.review"
+        ],
+        "faculty": [
+          "elm.leave_balance.view",
+          "elm.leave_request.create",
+          "elm.leave_request.delete",
+          "elm.leave_request.update",
+          "elm.leave_request.view",
+          "elm.substitution.review"
+        ],
+        "staff": [
+          "elm.leave_balance.view",
+          "elm.leave_request.create",
+          "elm.leave_request.delete",
+          "elm.leave_request.update",
+          "elm.leave_request.view",
+          "elm.substitution.review"
+        ]
+      },
+      "module_grants": [
+        "Deputy Registrar",
+        "Director",
+        "HOD (CSE)",
+        "HOD (Design)",
+        "HOD (ECE)",
+        "HOD (Liberal Arts)",
+        "HOD (ME)",
+        "HOD (NS)",
+        "Leave Administrator",
+        "Registrar",
+        "SectionHead_HR",
+        "SectionHead_IWD",
+        "SectionHead_PS",
+        "SectionHead_RSPC",
+        "faculty",
+        "staff"
+      ],
+      "nav": {
+        "base_path": "/elm",
+        "icon": "CalendarCheck",
+        "items": [
+          {
+            "code": "elm.apply",
+            "icon": "Plus",
+            "label": "Apply for Leave",
+            "required_permission": "elm.leave_request.create",
+            "sort_order": 10,
+            "to": "/elm/apply"
+          },
+          {
+            "code": "elm.mine",
+            "icon": "CalendarBlank",
+            "label": "My Leave",
+            "required_permission": "elm.leave_request.view",
+            "sort_order": 20,
+            "to": "/elm/mine"
+          },
+          {
+            "code": "elm.balances",
+            "icon": "Wallet",
+            "label": "Balances & History",
+            "required_permission": "elm.leave_balance.view",
+            "sort_order": 30,
+            "to": "/elm/balances"
+          },
+          {
+            "code": "elm.substitutions",
+            "icon": "Users",
+            "label": "Substitutions",
+            "required_permission": "elm.substitution.review",
+            "sort_order": 40,
+            "to": "/elm/substitutions"
+          },
+          {
+            "code": "elm.queue",
+            "icon": "Checks",
+            "label": "Leave Approvals",
+            "required_permission": "elm.leave_request.review",
+            "sort_order": 50,
+            "to": "/elm/queue"
+          },
+          {
+            "code": "elm.resumptions",
+            "icon": "UserCheck",
+            "label": "Resumptions",
+            "required_permission": "elm.resumption.review",
+            "sort_order": 60,
+            "to": "/elm/resumptions"
+          },
+          {
+            "code": "elm.policies",
+            "icon": "Sliders",
+            "label": "Leave Policy",
+            "required_permission": "elm.policy.publish",
+            "sort_order": 70,
+            "to": "/elm/policies"
+          },
+          {
+            "code": "elm.calendar",
+            "icon": "Calendar",
+            "label": "Holiday Calendar",
+            "required_permission": "elm.calendar.publish",
+            "sort_order": 80,
+            "to": "/elm/calendar"
+          },
+          {
+            "code": "elm.offline",
+            "icon": "ClipboardText",
+            "label": "Offline Leave",
+            "required_permission": "elm.offline_record.create",
+            "sort_order": 90,
+            "to": "/elm/offline"
+          },
+          {
+            "code": "elm.accounts",
+            "icon": "IdentificationCard",
+            "label": "Leave Accounts",
+            "required_permission": "elm.leave_account.view",
+            "sort_order": 100,
+            "to": "/elm/accounts"
+          }
+        ],
+        "label": "Leave",
+        "nav_section": "Services",
+        "sort_order": 20,
+        "status": "active"
+      },
+      "permissions": [
+        {
+          "code": "elm.leave_request.view",
+          "label": "See one's own leave requests"
+        },
+        {
+          "code": "elm.leave_request.create",
+          "label": "Apply for leave or an extension"
+        },
+        {
+          "code": "elm.leave_request.update",
+          "label": "Modify, cancel or resume one's own leave"
+        },
+        {
+          "code": "elm.leave_request.delete",
+          "label": "Withdraw one's own pending request"
+        },
+        {
+          "code": "elm.substitution.review",
+          "label": "Accept or decline a substitute nomination"
+        },
+        {
+          "code": "elm.leave_balance.view",
+          "label": "See one's own balances and leave-account history"
+        },
+        {
+          "code": "elm.leave_request.review",
+          "label": "Review, recommend or forward routed leave"
+        },
+        {
+          "code": "elm.leave_request.approve",
+          "label": "Approve or reject leave as sanctioning authority"
+        },
+        {
+          "code": "elm.resumption.review",
+          "label": "Verify resumption of duty"
+        },
+        {
+          "code": "elm.policy.publish",
+          "label": "Create, revise and publish leave policy and hierarchy"
+        },
+        {
+          "code": "elm.calendar.publish",
+          "label": "Create, revise and publish the holiday/RH calendar"
+        },
+        {
+          "code": "elm.offline_record.create",
+          "label": "Record offline-sanctioned leave"
+        },
+        {
+          "code": "elm.leave_account.view",
+          "label": "See any employee's leave account"
+        }
+      ],
+      "scope_permissions": [],
+      "system_permissions": []
+    },
     "placement_cell": {
       "grants": {
         "Dean Academic": [