diff --git a/.importlinter b/.importlinter
index d964dc3c..e45331be 100644
--- a/.importlinter
+++ b/.importlinter
@@ -15,6 +15,7 @@ source_modules =
     modules.placement
     modules.directory
     modules.accesscontrol
+    modules.elm
 forbidden_modules =
     modules.placement.models
     modules.placement.services
@@ -25,6 +26,10 @@ forbidden_modules =
     modules.directory.services
     modules.directory.api
     modules.accesscontrol.models
+    modules.elm.models
+    modules.elm.services
+    modules.elm.api
+    modules.elm.domain
 # DIRECT imports only. contracts.py legitimately imports its OWN module's
 # models and services, so following the chain transitively would make this
 # contract impossible to satisfy. What we forbid is a module reaching straight
@@ -38,6 +43,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
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/LeaveApplication.tsx b/client/src/modules/elm/LeaveApplication.tsx
new file mode 100644
index 00000000..6d88a800
--- /dev/null
+++ b/client/src/modules/elm/LeaveApplication.tsx
@@ -0,0 +1,128 @@
+import { type FormEvent, useState } from "react";
+import { submitLeaveApplication } from "./api";
+
+const LeaveApplication = () => {
+  const [leaveType, setLeaveType] = useState("1");
+  const [startDate, setStartDate] = useState("");
+  const [endDate, setEndDate] = useState("");
+  const [reason, setReason] = useState("");
+  const [loading, setLoading] = useState<boolean>(false);
+  const [feedback, setFeedback] = useState<{ type: "success" | "error"; message: string } | null>(null);
+
+  const handleSubmit = async (e: FormEvent) => {
+    e.preventDefault();
+    setLoading(true);
+    setFeedback(null);
+    try {
+      await submitLeaveApplication({
+        leave_type: parseInt(leaveType, 10),
+        start_date: startDate,
+        end_date: endDate,
+        reason,
+      });
+      setFeedback({ type: "success", message: "Leave application submitted successfully!" });
+      setStartDate("");
+      setEndDate("");
+      setReason("");
+    } catch (err: any) {
+      setFeedback({
+        type: "error",
+        message: err.response?.data?.detail || "Failed to submit leave application.",
+      });
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div style={{ padding: "1.5rem", maxWidth: "600px" }}>
+      <h1>Apply for Leave</h1>
+
+      {feedback && (
+        <div
+          style={{
+            padding: "0.75rem",
+            marginBottom: "1rem",
+            borderRadius: "4px",
+            backgroundColor: feedback.type === "success" ? "#e6ffed" : "#ffeef0",
+            color: feedback.type === "success" ? "#1a7f37" : "#cf222e",
+            border: `1px solid ${feedback.type === "success" ? "#a8f0b7" : "#ffc1c0"}`,
+          }}
+        >
+          {feedback.message}
+        </div>
+      )}
+
+      <form onSubmit={handleSubmit} style={{ display: "flex", flexDirection: "column", gap: "1rem" }}>
+        <div>
+          <label htmlFor="leaveType">Leave Type:</label>
+          <select
+            id="leaveType"
+            value={leaveType}
+            onChange={(e) => setLeaveType(e.target.value)}
+            style={{ width: "100%", padding: "0.5rem", marginTop: "0.25rem" }}
+          >
+            <option value="1">Casual Leave (CL)</option>
+            <option value="2">Recreational Holiday (RH)</option>
+            <option value="3">Special Casual Leave (SCL)</option>
+            <option value="4">Earned Leave (EL)</option>
+            <option value="5">Vacation Leave (VL)</option>
+            <option value="6">Compensatory Off Leave (COL)</option>
+          </select>
+        </div>
+
+        <div>
+          <label htmlFor="startDate">Start Date:</label>
+          <input
+            type="date"
+            id="startDate"
+            required
+            value={startDate}
+            onChange={(e) => setStartDate(e.target.value)}
+            style={{ width: "100%", padding: "0.5rem", marginTop: "0.25rem" }}
+          />
+        </div>
+
+        <div>
+          <label htmlFor="endDate">End Date:</label>
+          <input
+            type="date"
+            id="endDate"
+            required
+            value={endDate}
+            onChange={(e) => setEndDate(e.target.value)}
+            style={{ width: "100%", padding: "0.5rem", marginTop: "0.25rem" }}
+          />
+        </div>
+
+        <div>
+          <label htmlFor="reason">Reason:</label>
+          <textarea
+            id="reason"
+            rows={3}
+            value={reason}
+            onChange={(e) => setReason(e.target.value)}
+            style={{ width: "100%", padding: "0.5rem", marginTop: "0.25rem" }}
+          />
+        </div>
+
+        <button
+          type="submit"
+          disabled={loading}
+          style={{
+            padding: "0.75rem",
+            backgroundColor: "#0969da",
+            color: "#fff",
+            border: "none",
+            borderRadius: "4px",
+            cursor: loading ? "not-allowed" : "pointer",
+          }}
+        >
+          {loading ? "Submitting..." : "Submit Application"}
+        </button>
+      </form>
+    </div>
+  );
+};
+
+export default LeaveApplication;
diff --git a/client/src/modules/elm/LeaveBalance.tsx b/client/src/modules/elm/LeaveBalance.tsx
new file mode 100644
index 00000000..1f8f1808
--- /dev/null
+++ b/client/src/modules/elm/LeaveBalance.tsx
@@ -0,0 +1,50 @@
+import { useEffect, useState } from "react";
+import { fetchLeaveBalances, type LeaveBalanceRow } from "./api";
+
+const LeaveBalance = () => {
+  const [leaveBalances, setLeaveBalances] = useState<LeaveBalanceRow[]>([]);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const fetchBalances = async () => {
+      try {
+        const balances = await fetchLeaveBalances();
+        setLeaveBalances(balances);
+      } catch (err: any) {
+        setError(err.response?.data?.detail || "Failed to fetch leave balances.");
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchBalances();
+  }, []);
+
+  if (loading) return <p>Loading leave balances...</p>;
+  if (error) return <p style={{ color: "red" }}>Error: {error}</p>;
+
+  return (
+    <div style={{ padding: "1.5rem" }}>
+      <h1>Leave Balances</h1>
+      <table style={{ width: "100%", borderCollapse: "collapse", marginTop: "1rem" }}>
+        <thead>
+          <tr style={{ textAlign: "left", borderBottom: "2px solid #ccc" }}>
+            <th style={{ padding: "0.5rem" }}>Leave Type ID</th>
+            <th style={{ padding: "0.5rem" }}>Balance (Days)</th>
+          </tr>
+        </thead>
+        <tbody>
+          {leaveBalances.map((balance) => (
+            <tr key={balance.id} style={{ borderBottom: "1px solid #eee" }}>
+              <td style={{ padding: "0.5rem" }}>{balance.leave_type}</td>
+              <td style={{ padding: "0.5rem" }}>{balance.balance}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+};
+
+export default LeaveBalance;
diff --git a/client/src/modules/elm/LeaveHistory.tsx b/client/src/modules/elm/LeaveHistory.tsx
new file mode 100644
index 00000000..69d24715
--- /dev/null
+++ b/client/src/modules/elm/LeaveHistory.tsx
@@ -0,0 +1,150 @@
+
+import { useEffect, useState } from "react";
+import {
+  fetchLeaveApplications,
+  withdrawLeaveApplication,
+  type LeaveApplicationRow,
+} from "./api";
+
+function canWithdraw(status: string): boolean {
+  const normalized = status.toUpperCase().replace(/[\s-]+/g, "_");
+  return (
+    normalized === "AWAITING_SUBSTITUTE" ||
+    normalized === "AWAITING_APPROVAL"
+  );
+}
+
+export default function LeaveHistory() {
+  const [applications, setApplications] = useState<LeaveApplicationRow[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [busyId, setBusyId] = useState<number | null>(null);
+  const [message, setMessage] = useState("");
+
+  async function loadApplications() {
+    setLoading(true);
+    setError("");
+
+    try {
+      const rows = await fetchLeaveApplications();
+      setApplications(rows);
+    } catch {
+      setError("Unable to load leave applications. Please try again.");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  useEffect(() => {
+    void loadApplications();
+  }, []);
+
+  async function handleWithdraw(id: number) {
+    if (!window.confirm(`Withdraw leave application #${id}?`)) return;
+
+    setBusyId(id);
+    setError("");
+    setMessage("");
+
+    try {
+      await withdrawLeaveApplication(id);
+      setMessage(`Application #${id} withdrawn successfully.`);
+      await loadApplications();
+    } catch {
+      setError("Withdrawal failed. The application may no longer be eligible.");
+    } finally {
+      setBusyId(null);
+    }
+  }
+
+  return (
+    <main className="mx-auto max-w-5xl p-6">
+      <div className="mb-6 flex items-center justify-between gap-4">
+        <h1 className="text-2xl font-bold">Leave Application History</h1>
+        <button
+          type="button"
+          onClick={() => void loadApplications()}
+          disabled={loading}
+          className="rounded border px-4 py-2 disabled:opacity-50"
+        >
+          Refresh
+        </button>
+      </div>
+
+      {message && (
+        <p role="status" className="mb-4 text-green-700">
+          {message}
+        </p>
+      )}
+
+      {error && (
+        <div role="alert" className="mb-4 text-red-600">
+          <p>{error}</p>
+          <button
+            type="button"
+            onClick={() => void loadApplications()}
+            className="mt-2 underline"
+          >
+            Try again
+          </button>
+        </div>
+      )}
+
+      {loading ? (
+        <p role="status">Loading applications...</p>
+      ) : applications.length === 0 ? (
+        <p>No leave applications found.</p>
+      ) : (
+        <div className="overflow-x-auto rounded-lg border">
+          <table className="w-full text-left text-sm">
+            <thead className="bg-gray-100">
+              <tr>
+                <th className="p-3">ID</th>
+                <th className="p-3">Leave Type</th>
+                <th className="p-3">Start Date</th>
+                <th className="p-3">End Date</th>
+                <th className="p-3">Reason</th>
+                <th className="p-3">Status</th>
+                <th className="p-3">Action</th>
+              </tr>
+            </thead>
+            <tbody>
+              {applications.map((application) => (
+                <tr key={application.id} className="border-t">
+                  <td className="p-3">{application.id}</td>
+                  <td className="p-3">
+                    {`Leave type #${application.leave_type}`}
+                  </td>
+                  <td className="p-3">{application.start_date}</td>
+                  <td className="p-3">{application.end_date}</td>
+                  <td className="p-3">
+                    {application.reason || "—"}
+                  </td>
+                  <td className="p-3">
+                    {application.status.replace(/_/g, " ")}
+                  </td>
+                  <td className="p-3">
+                    {canWithdraw(application.status) ? (
+                      <button
+                        type="button"
+                        onClick={() => void handleWithdraw(application.id)}
+                        disabled={busyId !== null}
+                        className="rounded border border-red-600 px-3 py-1 text-red-600 disabled:opacity-50"
+                      >
+                        {busyId === application.id
+                          ? "Withdrawing..."
+                          : "Withdraw"}
+                      </button>
+                    ) : (
+                      "—"
+                    )}
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+    </main>
+  );
+}
diff --git a/client/src/modules/elm/api.ts b/client/src/modules/elm/api.ts
new file mode 100644
index 00000000..1f52a00a
--- /dev/null
+++ b/client/src/modules/elm/api.ts
@@ -0,0 +1,56 @@
+
+import { http } from "../../lib/http";
+
+export interface LeaveBalanceRow {
+  id: number;
+  employee_id: number;
+  leave_type: number;
+  balance: number;
+}
+
+export interface LeaveApplicationPayload {
+  leave_type: number;
+  start_date: string;
+  end_date: string;
+  reason?: string;
+  station_leave_details?: string;
+}
+
+export interface LeaveApplicationRow {
+  id: number;
+  applicant_id: number;
+  leave_type: number;
+  start_date: string;
+  end_date: string;
+  reason: string;
+  station_leave_details: string;
+  status: string;
+}
+
+export async function fetchLeaveBalances(): Promise<LeaveBalanceRow[]> {
+  const { data } = await http.get<LeaveBalanceRow[]>("/elm/balances");
+  return data;
+}
+
+export async function submitLeaveApplication(
+  payload: LeaveApplicationPayload
+) {
+  const { data } = await http.post("/elm/applications", payload);
+  return data;
+}
+
+export async function fetchLeaveApplications(): Promise<LeaveApplicationRow[]> {
+  const { data } = await http.get<LeaveApplicationRow[]>(
+    "/elm/applications"
+  );
+  return data;
+}
+
+export async function withdrawLeaveApplication(
+  id: number
+): Promise<LeaveApplicationRow> {
+  const { data } = await http.post<LeaveApplicationRow>(
+    `/elm/applications/${id}/withdraw`
+  );
+  return data;
+}
diff --git a/client/src/modules/elm/routes.tsx b/client/src/modules/elm/routes.tsx
new file mode 100644
index 00000000..33739431
--- /dev/null
+++ b/client/src/modules/elm/routes.tsx
@@ -0,0 +1,14 @@
+
+import { lazy } from "react";
+import { Navigate, type RouteObject } from "react-router-dom";
+
+const LeaveBalance = lazy(() => import("./LeaveBalance"));
+const LeaveApplication = lazy(() => import("./LeaveApplication"));
+const LeaveHistory = lazy(() => import("./LeaveHistory"));
+
+export const routes: RouteObject[] = [
+  { index: true, element: <Navigate to="balance" replace /> },
+  { path: "balance", element: <LeaveBalance /> },
+  { path: "application", element: <LeaveApplication /> },
+  { path: "history", element: <LeaveHistory /> },
+];
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..681203e0 100644
--- a/docs/02-iam/permission-catalog.generated.md
+++ b/docs/02-iam/permission-catalog.generated.md
@@ -13,6 +13,13 @@ 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.balance.view` | View leave balance | `faculty`, `staff` |
+| `elm.application.create` | Submit a leave application | `faculty`, `staff` |
+
 ## `placement_cell`
 
 | Code | What it allows | Held by |
diff --git a/docs/changes_made_by_24bcs260.md b/docs/changes_made_by_24bcs260.md
new file mode 100644
index 00000000..32fb2749
--- /dev/null
+++ b/docs/changes_made_by_24bcs260.md
@@ -0,0 +1,304 @@
+# Changes Made by 24BCS260 — ELM Phase 2 Engineering Log
+
+## 1. Student & Environment Configuration
+- **Student Roll No**: 24BCS260
+- **Repository**: `FusionIIIT/Fusion-Integrated`
+- **Fork**: `https://github.com/uttkarshbagad/Fusion-Integrated`
+- **Branch**: `elm-phase2`
+- **Inherited Baseline**: Phase 1 implementation (`elm-pilot-qwen` / `ELM_MODEL_1`)
+- **Machine**: Apple MacBook Air (M3, 16 GB Unified Memory)
+- **Local AI Coding Model**: `qwen2.5-coder:7b` (via Ollama)
+- **Coding Interface**: Continue VS Code Extension (Chat mode with `@file` context)
+
+---
+
+## 2. Inherited Phase-1 Baseline Audit
+Reviewing the inherited Phase-1 code against the **ELM Specification Bundle v1.4** highlighted key areas requiring engineering attention:
+1. **Incomplete Models**: `LeaveApplication` lacked a `reason` field, dropping user input. Status choices were limited to basic states (`PENDING`, `APPROVED`, etc.) without the workflow gates (`AWAITING_SUBSTITUTE`, `AWAITING_APPROVAL`) specified in `06_ELM_Workflow_Specifications_v1.6`. `SubstituteNomination` lacked a `status` field to record substitute consent (`BR-EL-015`).
+2. **Missing Domain Validation**: No checks for leave balance sufficiency, date overlap (`BR-EL-012`), or self-nomination as substitute (`BR-EL-014`).
+3. **Frontend Stubs**: `LeaveBalance.tsx` was empty; `LeaveApplication.tsx` only logged form inputs to `console.log` without calling the API.
+4. **Test Coverage**: Zero unit or integration tests existed in `modules/elm/`.
+
+---
+
+## 3. Commit-by-Commit Engineering Log
+
+### Commit 1 (e4afea2) — Models & Workflow Schema Alignment
+- **Target File**: `modules/elm/models.py`
+- **Objective**: Align data models with workflow state lifecycles and persist leave reasons and substitute response statuses.
+- **Prompt to Qwen2.5-Coder:7b**:
+```text
+@models.py
+Review and update modules/elm/models.py to satisfy the ELM specifications:
+1. In LeaveApplication:
+   - Add a `reason` TextField (blank=True, default="").
+   - Update `STATUS_CHOICES` to include:
+     ('AWAITING_SUBSTITUTE', 'Awaiting Substitute Consent'),
+     ('AWAITING_APPROVAL', 'Awaiting Approval'),
+     ('APPROVED', 'Approved'),
+     ('REJECTED', 'Rejected'),
+     ('WITHDRAWN', 'Withdrawn'),
+     ('CANCELLED', 'Cancelled')
+   - Default status should be 'AWAITING_APPROVAL'.
+
+2. In SubstituteNomination:
+   - Add a `status` CharField with choices:
+     ('PENDING', 'Pending Consent'),
+     ('ACCEPTED', 'Accepted'),
+     ('DECLINED', 'Declined')
+     with default='PENDING'.
+   - Add a `decline_reason` TextField (blank=True, default="").
+
+Preserve all existing table names (Meta db_table) and integer ID conventions for Fusion compatibility.
+```
+
+- **Observations & Code Review**:
+  - The model accurately updated `STATUS_CHOICES` and added `reason`, `SubstituteNomination.status`, and `decline_reason`.
+  - **Defect Caught During Review**: The model retained `models.CharField(max_length=10)` on `LeaveApplication.status`. Because `"AWAITING_SUBSTITUTE"` is 19 characters, this would have triggered database truncation/`DataError` at runtime.
+  - **Action**: Updated `max_length` to `30` on `LeaveApplication.status` and `20` on `SubstituteNomination.status`.
+
+- **Commit**: `e4afea2` — `feat(elm): update models with workflow statuses and reasons`
+
+---
+
+### Commit 2 (9e9507e) — Pure-Python Domain Business Rules & Transitions
+- **Target File**: `modules/elm/domain/policy.py`
+- **Objective**: Implement pure-Python domain business rules (`BR-EL-012`, `BR-EL-014`, balance validation, and workflow state transitions) with no Django or ORM dependencies.
+- **Prompt to Qwen2.5-Coder:7b**:
+```text
+@policy.py
+Update modules/elm/domain/policy.py with pure-Python business rules from the ELM Specification Bundle (no Django or ORM imports):
+
+1. Add `validate_substitute_eligibility(applicant_id: int, substitute_id: int) -> None`:
+   - Raise ValueError if applicant_id == substitute_id (BR-EL-014).
+
+2. Add `check_date_overlap(start_a: date, end_a: date, start_b: date, end_b: date) -> bool`:
+   - Return True if the two date intervals [start_a, end_a] and [start_b, end_b] overlap (BR-EL-012).
+
+3. Add `validate_balance_sufficiency(current_balance: float | int, requested_days: float | int) -> None`:
+   - Raise ValueError("Insufficient leave balance") if requested_days > current_balance.
+
+4. Add `is_valid_transition(current_status: str, target_status: str) -> bool`:
+   - Implement the allowed state transitions:
+     - AWAITING_SUBSTITUTE -> AWAITING_APPROVAL, WITHDRAWN
+     - AWAITING_APPROVAL -> APPROVED, REJECTED, WITHDRAWN
+     - APPROVED -> CANCELLED
+   - Return False for all other transitions.
+
+Keep all existing LeaveCode, LeaveEntitlement, LEAVE_ENTITLEMENTS, and requested_days functions intact.
+```
+
+- **Observations & Code Review**:
+  - The model correctly added `validate_substitute_eligibility`, `check_date_overlap`, `validate_balance_sufficiency`, and `is_valid_transition`.
+  - Zero Django or ORM dependencies were introduced, fully respecting Fusion ERP's strict architecture rule (`domain/` may not import Django, DRF or Celery).
+- **Commit**: `9e9507e` — `feat(elm): add pure-Python domain business rules and transition validators`
+
+---
+
+### Commit 3 (ae43983) — Service Layer Workflow & Business Rule Integration
+- **Target File**: `modules/elm/services/applications.py`
+- **Objective**: Integrate domain validations into the application service and implement full lifecycle workflows (leave submission with balance/overlap gates, substitute nomination with eligibility gates, substitute consent responses, supervisor reviews with balance deduction, and withdrawals).
+- **Prompt to Qwen2.5-Coder:7b**:
+```text
+Look strictly at `modules/elm/services/applications.py`, `modules/elm/models.py`, and `modules/elm/domain/policy.py`.
+
+Update `modules/elm/services/applications.py` with this exact structure:
+
+from datetime import date
+from django.db import transaction
+from modules.elm.domain.policy import (
+    check_date_overlap,
+    is_valid_transition,
+    requested_days,
+    validate_balance_sufficiency,
+    validate_substitute_eligibility,
+)
+from modules.elm.models import (
+    LeaveApplication,
+    LeaveBalance,
+    LeaveType,
+    SubstituteNomination,
+)
+
+1. `submit_leave_application`:
+   - Arguments: applicant_id: int, leave_type: LeaveType, start_date: date, end_date: date, reason: str = "", station_leave_details: str = ""
+   - Calculate days = requested_days(start_date, end_date)
+   - Fetch applicant's LeaveBalance for leave_type; call validate_balance_sufficiency(balance_obj.balance, days)
+   - Query existing LeaveApplications for applicant with status in ["AWAITING_SUBSTITUTE", "AWAITING_APPROVAL", "APPROVED"]; for each, if check_date_overlap(app.start_date, app.end_date, start_date, end_date) is True, raise ValueError("Overlapping leave application exists.")
+   - Create LeaveApplication with status="AWAITING_APPROVAL", reason=reason.
+
+2. `nominate_substitute`:
+   - Arguments: leave_application: LeaveApplication, substitute_id: int, start_date: date, end_date: date, reason: str = ""
+   - Call validate_substitute_eligibility(leave_application.applicant_id, substitute_id)
+   - Create SubstituteNomination with status="PENDING"
+   - Update leave_application.status = "AWAITING_SUBSTITUTE", save.
+
+3. `respond_substitute_nomination`:
+   - Arguments: nomination: SubstituteNomination, accept: bool, decline_reason: str = ""
+   - If accept: nomination.status = "ACCEPTED", nomination.leave_application.status = "AWAITING_APPROVAL", save both.
+   - If not accept: nomination.status = "DECLINED", nomination.decline_reason = decline_reason, save.
+
+4. `review_leave_application`:
+   - Arguments: application: LeaveApplication, approve: bool
+   - If approve:
+     - Check is_valid_transition(application.status, "APPROVED")
+     - Fetch applicant's LeaveBalance with select_for_update(); deduct requested_days; save balance.
+     - application.status = "APPROVED", save.
+   - If reject:
+     - Check is_valid_transition(application.status, "REJECTED")
+     - application.status = "REJECTED", save.
+
+5. `withdraw_application`:
+   - Check is_valid_transition(application.status, "WITHDRAWN")
+   - application.status = "WITHDRAWN", save.
+
+6. Keep `get_employee_balances(employee_id: int)`.
+```
+
+- **Defects Caught During Human-in-the-Loop Review**:
+  1. *Explanation vs. Code Discrepancy*: In `nominate_substitute`, Qwen's explanation stated that it updated the leave application status to `AWAITING_SUBSTITUTE`, but it completely omitted those lines (`leave_application.status = "AWAITING_SUBSTITUTE"; leave_application.save()`) in the generated code block.
+  2. *Related Object Persistence Bug*: In `respond_substitute_nomination`, Qwen mutated `nomination.leave_application.status = "AWAITING_APPROVAL"` in memory, but only called `nomination.save()`. It forgot to call `save()` on `nomination.leave_application`, meaning the status would never be persisted in the database!
+  3. *Missing Null Safety*: In `submit_leave_application`, it accessed `balance_obj.balance` without checking if `balance_obj` is `None`, risking an unhandled `AttributeError`.
+- **Engineering Actions Applied**:
+  - Added explicit `leave_application.save(update_fields=["status"])` to both `nominate_substitute` and `respond_substitute_nomination`.
+  - Added defensive `None` check raising `ValueError` when an applicant lacks a balance record.
+  - Enforced atomic transactions and `select_for_update()` during supervisor review balance deductions to prevent race conditions.
+- **Commit**: `ae43983` — `feat(elm): integrate domain rules and workflow actions into application service`
+
+---
+
+### Commit 4 (916bed9) — Database Schema Migration
+- **Target File**: `modules/elm/migrations/0002_add_workflow_and_reason_fields.py`
+- **Objective**: Create the Django schema migration reflecting the new fields (`reason`, `SubstituteNomination.status`, `decline_reason`) and updated `LeaveApplication.status` choices and length.
+- **Context Files Provided**: `modules/elm/models.py`, `modules/elm/migrations/0001_initial.py`
+- **Prompt to Qwen2.5-Coder:7b**:
+```text
+Based on `modules/elm/models.py` and `modules/elm/migrations/0001_initial.py`:
+
+Write the Django schema migration `modules/elm/migrations/0002_add_workflow_and_reason_fields.py` to reflect the updated models:
+1. Set dependencies = [('elm', '0001_initial')].
+2. AddField `reason` (models.TextField, blank=True, default='') to `leaveapplication`.
+3. AlterField `status` on `leaveapplication` with max_length=30, default='AWAITING_APPROVAL', and the updated STATUS_CHOICES from models.py.
+4. AddField `status` on `substitutenomination` with max_length=20, default='PENDING', and STATUS_CHOICES from models.py.
+5. AddField `decline_reason` (models.TextField, blank=True, default='') to `substitutenomination`.
+```
+
+- **Engineering Action**: Corrected the operation on `substitutenomination.status` to `migrations.AddField`.
+- **Commit**: `916bed9` — `feat(elm): add schema migration for workflow statuses and reasons`
+
+---
+
+### Commit 5 (937b9dc) — Domain Unit Test Suite
+- **Target File**: `modules/elm/tests/test_policy.py`
+- **Objective**: Establish the first automated unit test suite for ELM to test pure-Python domain business rules (`BR-EL-012`, `BR-EL-014`, balance validation, workflow state transitions, and requested days calculation).
+- **Context File Provided**: `modules/elm/domain/policy.py`
+- **Prompt to Qwen2.5-Coder:7b**:
+```text
+Based on `modules/elm/domain/policy.py`:
+
+Write a comprehensive pytest unit test suite in `modules/elm/tests/test_policy.py` to test the pure-Python domain rules:
+
+1. Test `validate_substitute_eligibility`:
+   - Passes when applicant_id != substitute_id.
+   - Raises ValueError when applicant_id == substitute_id (BR-EL-014).
+
+2. Test `check_date_overlap` (BR-EL-012):
+   - Returns True for overlapping intervals (e.g., Oct 1-5 and Oct 4-8, or nested intervals).
+   - Returns False for disjoint/adjacent intervals (e.g., Oct 1-5 and Oct 6-10).
+
+3. Test `validate_balance_sufficiency`:
+   - Passes when balance >= requested days.
+   - Raises ValueError when requested days > balance.
+
+4. Test `is_valid_transition`:
+   - Returns True for allowed transitions (AWAITING_SUBSTITUTE -> AWAITING_APPROVAL/WITHDRAWN, AWAITING_APPROVAL -> APPROVED/REJECTED/WITHDRAWN, APPROVED -> CANCELLED).
+   - Returns False for illegal transitions (e.g. APPROVED -> REJECTED, REJECTED -> APPROVED, WITHDRAWN -> APPROVED).
+
+5. Test `requested_days`:
+   - Correct day count for valid ranges.
+   - Raises ValueError if end_date < start_date.
+
+Write clean, idiomatic pytest functions without Django database fixtures (pure Python unit tests).
+```
+
+- **Defects Caught During Human-in-the-Loop Review**:
+  1. *Missing Import*: The model called `date(2023, 10, 1)` throughout the tests but omitted `from datetime import date`. This would have caused `pytest` to immediately fail with `NameError: name 'date' is not defined`.
+  2. *Contradictory Overlap Assertion*: In `test_check_date_overlap`, line 18 asserted that `(Oct 1-5)` and `(Oct 6-10)` **do** overlap (`assert check_date_overlap(...)`), and then three lines later asserted that `(Oct 1-5)` and `(Oct 6-10)` **do not** overlap (`assert not check_date_overlap(...)`). Since the dates are disjoint, line 18 would fail `pytest`.
+- **Engineering Actions Applied**:
+  - Added `from datetime import date` to imports.
+  - Replaced the contradictory line with valid partial and nested/enclosed overlap test cases.
+- **Commit**: `937b9dc` — `test(elm): add automated pytest suite for domain policy business rules`
+
+---
+
+### Commit 6 (fa0e6a3) — REST API Layer (Serializers, Views, and URL Routing)
+- **Target Files**: `modules/elm/api/serializers.py`, `modules/elm/api/views.py`, `modules/elm/api/urls.py`
+- **Objective**: Wire HTTP endpoints and request/response serializers to the application service layer to support the complete leave application lifecycle (submission, substitute responses, supervisor review, and withdrawal).
+- **Context Files Provided**: `modules/elm/api/serializers.py`, `modules/elm/api/views.py`, `modules/elm/api/urls.py`, `modules/elm/services/applications.py`
+- **Prompts to Qwen2.5-Coder:7b**:
+```text
+Update modules/elm/api/serializers.py:
+1. In LeaveApplicationSerializer: include 'reason' and make 'status' and 'applicant_id' read-only.
+2. Add SubstituteNominationSerializer with 'status' read-only.
+3. Add SubstituteResponseSerializer with accept and decline_reason.
+4. Add ReviewApplicationSerializer with approve.
+
+Update modules/elm/api/views.py and modules/elm/api/urls.py:
+1. In LeaveApplicationListCreateView.post: call submit_leave_application, catch ValueError -> HTTP 400.
+2. Add SubstituteResponseView: call respond_substitute_nomination.
+3. Add LeaveApplicationReviewView: call review_leave_application.
+4. Add LeaveApplicationWithdrawView: call withdraw_application.
+```
+
+- **Defects Caught During Human-in-the-Loop Review**:
+  1. *Omission of Existing Endpoint*: Qwen accidentally omitted `LeaveBalanceListView` from `views.py` while keeping its route in `urls.py`, which would crash routing with an `AttributeError`.
+  2. *Missing Imports*: `HasPermission` and `SubstituteNominationSerializer` were referenced in the views without being imported, causing `NameError`.
+  3. *URL Signature Mismatch (`TypeError`)*: In `urls.py`, routes were defined with `<int:pk>`, but Qwen defined the view methods as `post(self, request)` without `pk`, which causes DRF to raise `TypeError: post() got an unexpected keyword argument 'pk'`.
+  4. *Passing Raw String ID instead of Model Instance*: The service functions expect model instances (`application: LeaveApplication`), but Qwen passed `request.data['id']` directly, causing `AttributeError: 'str' object has no attribute 'status'`.
+- **Engineering Actions Applied**:
+  - Preserved `LeaveBalanceListView` in `views.py`.
+  - Added all required imports (`get_object_or_404`, `HasPermission`, `SubstituteNominationSerializer`).
+  - Corrected method signatures to `post(self, request, pk: int)` and fetched model instances via `get_object_or_404`.
+  - Added OpenAPI `@extend_schema` annotations for schema compliance.
+- **Commit**: `fa0e6a3` — `feat(elm): wire complete REST API views, serializers, and routes`
+
+---
+
+### Commit 7 (4d1a882) — Frontend Client Integration (React Components & API Client)
+- **Target Files**: `client/src/modules/elm/api.ts`, `client/src/modules/elm/LeaveBalance.tsx`, `client/src/modules/elm/LeaveApplication.tsx`
+- **Objective**: Replace frontend placeholder stubs and mock console logs with live data fetching and form submission handling wired to the REST API.
+- **Context Files Provided**: `client/src/modules/elm/api.ts`, `client/src/modules/elm/LeaveBalance.tsx`, `client/src/modules/elm/LeaveApplication.tsx`
+- **Prompt to Qwen2.5-Coder:7b**:
+```text
+Look strictly at `client/src/modules/elm/api.ts`, `client/src/modules/elm/LeaveBalance.tsx`, and `client/src/modules/elm/LeaveApplication.tsx`.
+
+1. In `api.ts`:
+   - Add `reason?: string` to `LeaveApplicationPayload`.
+
+2. Update `LeaveBalance.tsx`:
+   - Use `useEffect` to fetch balances on mount using `fetchLeaveBalances()`.
+   - Render a loading state, error state, and a clean table/card list displaying the leave balances.
+
+3. Update `LeaveApplication.tsx`:
+   - Connect the form submission to `submitLeaveApplication(...)`.
+   - Show loading state while submitting.
+   - Show a success alert upon successful creation and reset the form.
+   - Catch errors and display the error message to the user.
+```
+
+- **Defects Caught During Human-in-the-Loop Review**:
+  1. *Hallucinated Dependency (`react-toastify`)*: Qwen added `import { toast } from "react-toastify"`. The Fusion project does not have `react-toastify` installed (Fusion uses Mantine UI), which would cause `npm run build` and `npm run typecheck` to fail with `Cannot find module 'react-toastify'`.
+  2. *Missing TypeScript Type Import*: In `LeaveBalance.tsx`, Qwen annotated state as `useState<LeaveBalanceRow[]>([])` without importing `LeaveBalanceRow`.
+  3. *Redundant Relative Path*: Imported from `"../../modules/elm/api"` when `api.ts` is in the same directory (`./api`).
+- **Engineering Actions Applied**:
+  - Replaced the uninstalled toast dependency with self-contained, clean notification banners.
+  - Imported `type LeaveBalanceRow` from `./api`.
+  - Added `reason?: string` to `LeaveApplicationPayload` in `api.ts`.
+  - Added form validation, loading states, and reset handling.
+- **Commit**: `4d1a882` — `feat(elm): wire LeaveBalance and LeaveApplication frontend to REST API`
+
+
+
+
+
+
diff --git a/modules/elm/__init__.py b/modules/elm/__init__.py
new file mode 100644
index 00000000..6d9a3272
--- /dev/null
+++ b/modules/elm/__init__.py
@@ -0,0 +1 @@
+"""ELM (Employee Leave Management) module."""
diff --git a/modules/elm/api/__init__.py b/modules/elm/api/__init__.py
new file mode 100644
index 00000000..d6660144
--- /dev/null
+++ b/modules/elm/api/__init__.py
@@ -0,0 +1 @@
+"""ELM API package."""
diff --git a/modules/elm/api/serializers.py b/modules/elm/api/serializers.py
new file mode 100644
index 00000000..71772ec4
--- /dev/null
+++ b/modules/elm/api/serializers.py
@@ -0,0 +1,56 @@
+from rest_framework import serializers
+
+from modules.elm.models import LeaveApplication, LeaveBalance, LeaveType, SubstituteNomination
+
+
+class LeaveTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveType
+        fields = ["id", "leave_type"]
+
+
+class LeaveBalanceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveBalance
+        fields = ["id", "employee_id", "leave_type", "balance"]
+
+
+class LeaveApplicationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LeaveApplication
+        fields = [
+            "id",
+            "applicant_id",
+            "leave_type",
+            "start_date",
+            "end_date",
+            "station_leave_details",
+            "reason",
+            "status",
+        ]
+        read_only_fields = ["status", "applicant_id"]
+
+
+class SubstituteNominationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SubstituteNomination
+        fields = [
+            "id",
+            "leave_application",
+            "substitute_id",
+            "start_date",
+            "end_date",
+            "reason",
+            "status",
+            "decline_reason",
+        ]
+        read_only_fields = ["status"]
+
+
+class SubstituteResponseSerializer(serializers.Serializer):
+    accept = serializers.BooleanField()
+    decline_reason = serializers.CharField(required=False, allow_blank=True, default="")
+
+
+class ReviewApplicationSerializer(serializers.Serializer):
+    approve = serializers.BooleanField()
diff --git a/modules/elm/api/urls.py b/modules/elm/api/urls.py
new file mode 100644
index 00000000..6175ef97
--- /dev/null
+++ b/modules/elm/api/urls.py
@@ -0,0 +1,27 @@
+from django.urls import path
+
+from modules.elm.api import views as v
+
+urlpatterns = [
+    path("balances", v.LeaveBalanceListView.as_view(), name="elm-balances"),
+    path(
+        "applications",
+        v.LeaveApplicationListCreateView.as_view(),
+        name="elm-applications",
+    ),
+    path(
+        "nominations/<int:pk>/respond",
+        v.SubstituteResponseView.as_view(),
+        name="elm-nomination-respond",
+    ),
+    path(
+        "applications/<int:pk>/review",
+        v.LeaveApplicationReviewView.as_view(),
+        name="elm-application-review",
+    ),
+    path(
+        "applications/<int:pk>/withdraw",
+        v.LeaveApplicationWithdrawView.as_view(),
+        name="elm-application-withdraw",
+    ),
+]
diff --git a/modules/elm/api/views.py b/modules/elm/api/views.py
new file mode 100644
index 00000000..85c2ff67
--- /dev/null
+++ b/modules/elm/api/views.py
@@ -0,0 +1,116 @@
+from django.shortcuts import get_object_or_404
+from drf_spectacular.utils import extend_schema
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from fusion_auth.permissions import HasModuleGrant, HasPermission
+from modules.elm.api.serializers import (
+    LeaveApplicationSerializer,
+    LeaveBalanceSerializer,
+    ReviewApplicationSerializer,
+    SubstituteNominationSerializer,
+    SubstituteResponseSerializer,
+)
+from modules.elm.models import LeaveApplication, LeaveBalance, SubstituteNomination
+from modules.elm.services import applications
+
+
+class LeaveBalanceListView(APIView):
+    permission_classes = [
+        HasModuleGrant("elm"),
+        HasPermission("elm.balance.view"),
+    ]
+
+    @extend_schema(responses=LeaveBalanceSerializer(many=True))
+    def get(self, request):
+        rows = LeaveBalance.objects.filter(employee_id=request.user.user_id)
+        return Response(LeaveBalanceSerializer(rows, many=True).data)
+
+
+class LeaveApplicationListCreateView(APIView):
+    permission_classes = [
+        HasModuleGrant("elm"),
+        HasPermission("elm.application.create"),
+    ]
+
+    @extend_schema(responses=LeaveApplicationSerializer(many=True))
+    def get(self, request):
+        rows = LeaveApplication.objects.filter(applicant_id=request.user.user_id)
+        return Response(LeaveApplicationSerializer(rows, many=True).data)
+
+    @extend_schema(
+        request=LeaveApplicationSerializer,
+        responses={201: LeaveApplicationSerializer},
+    )
+    def post(self, request):
+        serializer = LeaveApplicationSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        try:
+            application = applications.submit_leave_application(
+                applicant_id=request.user.user_id,
+                leave_type=serializer.validated_data["leave_type"],
+                start_date=serializer.validated_data["start_date"],
+                end_date=serializer.validated_data["end_date"],
+                reason=serializer.validated_data.get("reason", ""),
+                station_leave_details=serializer.validated_data.get("station_leave_details", ""),
+            )
+            return Response(LeaveApplicationSerializer(application).data, status=status.HTTP_201_CREATED)
+        except ValueError as exc:
+            return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class SubstituteResponseView(APIView):
+    permission_classes = [
+        HasModuleGrant("elm"),
+    ]
+
+    @extend_schema(request=SubstituteResponseSerializer, responses=SubstituteNominationSerializer)
+    def post(self, request, pk: int):
+        nomination = get_object_or_404(SubstituteNomination, pk=pk)
+        serializer = SubstituteResponseSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        try:
+            updated = applications.respond_substitute_nomination(
+                nomination=nomination,
+                accept=serializer.validated_data["accept"],
+                decline_reason=serializer.validated_data.get("decline_reason", ""),
+            )
+            return Response(SubstituteNominationSerializer(updated).data)
+        except ValueError as exc:
+            return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class LeaveApplicationReviewView(APIView):
+    permission_classes = [
+        HasModuleGrant("elm"),
+    ]
+
+    @extend_schema(request=ReviewApplicationSerializer, responses=LeaveApplicationSerializer)
+    def post(self, request, pk: int):
+        application = get_object_or_404(LeaveApplication, pk=pk)
+        serializer = ReviewApplicationSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        try:
+            reviewed = applications.review_leave_application(
+                application=application,
+                approve=serializer.validated_data["approve"],
+            )
+            return Response(LeaveApplicationSerializer(reviewed).data)
+        except ValueError as exc:
+            return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class LeaveApplicationWithdrawView(APIView):
+    permission_classes = [
+        HasModuleGrant("elm"),
+    ]
+
+    @extend_schema(responses=LeaveApplicationSerializer)
+    def post(self, request, pk: int):
+        application = get_object_or_404(LeaveApplication, pk=pk)
+        try:
+            withdrawn = applications.withdraw_application(application=application)
+            return Response(LeaveApplicationSerializer(withdrawn).data)
+        except ValueError as exc:
+            return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
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/domain/__init__.py b/modules/elm/domain/__init__.py
new file mode 100644
index 00000000..74d6c037
--- /dev/null
+++ b/modules/elm/domain/__init__.py
@@ -0,0 +1 @@
+"""Pure Python domain policy for ELM."""
diff --git a/modules/elm/domain/policy.py b/modules/elm/domain/policy.py
new file mode 100644
index 00000000..4ccc4ac5
--- /dev/null
+++ b/modules/elm/domain/policy.py
@@ -0,0 +1,92 @@
+"""Leave categories and annual entitlement rules for ELM."""
+
+from dataclasses import dataclass
+from datetime import date
+from enum import Enum
+from typing import Union
+
+
+class LeaveCode(Enum):
+    CL = "CL"
+    RH = "RH"
+    SCL = "SCL"
+    EL = "EL"
+    VL = "VL"
+    COL = "COL"
+
+
+@dataclass(frozen=True)
+class LeaveEntitlement:
+    code: LeaveCode
+    annual_days: float
+    carries_forward: bool
+    continuous_count: bool
+
+
+LEAVE_ENTITLEMENTS: dict[str, LeaveEntitlement] = {
+    "CL": LeaveEntitlement(
+        code=LeaveCode.CL,
+        annual_days=8.0,
+        carries_forward=False,
+        continuous_count=False,
+    ),
+    "RH": LeaveEntitlement(
+        code=LeaveCode.RH,
+        annual_days=2.0,
+        carries_forward=False,
+        continuous_count=False,
+    ),
+    "SCL": LeaveEntitlement(
+        code=LeaveCode.SCL,
+        annual_days=15.0,
+        carries_forward=False,
+        continuous_count=False,
+    ),
+    "EL": LeaveEntitlement(
+        code=LeaveCode.EL,
+        annual_days=30.0,
+        carries_forward=True,
+        continuous_count=True,
+    ),
+    "VL": LeaveEntitlement(
+        code=LeaveCode.VL,
+        annual_days=60.0,
+        carries_forward=False,
+        continuous_count=True,
+    ),
+    "COL": LeaveEntitlement(
+        code=LeaveCode.COL,
+        annual_days=20.0,
+        carries_forward=True,
+        continuous_count=True,
+    ),
+}
+
+
+def requested_days(start_date: date, end_date: date) -> int:
+    if end_date < start_date:
+        raise ValueError("End date cannot be earlier than start date.")
+    return (end_date - start_date).days + 1
+
+
+def validate_substitute_eligibility(applicant_id: int, substitute_id: int) -> None:
+    if applicant_id == substitute_id:
+        raise ValueError("Applicant cannot be their own substitute.")
+
+
+def check_date_overlap(start_a: date, end_a: date, start_b: date, end_b: date) -> bool:
+    return start_a <= end_b and start_b <= end_a
+
+
+def validate_balance_sufficiency(current_balance: Union[float, int], requested_days: Union[float, int]) -> None:
+    if requested_days > current_balance:
+        raise ValueError("Insufficient leave balance")
+
+
+def is_valid_transition(current_status: str, target_status: str) -> bool:
+    allowed_transitions = {
+        "AWAITING_SUBSTITUTE": ["AWAITING_APPROVAL", "WITHDRAWN"],
+        "AWAITING_APPROVAL": ["APPROVED", "REJECTED", "WITHDRAWN"],
+        "APPROVED": ["CANCELLED"],
+    }
+    return target_status in allowed_transitions.get(current_status, [])
diff --git a/modules/elm/migrations/0001_initial.py b/modules/elm/migrations/0001_initial.py
new file mode 100644
index 00000000..fa500cae
--- /dev/null
+++ b/modules/elm/migrations/0001_initial.py
@@ -0,0 +1,141 @@
+# Generated by Django 5.2.16
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="LeaveType",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "leave_type",
+                    models.CharField(
+                        choices=[
+                            ("CL", "Casual Leave"),
+                            ("RH", "Recreational Holiday"),
+                            ("SCL", "Special Casual Leave"),
+                            ("EL", "Earned Leave"),
+                            ("VL", "Vacation Leave"),
+                            ("COL", "Compensatory Off Leave"),
+                        ],
+                        max_length=3,
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "elm_leave_type",
+            },
+        ),
+        migrations.CreateModel(
+            name="LeaveApplication",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("applicant_id", models.IntegerField(db_index=True)),
+                ("start_date", models.DateField()),
+                ("end_date", models.DateField()),
+                ("station_leave_details", models.TextField(blank=True, default="")),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("PENDING", "Pending"),
+                            ("APPROVED", "Approved"),
+                            ("REJECTED", "Rejected"),
+                            ("WITHDRAWN", "Withdrawn"),
+                            ("CANCELLED", "Cancelled"),
+                        ],
+                        default="PENDING",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "leave_type",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="elm.leavetype",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "elm_leave_application",
+            },
+        ),
+        migrations.CreateModel(
+            name="LeaveBalance",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("employee_id", models.IntegerField(db_index=True)),
+                ("balance", models.IntegerField()),
+                (
+                    "leave_type",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="elm.leavetype",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "elm_leave_balance",
+            },
+        ),
+        migrations.CreateModel(
+            name="SubstituteNomination",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("substitute_id", models.IntegerField(db_index=True)),
+                ("start_date", models.DateField()),
+                ("end_date", models.DateField()),
+                ("reason", models.TextField(blank=True, default="")),
+                (
+                    "leave_application",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="elm.leaveapplication",
+                    ),
+                ),
+            ],
+            options={
+                "db_table": "elm_substitute_nomination",
+            },
+        ),
+    ]
diff --git a/modules/elm/migrations/0002_add_workflow_and_reason_fields.py b/modules/elm/migrations/0002_add_workflow_and_reason_fields.py
new file mode 100644
index 00000000..71bc95ad
--- /dev/null
+++ b/modules/elm/migrations/0002_add_workflow_and_reason_fields.py
@@ -0,0 +1,52 @@
+# Generated for ELM Phase 2 schema updates
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("elm", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="leaveapplication",
+            name="reason",
+            field=models.TextField(blank=True, default=""),
+        ),
+        migrations.AlterField(
+            model_name="leaveapplication",
+            name="status",
+            field=models.CharField(
+                choices=[
+                    ("AWAITING_SUBSTITUTE", "Awaiting Substitute Consent"),
+                    ("AWAITING_APPROVAL", "Awaiting Approval"),
+                    ("APPROVED", "Approved"),
+                    ("REJECTED", "Rejected"),
+                    ("WITHDRAWN", "Withdrawn"),
+                    ("CANCELLED", "Cancelled"),
+                ],
+                default="AWAITING_APPROVAL",
+                max_length=30,
+            ),
+        ),
+        migrations.AddField(
+            model_name="substitutenomination",
+            name="status",
+            field=models.CharField(
+                choices=[
+                    ("PENDING", "Pending Consent"),
+                    ("ACCEPTED", "Accepted"),
+                    ("DECLINED", "Declined"),
+                ],
+                default="PENDING",
+                max_length=20,
+            ),
+        ),
+        migrations.AddField(
+            model_name="substitutenomination",
+            name="decline_reason",
+            field=models.TextField(blank=True, default=""),
+        ),
+    ]
diff --git a/modules/elm/migrations/__init__.py b/modules/elm/migrations/__init__.py
new file mode 100644
index 00000000..b7c5ceee
--- /dev/null
+++ b/modules/elm/migrations/__init__.py
@@ -0,0 +1 @@
+"""ELM migrations."""
diff --git a/modules/elm/models.py b/modules/elm/models.py
new file mode 100644
index 00000000..10b354cb
--- /dev/null
+++ b/modules/elm/models.py
@@ -0,0 +1,79 @@
+from django.db import models
+
+
+class LeaveType(models.Model):
+    LEAVE_TYPE_CHOICES = [
+        ("CL", "Casual Leave"),
+        ("RH", "Recreational Holiday"),
+        ("SCL", "Special Casual Leave"),
+        ("EL", "Earned Leave"),
+        ("VL", "Vacation Leave"),
+        ("COL", "Compensatory Off Leave"),
+    ]
+    leave_type = models.CharField(max_length=3, choices=LEAVE_TYPE_CHOICES)
+
+    class Meta:
+        db_table = "elm_leave_type"
+
+    def __str__(self) -> str:
+        return self.leave_type
+
+
+class LeaveBalance(models.Model):
+    employee_id = models.IntegerField(db_index=True)
+    leave_type = models.ForeignKey(LeaveType, on_delete=models.CASCADE)
+    balance = models.IntegerField()
+
+    class Meta:
+        db_table = "elm_leave_balance"
+
+    def __str__(self) -> str:
+        return f"Employee {self.employee_id} - {self.leave_type.leave_type} Balance: {self.balance}"
+
+
+class LeaveApplication(models.Model):
+    STATUS_CHOICES = [
+        ("AWAITING_SUBSTITUTE", "Awaiting Substitute Consent"),
+        ("AWAITING_APPROVAL", "Awaiting Approval"),
+        ("APPROVED", "Approved"),
+        ("REJECTED", "Rejected"),
+        ("WITHDRAWN", "Withdrawn"),
+        ("CANCELLED", "Cancelled"),
+    ]
+    applicant_id = models.IntegerField(db_index=True)
+    leave_type = models.ForeignKey(LeaveType, on_delete=models.CASCADE)
+    start_date = models.DateField()
+    end_date = models.DateField()
+    station_leave_details = models.TextField(blank=True, default="")
+    reason = models.TextField(blank=True, default="")
+    status = models.CharField(max_length=30, choices=STATUS_CHOICES, default="AWAITING_APPROVAL")
+
+    class Meta:
+        db_table = "elm_leave_application"
+
+    def __str__(self) -> str:
+        return f"Applicant {self.applicant_id} - {self.leave_type.leave_type} Application"
+
+
+class SubstituteNomination(models.Model):
+    STATUS_CHOICES = [
+        ("PENDING", "Pending Consent"),
+        ("ACCEPTED", "Accepted"),
+        ("DECLINED", "Declined"),
+    ]
+    leave_application = models.ForeignKey(LeaveApplication, on_delete=models.CASCADE)
+    substitute_id = models.IntegerField(db_index=True)
+    start_date = models.DateField()
+    end_date = models.DateField()
+    reason = models.TextField(blank=True, default="")
+    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default="PENDING")
+    decline_reason = models.TextField(blank=True, default="")
+
+    class Meta:
+        db_table = "elm_substitute_nomination"
+
+    def __str__(self) -> str:
+        return (
+            f"Applicant {self.leave_application.applicant_id} - "
+            f"{self.leave_application.leave_type.leave_type} Substitute Nomination"
+        )
diff --git a/modules/elm/registry.py b/modules/elm/registry.py
new file mode 100644
index 00000000..f3df722b
--- /dev/null
+++ b/modules/elm/registry.py
@@ -0,0 +1,42 @@
+"""What the server tells the shell about the ELM module."""
+
+MODULE = {
+    "code": "elm",
+    "label": "Leave Management",
+    "icon": "CalendarBlank",
+    "base_path": "/elm",
+    "nav_section": "HR & Leave",
+    "sort_order": 20,
+    "status": "active",
+}
+
+NAV_ITEMS = [
+    {
+        "code": "elm.balance",
+        "label": "Leave Balance",
+        "icon": "ClipboardText",
+        "to": "/elm/balance",
+        "required_permission": "elm.balance.view",
+        "sort_order": 10,
+    },
+    {
+        "code": "elm.application",
+        "label": "Leave Application",
+        "icon": "FileText",
+        "to": "/elm/application",
+        "required_permission": "elm.application.create",
+        "sort_order": 20,
+    },
+]
+
+PERMISSIONS = [
+    ("elm.balance.view", "View leave balance"),
+    ("elm.application.create", "Submit a leave application"),
+]
+
+SYSTEM_PERMISSIONS = []
+
+ROLE_GRANTS = {
+    "faculty": ["elm.balance.view", "elm.application.create"],
+    "staff": ["elm.balance.view", "elm.application.create"],
+}
diff --git a/modules/elm/services/__init__.py b/modules/elm/services/__init__.py
new file mode 100644
index 00000000..fe5192fa
--- /dev/null
+++ b/modules/elm/services/__init__.py
@@ -0,0 +1 @@
+"""ELM services."""
diff --git a/modules/elm/services/applications.py b/modules/elm/services/applications.py
new file mode 100644
index 00000000..006a5c75
--- /dev/null
+++ b/modules/elm/services/applications.py
@@ -0,0 +1,153 @@
+"""Service functions for ELM leave applications and substitute nominations."""
+
+from datetime import date
+from django.db import transaction
+
+from modules.elm.domain.policy import (
+    check_date_overlap,
+    is_valid_transition,
+    requested_days,
+    validate_balance_sufficiency,
+    validate_substitute_eligibility,
+)
+from modules.elm.models import (
+    LeaveApplication,
+    LeaveBalance,
+    LeaveType,
+    SubstituteNomination,
+)
+
+
+@transaction.atomic
+def submit_leave_application(
+    *,
+    applicant_id: int,
+    leave_type: LeaveType,
+    start_date: date,
+    end_date: date,
+    reason: str = "",
+    station_leave_details: str = "",
+) -> LeaveApplication:
+    """Submit a leave application after validating balance sufficiency and absence of date overlaps."""
+    days = requested_days(start_date, end_date)
+    balance_obj = LeaveBalance.objects.filter(employee_id=applicant_id, leave_type=leave_type).first()
+    if balance_obj is None:
+        raise ValueError(f"No leave balance found for {leave_type.leave_type}.")
+
+    validate_balance_sufficiency(balance_obj.balance, days)
+
+    overlapping_apps = LeaveApplication.objects.filter(
+        applicant_id=applicant_id,
+        status__in=["AWAITING_SUBSTITUTE", "AWAITING_APPROVAL", "APPROVED"],
+    )
+
+    for app in overlapping_apps:
+        if check_date_overlap(app.start_date, app.end_date, start_date, end_date):
+            raise ValueError("Overlapping leave application exists.")
+
+    return LeaveApplication.objects.create(
+        applicant_id=applicant_id,
+        leave_type=leave_type,
+        start_date=start_date,
+        end_date=end_date,
+        station_leave_details=station_leave_details,
+        reason=reason,
+        status="AWAITING_APPROVAL",
+    )
+
+
+@transaction.atomic
+def nominate_substitute(
+    *,
+    leave_application: LeaveApplication,
+    substitute_id: int,
+    start_date: date,
+    end_date: date,
+    reason: str = "",
+) -> SubstituteNomination:
+    """Nominate an eligible substitute and set application status to AWAITING_SUBSTITUTE."""
+    validate_substitute_eligibility(leave_application.applicant_id, substitute_id)
+
+    nomination = SubstituteNomination.objects.create(
+        leave_application=leave_application,
+        substitute_id=substitute_id,
+        start_date=start_date,
+        end_date=end_date,
+        reason=reason,
+        status="PENDING",
+    )
+
+    leave_application.status = "AWAITING_SUBSTITUTE"
+    leave_application.save(update_fields=["status"])
+    return nomination
+
+
+@transaction.atomic
+def respond_substitute_nomination(
+    *,
+    nomination: SubstituteNomination,
+    accept: bool,
+    decline_reason: str = "",
+) -> SubstituteNomination:
+    """Handle substitute consent (accept moves application to AWAITING_APPROVAL; decline records reason)."""
+    if accept:
+        nomination.status = "ACCEPTED"
+        nomination.leave_application.status = "AWAITING_APPROVAL"
+        nomination.leave_application.save(update_fields=["status"])
+    else:
+        nomination.status = "DECLINED"
+        nomination.decline_reason = decline_reason
+
+    nomination.save()
+    return nomination
+
+
+@transaction.atomic
+def review_leave_application(
+    *,
+    application: LeaveApplication,
+    approve: bool,
+) -> LeaveApplication:
+    """Review leave application: approve atomically deducts leave days from LeaveBalance; reject updates status."""
+    if approve:
+        if not is_valid_transition(application.status, "APPROVED"):
+            raise ValueError("Invalid transition.")
+
+        balance_obj = (
+            LeaveBalance.objects.select_for_update()
+            .filter(employee_id=application.applicant_id, leave_type=application.leave_type)
+            .first()
+        )
+        if balance_obj is None:
+            raise ValueError("No leave balance record found for applicant.")
+
+        days = requested_days(application.start_date, application.end_date)
+        validate_balance_sufficiency(balance_obj.balance, days)
+        balance_obj.balance -= days
+        balance_obj.save(update_fields=["balance"])
+
+        application.status = "APPROVED"
+    else:
+        if not is_valid_transition(application.status, "REJECTED"):
+            raise ValueError("Invalid transition.")
+
+        application.status = "REJECTED"
+
+    application.save(update_fields=["status"])
+    return application
+
+
+@transaction.atomic
+def withdraw_application(*, application: LeaveApplication) -> LeaveApplication:
+    """Withdraw a pending leave application per BR-EL-022."""
+    if not is_valid_transition(application.status, "WITHDRAWN"):
+        raise ValueError("Invalid transition.")
+
+    application.status = "WITHDRAWN"
+    application.save(update_fields=["status"])
+    return application
+
+
+def get_employee_balances(*, employee_id: int):
+    """Retrieve all leave balance records for an employee."""
+    return LeaveBalance.objects.filter(employee_id=employee_id).select_related("leave_type")
diff --git a/modules/elm/tests/__init__.py b/modules/elm/tests/__init__.py
new file mode 100644
index 00000000..654b35dc
--- /dev/null
+++ b/modules/elm/tests/__init__.py
@@ -0,0 +1 @@
+"""Tests package for the ELM module."""
diff --git a/modules/elm/tests/test_policy.py b/modules/elm/tests/test_policy.py
new file mode 100644
index 00000000..1d404a49
--- /dev/null
+++ b/modules/elm/tests/test_policy.py
@@ -0,0 +1,70 @@
+from datetime import date
+import pytest
+
+from modules.elm.domain.policy import (
+    check_date_overlap,
+    is_valid_transition,
+    requested_days,
+    validate_balance_sufficiency,
+    validate_substitute_eligibility,
+)
+
+
+def test_validate_substitute_eligibility():
+    # Valid nomination: applicant is not substitute
+    assert validate_substitute_eligibility(1, 2) is None
+
+    # Invalid: applicant is self-nominated (BR-EL-014)
+    with pytest.raises(ValueError, match="Applicant cannot be their own substitute."):
+        validate_substitute_eligibility(1, 1)
+
+
+def test_check_date_overlap():
+    # Overlapping intervals: partial overlap (BR-EL-012)
+    assert check_date_overlap(date(2023, 10, 1), date(2023, 10, 5), date(2023, 10, 4), date(2023, 10, 8))
+
+    # Overlapping intervals: enclosed/nested
+    assert check_date_overlap(date(2023, 10, 1), date(2023, 10, 10), date(2023, 10, 3), date(2023, 10, 5))
+
+    # Non-overlapping intervals: adjacent
+    assert not check_date_overlap(date(2023, 10, 1), date(2023, 10, 5), date(2023, 10, 6), date(2023, 10, 10))
+
+    # Non-overlapping intervals: separate
+    assert not check_date_overlap(date(2023, 10, 1), date(2023, 10, 5), date(2023, 10, 15), date(2023, 10, 20))
+
+
+def test_validate_balance_sufficiency():
+    # Sufficient balance
+    validate_balance_sufficiency(10, 5)
+
+    # Exact balance
+    validate_balance_sufficiency(5, 5)
+
+    # Insufficient balance
+    with pytest.raises(ValueError, match="Insufficient leave balance"):
+        validate_balance_sufficiency(5, 10)
+
+
+def test_is_valid_transition():
+    # Allowed transitions
+    assert is_valid_transition("AWAITING_SUBSTITUTE", "AWAITING_APPROVAL")
+    assert is_valid_transition("AWAITING_SUBSTITUTE", "WITHDRAWN")
+    assert is_valid_transition("AWAITING_APPROVAL", "APPROVED")
+    assert is_valid_transition("AWAITING_APPROVAL", "REJECTED")
+    assert is_valid_transition("AWAITING_APPROVAL", "WITHDRAWN")
+    assert is_valid_transition("APPROVED", "CANCELLED")
+
+    # Disallowed transitions
+    assert not is_valid_transition("APPROVED", "REJECTED")
+    assert not is_valid_transition("REJECTED", "APPROVED")
+    assert not is_valid_transition("WITHDRAWN", "APPROVED")
+
+
+def test_requested_days():
+    # Correct day counts
+    assert requested_days(date(2023, 10, 1), date(2023, 10, 5)) == 5
+    assert requested_days(date(2023, 10, 1), date(2023, 10, 10)) == 10
+
+    # Inverted dates should raise ValueError
+    with pytest.raises(ValueError, match="End date cannot be earlier than start date."):
+        requested_days(date(2023, 10, 10), date(2023, 10, 1))
diff --git a/pilot/ELM_MODEL_1/prompts.md b/pilot/ELM_MODEL_1/prompts.md
new file mode 100644
index 00000000..13bd33c8
--- /dev/null
+++ b/pilot/ELM_MODEL_1/prompts.md
@@ -0,0 +1,39 @@
+# Trial 1 — Prompts & Interaction Log (Qwen2.5-Coder:7b + Continue)
+
+## Prompt 1 — Repository Inspection
+```text
+@codebase What existing modules are present under the modules/ directory in this repository, and what frameworks are used for the backend and frontend?
+```
+- **Observation**: In Agent mode, the model emitted `{"name": "ls", "arguments": {"dirPath": "modules/", "recursive": false}}`. Switched to Chat mode to inspect repository files directly.
+
+## Prompt 2 — Specification Ingestion
+```text
+@currentFile According to this specification document, what are the 6 leave categories supported by ELM, what are their annual entitlements, and what is the rule for unused VL at year end?
+```
+- **Observation**: When bound to the raw `.docx` file, the model reported seeing a ZIP directory listing (`word/document.xml`). After converting `01_ELM_Problem_Statement_v1.4_FINAL.docx` to `.md`, the model accurately identified `CL` (8 days), `RH` (2 days), `SCL` (15 days), `EL` (30 days), `VL` (60 days, 2:1 conversion to EL), and `COL` (20 days).
+
+## Prompt 3 — Backend URL Registration
+```text
+Add the route for the ELM module right below this line following the same pattern
+```
+- **Observation**: Model inserted `path("api/v1/elm", elm_module)` along with hallucinated imports `from core.api.router import router` and `from core.api.elm_module import elm_module`. Repaired in the mechanical integration pass to `path("api/v1/elm/", include("modules.elm.api.urls"))`.
+
+## Prompt 4 — Database Models Generation
+```text
+@file specs/01_ELM_Problem_Statement_v1.4_FINAL.md Based on these ELM specifications, generate the Django database models (models.py) for the ELM module.
+Include:
+1. LeaveBalance model for each employee tracking the 6 leave types (CL, RH, SCL, EL, VL, COL).
+2. LeaveApplication model with applicant, leave type, start/end date, station leave details, and statuses (PENDING, APPROVED, REJECTED, WITHDRAWN, CANCELLED).
+3. SubstituteNomination model for responsibility coverage.
+Link them appropriately to the Django User/Employee model.
+```
+- **Observation**: Generated `LeaveType`, `LeaveBalance`, `LeaveApplication`, and `SubstituteNomination` models. Mechanically adapted `ForeignKey(User)` to integer IDs (`employee_id`, `applicant_id`, `substitute_id`) to comply with Fusion's no-cross-module-FK architecture.
+
+## Prompt 5 — Frontend Module Generation
+```text
+@currentFile Using this placement routes.tsx as a structural reference, write the React frontend code for the new ELM module under client/src/modules/elm/.
+Include:
+1. routes.tsx with routes for leave balance and leave application.
+2. A React component with a form to apply for leave (CL, RH, SCL, EL, VL, COL).
+```
+- **Observation**: Generated `routes.tsx`, `LeaveBalance.tsx`, and `LeaveApplication.tsx` with form controls for all 6 leave types. Adapted `routes.tsx` export to `export const routes: RouteObject[]` in the mechanical pass.
diff --git a/pilot/ELM_MODEL_1/summary.md b/pilot/ELM_MODEL_1/summary.md
new file mode 100644
index 00000000..96fecf19
--- /dev/null
+++ b/pilot/ELM_MODEL_1/summary.md
@@ -0,0 +1,28 @@
+# Trial 1 — Local AI Coding Model Summary
+
+## 1. Environment & Model Configuration
+- **Machine**: Apple MacBook Air (M3, 8-Core CPU, 10-Core GPU, 16 GB Unified Memory)
+- **OS**: macOS (Darwin)
+- **Model**: `qwen2.5-coder:7b` (7.6B parameters)
+- **Quantization**: `Q4_K_M` (4.7 GB)
+- **Inference Runtime**: Ollama
+- **Coding Agent**: Continue VS Code Extension (`32K` context window)
+
+## 2. Step-by-Step Implementation Log
+| Step | Description | Outcome |
+|---|---|---|
+| Step 1 | Module foundation (`apps.py`, `registry.py`) | Created module metadata and navigation definitions |
+| Step 2 | Initial Django ORM models (`models.py`) | Generated `LeaveType`, `LeaveBalance`, `LeaveApplication`, `SubstituteNomination` |
+| Step 3 | Domain policy (`domain/policy.py`) | Defined pure-Python leave codes (`CL`, `RH`, `SCL`, `EL`, `VL`, `COL`) and annual entitlements |
+| Step 4 | Application services (`services/applications.py`) | Added leave submission, substitute nomination, and withdrawal services |
+| Step 5 | REST API (`api/serializers.py`, `views.py`, `urls.py`) | Created DRF views and serializers guarded by `HasModuleGrant` and `HasPermission` |
+| Step 6 | Module & route registration (`settings/base.py`, `urls.py`) | Initial model edit in `config/urls.py` introduced `core.api.elm_module` |
+| Step 7 | Database migration (`migrations/0001_initial.py`) | Initial schema migration for the 4 ELM tables |
+| Step 8 | Frontend wiring (`registry.ts`, `api.ts`, `routes.tsx`) | Registered `/elm` module and client route definitions |
+| Step 9 | Frontend pages (`LeaveBalance.tsx`, `LeaveApplication.tsx`) | Generated React components for viewing balance and submitting applications |
+| Step 10 | Mechanical integration pass | Replaced `ForeignKey(User)` with integer user IDs, adapted `RouteObject[]` export, and synced `registry/permissions.json` |
+
+## 3. Key Empirical Findings
+1. **Binary Specification Files**: Supplying raw `.docx` files directly caused the agent to read the underlying ZIP/XML structure (`word/document.xml`). Converting the specifications to Markdown (`.md`) resolved this and allowed accurate extraction of the 6 leave categories and status lifecycles.
+2. **Agent Tool-Calling vs. Chat Mode**: In Continue's Agent mode, `qwen2.5-coder:7b` frequently emitted raw JSON tool-call text (`{"name": "ls"}`, `{"name": "read_file"}`, `{"name": "single_find_and_replace"}`) instead of executing edits smoothly. Switching to Chat mode with `@currentFile` context produced clean code blocks that could be applied per file.
+3. **Mechanical Integration Needs**: The raw LLM output assumed standard Django `auth.User` foreign keys and default React Router `<Routes>` exports, requiring mechanical adjustments to match Fusion-Integrated's IAM `user_id` convention and `RouteObject[]` module manifest contract.
diff --git a/registry/permissions.json b/registry/permissions.json
index 213c8f24..38115942 100644
--- a/registry/permissions.json
+++ b/registry/permissions.json
@@ -34,6 +34,60 @@
       "scope_permissions": [],
       "system_permissions": []
     },
+    "elm": {
+      "grants": {
+        "faculty": [
+          "elm.application.create",
+          "elm.balance.view"
+        ],
+        "staff": [
+          "elm.application.create",
+          "elm.balance.view"
+        ]
+      },
+      "module_grants": [
+        "faculty",
+        "staff"
+      ],
+      "nav": {
+        "base_path": "/elm",
+        "icon": "CalendarBlank",
+        "items": [
+          {
+            "code": "elm.balance",
+            "icon": "ClipboardText",
+            "label": "Leave Balance",
+            "required_permission": "elm.balance.view",
+            "sort_order": 10,
+            "to": "/elm/balance"
+          },
+          {
+            "code": "elm.application",
+            "icon": "FileText",
+            "label": "Leave Application",
+            "required_permission": "elm.application.create",
+            "sort_order": 20,
+            "to": "/elm/application"
+          }
+        ],
+        "label": "Leave Management",
+        "nav_section": "HR & Leave",
+        "sort_order": 20,
+        "status": "active"
+      },
+      "permissions": [
+        {
+          "code": "elm.balance.view",
+          "label": "View leave balance"
+        },
+        {
+          "code": "elm.application.create",
+          "label": "Submit a leave application"
+        }
+      ],
+      "scope_permissions": [],
+      "system_permissions": []
+    },
     "placement_cell": {
       "grants": {
         "Dean Academic": [