diff --git a/VueApp/src/ClinicalScheduler/__tests__/audit-log-page-access.test.ts b/VueApp/src/ClinicalScheduler/__tests__/audit-log-page-access.test.ts
new file mode 100644
index 000000000..9d578cbdd
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/__tests__/audit-log-page-access.test.ts
@@ -0,0 +1,97 @@
+import { usePermissionsStore } from "../stores/permissions"
+import { AuditLogService } from "../services/audit-log-service"
+import { RotationService } from "../services/rotation-service"
+import { PageDataService } from "../services/page-data-service"
+import AuditLogPage from "../pages/AuditLogPage.vue"
+import {
+    setupTest,
+    createTestWrapper,
+    waitForAsync,
+    createMockPermissionsStore,
+    createMockUserPermissions,
+} from "./test-utils"
+import type { UserPermissions } from "../types"
+
+type MockPermissionsStore = Omit<ReturnType<typeof createMockPermissionsStore>, "userPermissions"> & {
+    hasManagePermission?: boolean
+    userPermissions: UserPermissions | null
+}
+
+// Mock the permissions store and the services the page calls
+vi.mock("../stores/permissions")
+vi.mock("../services/audit-log-service")
+vi.mock("../services/rotation-service")
+vi.mock("../services/page-data-service")
+
+// Stub child components that hit the network or rely on named routes
+vi.mock("../components/AccessDeniedCard.vue", () => ({
+    default: {
+        name: "AccessDeniedCard",
+        props: ["message", "subtitle"],
+        template: '<div class="no-access-card"><div>Access Denied</div><div>{{message}}</div></div>',
+    },
+}))
+vi.mock("../components/SchedulerNavigation.vue", () => ({
+    default: { name: "SchedulerNavigation", template: "<div class='scheduler-nav'></div>" },
+}))
+
+describe("auditLogPage - Access Control", () => {
+    let mockPermissionsStore: MockPermissionsStore = {} as never
+    let router: any = {}
+
+    beforeEach(() => {
+        const { router: testRouter, mockStore } = setupTest()
+        router = testRouter
+        mockPermissionsStore = mockStore
+        vi.mocked(usePermissionsStore).mockReturnValue(mockPermissionsStore as any)
+        vi.mocked(AuditLogService.getAuditLog).mockResolvedValue({ result: [], success: true, errors: [] })
+        vi.mocked(AuditLogService.getModifiers).mockResolvedValue({ result: [], success: true, errors: [] })
+        vi.mocked(AuditLogService.getPersons).mockResolvedValue({ result: [], success: true, errors: [] })
+        vi.mocked(AuditLogService.getTerms).mockResolvedValue({ result: [], success: true, errors: [] })
+        vi.mocked(RotationService.getRotations).mockResolvedValue({ result: [], success: true, errors: [] })
+        vi.mocked(PageDataService.getPageData).mockResolvedValue({ currentGradYear: 2026, availableGradYears: [2026] })
+    })
+
+    it("shows access denied when user lacks the manage permission", () => {
+        mockPermissionsStore.hasManagePermission = false
+        mockPermissionsStore.userPermissions = createMockUserPermissions()
+
+        const wrapper = createTestWrapper({ component: AuditLogPage, router })
+
+        expect(wrapper.find(".no-access-card").exists()).toBeTruthy()
+        // The results table (and its "Modified By" column) only renders for managers.
+        expect(wrapper.text()).not.toContain("Modified By")
+    })
+
+    it("shows the audit trail and loads filter options for managers", async () => {
+        mockPermissionsStore.hasManagePermission = true
+        mockPermissionsStore.userPermissions = createMockUserPermissions({
+            permissions: {
+                hasAdminPermission: false,
+                hasManagePermission: true,
+                hasEditClnSchedulesPermission: false,
+                hasEditOwnSchedulePermission: false,
+                servicePermissions: {},
+                editableServiceCount: 0,
+            },
+        })
+
+        const wrapper = createTestWrapper({ component: AuditLogPage, router })
+        await waitForAsync()
+
+        expect(wrapper.find(".no-access-card").exists()).toBeFalsy()
+        expect(wrapper.text()).toContain("Modified By")
+        expect(RotationService.getRotations).toHaveBeenCalledWith()
+        expect(AuditLogService.getModifiers).toHaveBeenCalledWith()
+    })
+
+    it("initializes the permissions store on mount when not yet loaded", async () => {
+        mockPermissionsStore.hasManagePermission = true
+        mockPermissionsStore.userPermissions = null
+
+        createTestWrapper({ component: AuditLogPage, router })
+        await waitForAsync()
+
+        expect(mockPermissionsStore.initialize).toHaveBeenCalledWith()
+    })
+})
diff --git a/VueApp/src/ClinicalScheduler/__tests__/audit-log-results-table.test.ts b/VueApp/src/ClinicalScheduler/__tests__/audit-log-results-table.test.ts
new file mode 100644
index 000000000..fcfb4aa82
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/__tests__/audit-log-results-table.test.ts
@@ -0,0 +1,66 @@
+import AuditLogResultsTable from "../components/AuditLogResultsTable.vue"
+import StatusBadge from "@/components/StatusBadge.vue"
+import { createTestWrapper } from "./test-utils"
+import type { AuditLogEntry } from "../types/audit-types"
+
+function makeEntry(overrides: Partial<AuditLogEntry> = {}): AuditLogEntry {
+    return {
+        scheduleAuditId: 1,
+        area: "Clinicians",
+        mothraId: "abc123",
+        personName: "Dr. Example",
+        action: "Added to rotation",
+        rotationId: 5,
+        rotationName: "Cardiology",
+        weekId: 10,
+        weekNum: 3,
+        weekStart: "2026-01-05",
+        term: "Spring 2026",
+        modifiedBy: "mgr456",
+        modifiedByName: "Manager Person",
+        timeStamp: "2026-01-06T08:30:00",
+        ...overrides,
+    }
+}
+
+function mountTable(entries: AuditLogEntry[], isLoading = false) {
+    return createTestWrapper({
+        component: AuditLogResultsTable,
+        props: { entries, isLoading },
+    })
+}
+
+describe("auditLogResultsTable", () => {
+    it("renders audit entries", () => {
+        expect.assertions(4)
+
+        const wrapper = mountTable([makeEntry()])
+
+        expect(wrapper.text()).toContain("Dr. Example")
+        expect(wrapper.text()).toContain("Added to rotation")
+        expect(wrapper.text()).toContain("Cardiology")
+        expect(wrapper.text()).toContain("Manager Person")
+    })
+
+    it("renders one row per entry", () => {
+        expect.assertions(3)
+
+        const wrapper = mountTable([
+            makeEntry(),
+            makeEntry({ scheduleAuditId: 2, personName: "Dr. Second", action: "Removed from rotation" }),
+        ])
+
+        // One action badge renders per entry across every responsive table variant.
+        expect(wrapper.findAllComponents(StatusBadge)).toHaveLength(2)
+        expect(wrapper.text()).toContain("Dr. Second")
+        expect(wrapper.text()).toContain("Removed from rotation")
+    })
+
+    it("marks the table as loading", () => {
+        expect.assertions(1)
+
+        const wrapper = mountTable([], true)
+
+        expect(wrapper.findComponent({ name: "QTable" }).props("loading")).toBeTruthy()
+    })
+})
diff --git a/VueApp/src/ClinicalScheduler/__tests__/week-history-content.test.ts b/VueApp/src/ClinicalScheduler/__tests__/week-history-content.test.ts
new file mode 100644
index 000000000..096c23ca0
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/__tests__/week-history-content.test.ts
@@ -0,0 +1,153 @@
+import WeekHistoryContent from "../components/WeekHistoryContent.vue"
+import { createTestWrapper } from "./test-utils"
+import { useDateFunctions } from "@/composables/DateFunctions"
+import type { AuditLogEntry } from "../types/audit-types"
+
+function makeEntry(overrides: Partial<AuditLogEntry> = {}): AuditLogEntry {
+    return {
+        scheduleAuditId: 1,
+        area: "Clinicians",
+        mothraId: "abc123",
+        personName: "Dr. Example",
+        action: "Added to rotation",
+        rotationId: 5,
+        rotationName: "Cardiology",
+        weekId: 10,
+        weekNum: 3,
+        weekStart: "2026-01-05",
+        term: "Spring 2026",
+        modifiedBy: "mgr456",
+        modifiedByName: "Manager Person",
+        timeStamp: "2026-01-06T08:30:00",
+        ...overrides,
+    }
+}
+
+function mountContent(props: Record<string, unknown> = {}) {
+    return createTestWrapper({
+        component: WeekHistoryContent,
+        props: {
+            titleId: "week-history-title-test",
+            viewMode: "rotation",
+            weekNumber: 3,
+            weekDateStart: "2026-01-05",
+            contextLabel: "Cardiology",
+            entries: [],
+            isLoading: false,
+            error: null,
+            ...props,
+        },
+    })
+}
+
+describe("weekHistoryContent", () => {
+    it("shows skeleton rows while loading", () => {
+        expect.assertions(2)
+
+        const wrapper = mountContent({ isLoading: true })
+
+        expect(wrapper.findAll(".week-history__skeleton-row")).toHaveLength(3)
+        expect(wrapper.attributes("aria-busy")).toBe("true")
+    })
+
+    it("shows the error state and emits retry", async () => {
+        expect.assertions(2)
+
+        const wrapper = mountContent({ error: "Failed to load the audit trail" })
+
+        expect(wrapper.find("[role='alert']").text()).toContain("Failed to load the audit trail")
+
+        await wrapper.find("[role='alert'] button").trigger("click")
+
+        expect(wrapper.emitted("retry")).toHaveLength(1)
+    })
+
+    it("shows an empty state when there are no entries", () => {
+        expect.assertions(1)
+
+        const wrapper = mountContent({ entries: [] })
+
+        expect(wrapper.text()).toContain("No audit entries for this week.")
+    })
+
+    it("lists entries with the clinician as subject in rotation view", () => {
+        expect.assertions(3)
+
+        const wrapper = mountContent({ viewMode: "rotation", entries: [makeEntry()] })
+
+        expect(wrapper.find(".week-history__subject").text()).toBe("Dr. Example")
+        expect(wrapper.text()).toContain("Added to rotation")
+        expect(wrapper.text()).toContain("Manager Person")
+    })
+
+    it("lists entries with the rotation as subject in clinician view", () => {
+        expect.assertions(1)
+
+        const wrapper = mountContent({ viewMode: "clinician", entries: [makeEntry()] })
+
+        expect(wrapper.find(".week-history__subject").text()).toBe("Cardiology")
+    })
+
+    it("labels the week navigation with the current week and date", () => {
+        expect.assertions(2)
+
+        const { formatDate } = useDateFunctions()
+        const wrapper = mountContent({ weekNumber: 3, weekDateStart: "2026-01-05" })
+
+        const label = wrapper.find(".week-history__nav-label").text()
+        expect(label).toContain("Week 3")
+        expect(label).toContain(formatDate("2026-01-05"))
+    })
+
+    it("emits prev/next when the enabled nav controls are clicked", async () => {
+        expect.assertions(2)
+
+        const wrapper = mountContent({ canPrev: true, canNext: true })
+
+        await wrapper.find("[aria-label='Previous week']").trigger("click")
+        await wrapper.find("[aria-label='Next week']").trigger("click")
+
+        expect(wrapper.emitted("prev")).toHaveLength(1)
+        expect(wrapper.emitted("next")).toHaveLength(1)
+    })
+
+    it("disables nav controls at the schedule ends", () => {
+        expect.assertions(2)
+
+        const wrapper = mountContent({ canPrev: false, canNext: false })
+
+        expect(wrapper.find("[aria-label='Previous week']").classes()).toContain("disabled")
+        expect(wrapper.find("[aria-label='Next week']").classes()).toContain("disabled")
+    })
+
+    it("shows skeleton rows only on the initial load (no entries yet)", () => {
+        expect.assertions(2)
+
+        const wrapper = mountContent({ isLoading: true, entries: [] })
+
+        expect(wrapper.findAll(".week-history__skeleton-row")).toHaveLength(3)
+        expect(wrapper.find(".week-history__list").exists()).toBeFalsy()
+    })
+
+    it("keeps the current rows (dimmed) instead of a skeleton while paging weeks", () => {
+        expect.assertions(3)
+
+        // Entries already present while loading = paging to another week
+        const wrapper = mountContent({ isLoading: true, entries: [makeEntry()] })
+
+        expect(wrapper.findAll(".week-history__skeleton-row")).toHaveLength(0)
+        const list = wrapper.find(".week-history__list")
+        expect(list.exists()).toBeTruthy()
+        expect(list.classes()).toContain("week-history__list--loading")
+    })
+
+    it("shows the loading progress bar only while a fetch is in flight", () => {
+        expect.assertions(2)
+
+        const loading = mountContent({ isLoading: true, entries: [makeEntry()] })
+        const idle = mountContent({ isLoading: false, entries: [makeEntry()] })
+
+        expect(loading.find(".week-history__progress").exists()).toBeTruthy()
+        expect(idle.find(".week-history__progress").exists()).toBeFalsy()
+    })
+})
diff --git a/VueApp/src/ClinicalScheduler/components/AuditLogResultsTable.vue b/VueApp/src/ClinicalScheduler/components/AuditLogResultsTable.vue
new file mode 100644
index 000000000..54e1c6409
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/components/AuditLogResultsTable.vue
@@ -0,0 +1,227 @@
+<template>
+    <!-- Desktop (lg+): full table -->
+    <q-table
+        v-if="$q.screen.gt.md"
+        row-key="scheduleAuditId"
+        :rows="entries"
+        :columns="columns"
+        :loading="isLoading"
+        v-model:pagination="pagination"
+        :rows-per-page-options="[10, 25, 50, 100]"
+        binary-state-sort
+        dense
+        flat
+        bordered
+    >
+        <template #body-cell-timeStamp="props">
+            <q-td :props="props">
+                {{ formatDateTime(props.row.timeStamp, { dateStyle: "short", timeStyle: "short" }) }}
+            </q-td>
+        </template>
+        <template #body-cell-action="props">
+            <q-td :props="props">
+                <StatusBadge :color="getAuditActionColor(props.row.action)">
+                    {{ props.row.action }}
+                </StatusBadge>
+            </q-td>
+        </template>
+        <template #no-data>
+            <div class="full-width text-center q-pa-md text-grey-7">No audit entries found matching this filter.</div>
+        </template>
+    </q-table>
+
+    <!-- Tablet (sm/md): main columns + a stacked Action/Week/Area row -->
+    <q-table
+        v-else-if="$q.screen.gt.xs"
+        row-key="scheduleAuditId"
+        :rows="entries"
+        :columns="tabletColumns"
+        :loading="isLoading"
+        v-model:pagination="pagination"
+        :rows-per-page-options="[10, 25, 50, 100]"
+        binary-state-sort
+        dense
+        flat
+        bordered
+    >
+        <template #body="props">
+            <q-tr :props="props">
+                <q-td
+                    key="timeStamp"
+                    :props="props"
+                >
+                    {{ formatDateTime(props.row.timeStamp, { dateStyle: "short", timeStyle: "short" }) }}
+                </q-td>
+                <q-td
+                    key="modifiedByName"
+                    :props="props"
+                >
+                    {{ props.row.modifiedByName }}
+                </q-td>
+                <q-td
+                    key="personName"
+                    :props="props"
+                >
+                    {{ props.row.personName }}
+                </q-td>
+                <q-td
+                    key="rotationName"
+                    :props="props"
+                >
+                    {{ props.row.rotationName }}
+                </q-td>
+                <q-td
+                    key="term"
+                    :props="props"
+                >
+                    {{ props.row.term }}
+                </q-td>
+            </q-tr>
+            <q-tr :props="props">
+                <q-td
+                    :colspan="tabletColumns.length"
+                    class="bg-grey-1 q-py-xs"
+                >
+                    <div class="row items-center q-gutter-sm">
+                        <StatusBadge :color="getAuditActionColor(props.row.action)">
+                            {{ props.row.action }}
+                        </StatusBadge>
+                        <span
+                            v-if="formatWeekCell(props.row.weekNum, props.row.weekStart)"
+                            class="text-caption text-grey-8"
+                        >
+                            {{ formatWeekCell(props.row.weekNum, props.row.weekStart) }}
+                        </span>
+                        <span class="text-caption text-grey-7">{{ props.row.area }}</span>
+                    </div>
+                </q-td>
+            </q-tr>
+        </template>
+    </q-table>
+
+    <!-- Mobile (xs): card layout -->
+    <q-table
+        v-else
+        row-key="scheduleAuditId"
+        :rows="entries"
+        :columns="columns"
+        :loading="isLoading"
+        v-model:pagination="pagination"
+        :rows-per-page-options="[10, 25, 50, 100]"
+        grid
+        binary-state-sort
+        dense
+        flat
+        bordered
+    >
+        <template #item="props">
+            <div class="q-pa-xs col-12">
+                <q-card
+                    flat
+                    bordered
+                >
+                    <q-card-section class="q-pa-sm">
+                        <div class="row items-center q-mb-xs">
+                            <StatusBadge
+                                :color="getAuditActionColor(props.row.action)"
+                                class="q-mr-sm"
+                            >
+                                {{ props.row.action }}
+                            </StatusBadge>
+                            <span class="text-caption text-grey-7">
+                                {{
+                                    formatDateTime(props.row.timeStamp, {
+                                        dateStyle: "short",
+                                        timeStyle: "short",
+                                    })
+                                }}
+                            </span>
+                        </div>
+                        <div
+                            v-if="props.row.personName"
+                            class="text-subtitle2"
+                        >
+                            {{ props.row.personName }}
+                        </div>
+                        <div
+                            v-if="formatRotationTerm(props.row)"
+                            class="text-caption text-grey-8"
+                        >
+                            {{ formatRotationTerm(props.row) }}
+                        </div>
+                        <div
+                            v-if="formatWeekCell(props.row.weekNum, props.row.weekStart)"
+                            class="text-caption text-grey-8"
+                        >
+                            {{ formatWeekCell(props.row.weekNum, props.row.weekStart) }}
+                        </div>
+                        <div class="text-caption q-mt-xs">
+                            <span class="text-grey-7">by</span> {{ props.row.modifiedByName }}
+                            <span class="text-grey-7"> &middot; </span>{{ props.row.area }}
+                        </div>
+                    </q-card-section>
+                </q-card>
+            </div>
+        </template>
+    </q-table>
+</template>
+
+<script setup lang="ts">
+import { ref } from "vue"
+import type { Ref } from "vue"
+import { useQuasar } from "quasar"
+import type { QTableColumn, QTableProps } from "quasar"
+import { useDateFunctions } from "@/composables/DateFunctions"
+import StatusBadge from "@/components/StatusBadge.vue"
+import { getAuditActionColor } from "../utils/audit-actions"
+import type { AuditLogEntry } from "../types/audit-types"
+
+defineProps<{
+    entries: AuditLogEntry[]
+    isLoading: boolean
+}>()
+
+const $q = useQuasar()
+const { formatDate, formatDateTime } = useDateFunctions()
+
+const pagination = ref({
+    sortBy: "timeStamp",
+    descending: true,
+    rowsPerPage: 25,
+}) as Ref<QTableProps["pagination"]>
+
+function formatWeekCell(weekNum: number, weekStart: string | null): string {
+    const date = weekStart ? formatDate(weekStart) : ""
+    if (weekNum) {
+        return date ? `Wk ${weekNum} · ${date}` : `Wk ${weekNum}`
+    }
+    return date
+}
+
+function formatRotationTerm(entry: AuditLogEntry): string {
+    return [entry.rotationName, entry.term].filter(Boolean).join(" • ")
+}
+
+const columns: QTableColumn<AuditLogEntry>[] = [
+    { name: "timeStamp", label: "Date", field: "timeStamp", align: "left", sortable: true },
+    { name: "modifiedByName", label: "Modified By", field: "modifiedByName", align: "left", sortable: true },
+    { name: "personName", label: "Person", field: "personName", align: "left", sortable: true },
+    { name: "area", label: "Area", field: "area", align: "left", sortable: true },
+    { name: "rotationName", label: "Rotation", field: "rotationName", align: "left", sortable: true },
+    { name: "term", label: "Term", field: "term", align: "left", sortable: true },
+    {
+        name: "week",
+        label: "Week",
+        field: "weekNum",
+        align: "left",
+        sortable: true,
+        format: (val: number, row: AuditLogEntry) => formatWeekCell(val, row.weekStart),
+    },
+    { name: "action", label: "Action", field: "action", align: "left", sortable: true },
+]
+
+// Tablet (sm/md): a reduced column set; Action/Week/Area move to a stacked detail row.
+const tabletColumns = columns.filter((column) =>
+    ["timeStamp", "modifiedByName", "personName", "rotationName", "term"].includes(column.name),
+)
+</script>
diff --git a/VueApp/src/ClinicalScheduler/components/ScheduleLegend.vue b/VueApp/src/ClinicalScheduler/components/ScheduleLegend.vue
index 5ca82545a..0756daee6 100644
--- a/VueApp/src/ClinicalScheduler/components/ScheduleLegend.vue
+++ b/VueApp/src/ClinicalScheduler/components/ScheduleLegend.vue
@@ -97,6 +97,20 @@
                         />
                         <span class="legend-text">Needs primary evaluator</span>
                     </div>
+
+                    <div
+                        v-if="showHistory"
+                        class="legend-item"
+                    >
+                        <q-icon
+                            name="history"
+                            size="xs"
+                            color="grey-7"
+                            class="legend-icon"
+                            aria-hidden="true"
+                        />
+                        <span class="legend-text">View audit trail</span>
+                    </div>
                 </div>
             </q-card-section>
         </q-card>
@@ -110,12 +124,14 @@ import { useQuasar } from "quasar"
 interface Props {
     showWarning?: boolean
     showBulkGuide?: boolean
+    showHistory?: boolean
     itemType?: "rotation" | "clinician"
 }
 
 withDefaults(defineProps<Props>(), {
     showWarning: false,
     showBulkGuide: false,
+    showHistory: false,
     itemType: "rotation",
 })
 
diff --git a/VueApp/src/ClinicalScheduler/components/ScheduleView.vue b/VueApp/src/ClinicalScheduler/components/ScheduleView.vue
index 849c7e7f9..65fcd462b 100644
--- a/VueApp/src/ClinicalScheduler/components/ScheduleView.vue
+++ b/VueApp/src/ClinicalScheduler/components/ScheduleView.vue
@@ -41,7 +41,7 @@
                 class="q-mb-md"
             >
                 <!-- Week grid -->
-                <div class="row q-gutter-md q-mb-lg q-pa-md">
+                <div class="row q-gutter-md q-mb-lg q-pa-md schedule-week-grid">
                     <WeekCell
                         v-for="week in semester.weeks"
                         :key="week.weekId"
@@ -55,10 +55,12 @@
                         :is-loading="loadingWeekId === week.weekId"
                         :selectable="enableWeekSelection"
                         :selected="isWeekSelected(week.weekId)"
+                        :can-view-history="canShowHistory"
                         @click="onWeekClick"
                         @shift-click="onWeekShiftClick"
                         @remove-assignment="handleRemoveAssignment"
                         @toggle-primary="handleTogglePrimary"
+                        @view-history="openWeekHistory"
                     />
                 </div>
             </q-expansion-item>
@@ -69,8 +71,20 @@
             v-if="showLegend && schedulesBySemester && schedulesBySemester.length > 0"
             :show-warning="showWarningInLegend"
             :show-bulk-guide="enableWeekSelection"
+            :show-history="canViewHistory"
             :item-type="viewMode === 'rotation' ? 'clinician' : 'rotation'"
         />
+
+        <!-- One shared dialog; the clicked week sets where it opens, then it pages the schedule.
+             Always mounted (it self-guards on a null context) to keep the template simpler. -->
+        <WeekHistoryDialog
+            v-model="historyOpen"
+            :view-mode="viewMode"
+            :context-id="historyContextId"
+            :context-label="historyContextLabel"
+            :weeks="allWeeks"
+            :start-week-id="historyStartWeekId"
+        />
     </div>
 </template>
 
@@ -78,6 +92,7 @@
 import { computed, ref } from "vue"
 import { useKeyModifier, useEventListener } from "@vueuse/core"
 import WeekCell from "./WeekCell.vue"
+import WeekHistoryDialog from "./WeekHistoryDialog.vue"
 import ScheduleLegend from "./ScheduleLegend.vue"
 import StatusBanner from "@/components/StatusBanner.vue"
 import type { WeekItem, ScheduleAssignment, ScheduleSemester, ViewMode } from "./schedule-view-types"
@@ -110,6 +125,11 @@ interface Props {
     // Selection mode
     enableWeekSelection?: boolean
 
+    // Inline per-week history (manager-only)
+    canViewHistory?: boolean
+    historyContextId?: number | string | null
+    historyContextLabel?: string
+
     // Custom messages
     noDataMessage?: string
     emptyStateMessage?: string
@@ -141,6 +161,9 @@ const props = withDefaults(defineProps<Props>(), {
     showPrimaryToggle: true,
     requiresPrimaryForWeek: false,
     enableWeekSelection: false,
+    canViewHistory: false,
+    historyContextId: null,
+    historyContextLabel: "",
     noDataMessage: "No schedule data available",
     emptyStateMessage: "Click to add assignment",
     readOnlyEmptyMessage: "No assignments",
@@ -179,6 +202,22 @@ const allWeeks = computed(() => {
     return weeks
 })
 
+// Gate once here (context is schedule-level), then feed the flat week list to one shared dialog.
+const canShowHistory = computed(
+    () =>
+        props.canViewHistory &&
+        props.historyContextId !== null &&
+        props.historyContextId !== undefined &&
+        props.historyContextId !== "",
+)
+const historyOpen = ref(false)
+const historyStartWeekId = ref<number | null>(null)
+
+function openWeekHistory(week: WeekItem) {
+    historyStartWeekId.value = week.weekId
+    historyOpen.value = true
+}
+
 // Check if a week is selected
 function isWeekSelected(weekId: number): boolean {
     return selectedWeekIds.value.has(weekId)
@@ -350,4 +389,12 @@ defineExpose({
 .cursor-pointer {
     cursor: pointer;
 }
+
+/* Mobile single column: q-gutter-md adds only a left margin, which left-pins the card */
+@media (max-width: 599.98px) {
+    .schedule-week-grid,
+    .schedule-week-grid > * {
+        margin-left: 0;
+    }
+}
 </style>
diff --git a/VueApp/src/ClinicalScheduler/components/SchedulerNavigation.vue b/VueApp/src/ClinicalScheduler/components/SchedulerNavigation.vue
index 1e03023d1..aca8155b6 100644
--- a/VueApp/src/ClinicalScheduler/components/SchedulerNavigation.vue
+++ b/VueApp/src/ClinicalScheduler/components/SchedulerNavigation.vue
@@ -35,6 +35,14 @@
             :id="`clinician-tab`"
             role="tab"
         />
+        <q-route-tab
+            v-if="permissionsStore.hasManagePermission"
+            name="audit"
+            label="Audit Trail"
+            :to="{ name: 'AuditLog' }"
+            :id="`audit-tab`"
+            role="tab"
+        />
     </q-tabs>
 </template>
 
diff --git a/VueApp/src/ClinicalScheduler/components/WeekCell.vue b/VueApp/src/ClinicalScheduler/components/WeekCell.vue
index e20190f61..5f8ca424c 100644
--- a/VueApp/src/ClinicalScheduler/components/WeekCell.vue
+++ b/VueApp/src/ClinicalScheduler/components/WeekCell.vue
@@ -28,6 +28,11 @@
                     title="Primary evaluator required for this week"
                 />
                 <span>Week {{ week.weekNumber }} ({{ formatDate(week.dateStart) }})</span>
+                <WeekHistoryButton
+                    v-if="canViewHistory"
+                    :week-number="week.weekNumber"
+                    @view-history="$emit('view-history', week)"
+                />
             </div>
 
             <!-- Assignments -->
@@ -162,6 +167,7 @@ import { useTimeoutFn } from "@vueuse/core"
 import { inflect } from "inflection"
 import { useDateFunctions } from "@/composables/DateFunctions"
 import { ANIMATIONS } from "../constants/app-constants"
+import WeekHistoryButton from "./WeekHistoryButton.vue"
 
 const { formatDate } = useDateFunctions()
 
@@ -201,6 +207,8 @@ interface Props {
     isLoading?: boolean
     selectable?: boolean
     selected?: boolean
+    // Manager-only audit-trail trigger; ScheduleView owns the dialog and its context.
+    canViewHistory?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -213,6 +221,7 @@ const props = withDefaults(defineProps<Props>(), {
     isLoading: false,
     selectable: false,
     selected: false,
+    canViewHistory: false,
 })
 
 const emit = defineEmits<{
@@ -220,6 +229,7 @@ const emit = defineEmits<{
     "remove-assignment": [assignmentId: number, displayName: string, isPrimary?: boolean]
     "toggle-primary": [assignmentId: number, isPrimary: boolean, displayName: string]
     "shift-click": [week: Props["week"]]
+    "view-history": [week: Props["week"]]
 }>()
 
 // Computed properties
@@ -269,7 +279,20 @@ const {
 } = useTimeoutFn(() => emit("click", props.week), 500, { immediate: false })
 
 // Methods
+
+// Touch taps don't bubble through a child control's @click.stop, so ignore any
+// tap/click that starts on an in-cell control (it must not also schedule the week).
+function originatesOnControl(event?: Event): boolean {
+    if (!event) return false
+    // composedPath covers text-node targets (some touch taps) that event.target misses
+    return event
+        .composedPath()
+        .some((node) => node instanceof Element && node.matches("button, [role='button'], a, input, select, textarea"))
+}
+
 function handleClick(event?: MouseEvent) {
+    if (originatesOnControl(event)) return
+
     // Don't handle click during selection mode if just selecting
     if (props.selectable && !props.canEdit) {
         if (event?.shiftKey) {
@@ -296,7 +319,8 @@ function handleClick(event?: MouseEvent) {
 }
 
 // Touch event handlers for mobile long-press
-function handleTouchStart() {
+function handleTouchStart(event: TouchEvent) {
+    if (originatesOnControl(event)) return
     if (props.selectable && !props.isPastYear) {
         startLongPress()
     }
@@ -360,6 +384,14 @@ const cardClasses = computed(() => {
     min-width: 200px;
 }
 
+/* Mobile single column: fill the width instead of capping at 280px */
+@media (width <= 599.98px) {
+    .week-schedule-card {
+        max-width: none;
+        min-width: 0;
+    }
+}
+
 .week-schedule-card .q-card {
     height: 100%;
 }
diff --git a/VueApp/src/ClinicalScheduler/components/WeekHistoryBody.vue b/VueApp/src/ClinicalScheduler/components/WeekHistoryBody.vue
new file mode 100644
index 000000000..3fe54b346
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/components/WeekHistoryBody.vue
@@ -0,0 +1,174 @@
+<template>
+    <!-- Initial load only; while paging we keep the prior week's rows (below) -->
+    <div
+        v-if="showSkeleton"
+        class="week-history__body"
+    >
+        <div
+            v-for="n in 3"
+            :key="n"
+            class="week-history__skeleton-row"
+        >
+            <q-skeleton
+                type="QBadge"
+                width="6rem"
+                height="1.125rem"
+            />
+            <q-skeleton
+                type="text"
+                width="70%"
+            />
+            <q-skeleton
+                type="text"
+                width="50%"
+            />
+        </div>
+    </div>
+
+    <div
+        v-else-if="error"
+        class="week-history__body"
+    >
+        <StatusBanner type="error">
+            {{ error }}
+            <template #action>
+                <q-btn
+                    flat
+                    dense
+                    no-caps
+                    size="sm"
+                    color="primary"
+                    label="Retry"
+                    @click="$emit('retry')"
+                />
+            </template>
+        </StatusBanner>
+    </div>
+
+    <!-- Empty: teach what this surface is -->
+    <div
+        v-else-if="entries.length === 0"
+        class="week-history__body week-history__state"
+    >
+        <q-icon
+            name="history_toggle_off"
+            color="grey-7"
+            size="sm"
+        />
+        <span class="week-history__state-text text-grey-7">No audit entries for this week.</span>
+    </div>
+
+    <!-- While paging, the prior week's rows stay (dimmed) until new data arrives -->
+    <ul
+        v-else
+        :class="listClass"
+    >
+        <li
+            v-for="entry in entries"
+            :key="entry.scheduleAuditId"
+            class="week-history__item"
+        >
+            <StatusBadge :color="getAuditActionColor(entry.action)">{{ entry.action }}</StatusBadge>
+            <div class="week-history__subject">{{ subjectFor(entry) }}</div>
+            <div class="week-history__meta">
+                by {{ entry.modifiedByName }} &middot;
+                {{ formatDateTime(entry.timeStamp, { dateStyle: "short", timeStyle: "short" }) }}
+            </div>
+        </li>
+    </ul>
+</template>
+
+<script setup lang="ts">
+import { computed } from "vue"
+import { useDateFunctions } from "@/composables/DateFunctions"
+import StatusBadge from "@/components/StatusBadge.vue"
+import StatusBanner from "@/components/StatusBanner.vue"
+import { getAuditActionColor } from "../utils/audit-actions"
+import type { AuditLogEntry } from "../types/audit-types"
+
+const props = defineProps<{
+    /** "rotation" shows the clinician as the subject; "clinician" shows the rotation */
+    viewMode: "rotation" | "clinician"
+    entries: AuditLogEntry[]
+    isLoading: boolean
+    error: string | null
+}>()
+
+defineEmits<{ retry: [] }>()
+
+const { formatDateTime } = useDateFunctions()
+
+const showSkeleton = computed(() => props.isLoading && props.entries.length === 0)
+const listClass = computed(() => ["week-history__list", { "week-history__list--loading": props.isLoading }])
+
+// Show the dimension that varies: the clinician (rotation view) or the rotation (clinician view).
+function subjectFor(entry: AuditLogEntry): string {
+    return props.viewMode === "rotation" ? entry.personName : entry.rotationName
+}
+</script>
+
+<style scoped>
+.week-history__body {
+    padding: 0.75rem 0.875rem;
+}
+
+.week-history__skeleton-row {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    padding: 0.375rem 0;
+}
+
+.week-history__state {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.week-history__state-text {
+    font-size: 0.8rem;
+}
+
+.week-history__list {
+    list-style: none;
+    margin: 0;
+    padding: 0.375rem 0;
+
+    /* Fade back to full when fresh rows replace the dimmed ones */
+    transition: opacity 0.2s ease;
+}
+
+.week-history__list--loading {
+    /* Dim the outgoing week while the next loads */
+    opacity: 0.45;
+}
+
+@media screen and (prefers-reduced-motion: reduce) {
+    .week-history__list {
+        transition: none;
+    }
+}
+
+.week-history__item {
+    padding: 0.5rem 0.875rem;
+    border-top: 0.0625rem solid var(--ucdavis-black-10);
+}
+
+.week-history__item:first-child {
+    border-top: none;
+}
+
+.week-history__subject {
+    margin-top: 0.3125rem;
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--ucdavis-black-90);
+    line-height: 1.25;
+}
+
+.week-history__meta {
+    margin-top: 0.0625rem;
+    font-size: 0.72rem;
+    color: var(--ucdavis-black-80);
+}
+</style>
diff --git a/VueApp/src/ClinicalScheduler/components/WeekHistoryButton.vue b/VueApp/src/ClinicalScheduler/components/WeekHistoryButton.vue
new file mode 100644
index 000000000..66797f699
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/components/WeekHistoryButton.vue
@@ -0,0 +1,45 @@
+<template>
+    <!-- Trigger only; the shared WeekHistoryDialog in ScheduleView owns the modal -->
+    <q-btn
+        flat
+        round
+        dense
+        size="sm"
+        icon="history"
+        color="grey-7"
+        class="week-history-btn"
+        :aria-label="`View audit trail for week ${weekNumber}`"
+        @click.stop="$emit('view-history')"
+    >
+        <!-- Hover only: on touch, the opening tap also shows the tooltip and it lingers -->
+        <q-tooltip
+            v-if="supportsHover"
+            :delay="500"
+            >Audit Trail</q-tooltip
+        >
+    </q-btn>
+</template>
+
+<script setup lang="ts">
+import { useMediaQuery } from "@vueuse/core"
+
+defineProps<{
+    /** Week number, used only to label the trigger for assistive tech */
+    weekNumber: number
+}>()
+
+defineEmits<{ "view-history": [] }>()
+
+// Tooltips are a hover affordance; render them only when the primary input can hover
+const supportsHover = useMediaQuery("(hover: hover)")
+</script>
+
+<style scoped>
+.week-history-btn {
+    flex-shrink: 0;
+
+    /* >=24px hit area (WCAG 2.5.8) so a near-miss tap doesn't fall through to the cell */
+    min-width: 1.75rem;
+    min-height: 1.75rem;
+}
+</style>
diff --git a/VueApp/src/ClinicalScheduler/components/WeekHistoryContent.vue b/VueApp/src/ClinicalScheduler/components/WeekHistoryContent.vue
new file mode 100644
index 000000000..a7ce03ea7
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/components/WeekHistoryContent.vue
@@ -0,0 +1,340 @@
+<template>
+    <section
+        :class="['week-history', { 'week-history--fluid': fluid }]"
+        :aria-labelledby="titleId"
+        :aria-busy="isLoading"
+    >
+        <header class="week-history__header">
+            <div class="week-history__bar">
+                <div class="week-history__heading">
+                    <div
+                        :id="titleId"
+                        class="week-history__title"
+                    >
+                        Audit Trail
+                    </div>
+                    <div class="week-history__subtitle">{{ contextLabel }}</div>
+                </div>
+                <q-btn
+                    v-close-popup
+                    flat
+                    round
+                    dense
+                    size="sm"
+                    icon="close"
+                    color="grey-7"
+                    class="week-history__close"
+                    aria-label="Close audit trail"
+                >
+                    <!-- Hover devices only; see the trigger tooltip in WeekHistoryButton -->
+                    <q-tooltip
+                        v-if="supportsHover"
+                        :delay="500"
+                        >Close</q-tooltip
+                    >
+                </q-btn>
+            </div>
+
+            <!-- Page between weeks without closing the dialog. The week label is a
+                 live region so screen readers announce each move. -->
+            <nav
+                class="week-history__nav"
+                aria-label="Week navigation"
+            >
+                <q-btn
+                    flat
+                    round
+                    dense
+                    size="sm"
+                    icon="chevron_left"
+                    color="grey-8"
+                    class="week-history__nav-btn"
+                    :disable="!canPrev"
+                    aria-label="Previous week"
+                    @click="$emit('prev')"
+                >
+                    <q-tooltip
+                        v-if="showPrevTooltip"
+                        :delay="500"
+                        >Previous week</q-tooltip
+                    >
+                </q-btn>
+                <div
+                    class="week-history__nav-label"
+                    aria-live="polite"
+                >
+                    Week {{ weekNumber }} ({{ formatDate(weekDateStart) }})
+                </div>
+                <q-btn
+                    flat
+                    round
+                    dense
+                    size="sm"
+                    icon="chevron_right"
+                    color="grey-8"
+                    class="week-history__nav-btn"
+                    :disable="!canNext"
+                    aria-label="Next week"
+                    @click="$emit('next')"
+                >
+                    <q-tooltip
+                        v-if="showNextTooltip"
+                        :delay="500"
+                        >Next week</q-tooltip
+                    >
+                </q-btn>
+            </nav>
+
+            <!-- Determinate + absolutely placed: even a fast load reads as a full sweep -->
+            <Transition name="week-history-progress">
+                <q-linear-progress
+                    v-if="showProgress"
+                    :value="progress"
+                    size="0.125rem"
+                    color="primary"
+                    track-color="transparent"
+                    class="week-history__progress"
+                    aria-hidden="true"
+                />
+            </Transition>
+        </header>
+
+        <!-- Height tracks the measured content so the card animates between weeks, not snaps -->
+        <div
+            ref="viewport"
+            class="week-history__viewport"
+        >
+            <div
+                ref="measure"
+                class="week-history__measure"
+            >
+                <WeekHistoryBody
+                    :view-mode="viewMode"
+                    :entries="entries"
+                    :is-loading="isLoading"
+                    :error="error"
+                    @retry="$emit('retry')"
+                />
+            </div>
+        </div>
+    </section>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, useTemplateRef, watch } from "vue"
+import { useIntervalFn, useMediaQuery, useResizeObserver, useTimeoutFn } from "@vueuse/core"
+import { useDateFunctions } from "@/composables/DateFunctions"
+import WeekHistoryBody from "./WeekHistoryBody.vue"
+import type { AuditLogEntry } from "../types/audit-types"
+
+const props = defineProps<{
+    /** Id shared with the wrapper so it can name the surface via aria-labelledby */
+    titleId: string
+    /** "rotation" shows the clinician as the subject; "clinician" shows the rotation */
+    viewMode: "rotation" | "clinician"
+    weekNumber: number
+    weekDateStart: string
+    contextLabel: string
+    entries: AuditLogEntry[]
+    isLoading: boolean
+    error: string | null
+    /** Fill the wrapper (dialog) instead of the fixed popover width */
+    fluid?: boolean
+    /** Enable the "Previous week" control (false at the first week of the schedule) */
+    canPrev?: boolean
+    /** Enable the "Next week" control (false at the last week of the schedule) */
+    canNext?: boolean
+}>()
+
+defineEmits<{ retry: []; prev: []; next: [] }>()
+
+const { formatDate } = useDateFunctions()
+
+// Tooltips are a hover affordance; render them only when the primary input can hover
+const supportsHover = useMediaQuery("(hover: hover)")
+
+// Precomputed template conditionals, so the template carries fewer inline branches
+const showPrevTooltip = computed(() => supportsHover.value && props.canPrev)
+const showNextTooltip = computed(() => supportsHover.value && props.canNext)
+
+// Feed the measured content height to the viewport, which CSS transitions.
+const viewport = useTemplateRef<HTMLElement>("viewport")
+const measure = useTemplateRef<HTMLElement>("measure")
+const bodyHeight = ref("auto")
+
+useResizeObserver(measure, () => {
+    const el = measure.value
+    if (el) bodyHeight.value = `${el.offsetHeight}px`
+})
+
+// Reset scroll to the top on each new week.
+watch(
+    () => props.weekNumber,
+    () => {
+        if (viewport.value) viewport.value.scrollTop = 0
+    },
+)
+
+// Creep toward ~90% while loading, then snap to 100%: a determinate bar that always
+// completes reads better than an indeterminate pulse cut off by a quick load.
+const progress = ref(0)
+const showProgress = ref(false)
+
+const { pause: pauseTrickle, resume: resumeTrickle } = useIntervalFn(
+    () => {
+        progress.value += (0.9 - progress.value) * 0.22
+    },
+    160,
+    { immediate: false },
+)
+
+// Hold the completed bar briefly so the fill shows, then remove it.
+const { start: scheduleHide, stop: cancelHide } = useTimeoutFn(
+    () => {
+        showProgress.value = false
+        progress.value = 0
+    },
+    280,
+    { immediate: false },
+)
+
+watch(
+    () => props.isLoading,
+    (loading) => {
+        if (loading) {
+            cancelHide()
+            showProgress.value = true
+            progress.value = 0.12
+            resumeTrickle()
+        } else {
+            pauseTrickle()
+            if (showProgress.value) {
+                progress.value = 1
+                scheduleHide()
+            }
+        }
+    },
+    { immediate: true },
+)
+</script>
+
+<style scoped>
+.week-history {
+    width: 20rem;
+    max-width: 88vw;
+}
+
+.week-history--fluid {
+    width: 100%;
+    max-width: 100%;
+}
+
+.week-history__header {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+    padding: 0.5rem 0.375rem 0.5rem 0.875rem;
+
+    /* Positioned so the loading bar can anchor here; kept above the scrolling viewport */
+    position: sticky;
+    top: 0;
+    z-index: 1;
+    background: #fff;
+    border-bottom: 0.0625rem solid var(--ucdavis-black-10);
+}
+
+.week-history__bar {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+}
+
+.week-history__nav {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+.week-history__nav-btn {
+    flex-shrink: 0;
+}
+
+.week-history__nav-label {
+    flex: 1;
+    min-width: 0;
+    text-align: center;
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ucdavis-black-90);
+}
+
+.week-history__progress {
+    position: absolute;
+    right: 0;
+    bottom: -0.0625rem;
+    left: 0;
+}
+
+/* Smooth the fill between trickle steps and on the final snap to 100% */
+.week-history__progress :deep(.q-linear-progress__model) {
+    transition: transform 0.35s cubic-bezier(0.22, 1, 0.36, 1);
+}
+
+/* Fade out on removal */
+.week-history-progress-leave-active {
+    transition: opacity 0.25s ease;
+}
+
+.week-history-progress-leave-to {
+    opacity: 0;
+}
+
+@media screen and (prefers-reduced-motion: reduce) {
+    .week-history__progress :deep(.q-linear-progress__model) {
+        transition: none;
+    }
+
+    .week-history-progress-leave-active {
+        transition: none;
+    }
+}
+
+.week-history__viewport {
+    overflow-y: auto;
+    max-height: 55vh;
+
+    /* Height comes from the measured content (script); animate size changes between weeks */
+    height: v-bind("bodyHeight");
+    transition: height 0.24s cubic-bezier(0.22, 1, 0.36, 1);
+    will-change: height;
+}
+
+@media screen and (prefers-reduced-motion: reduce) {
+    .week-history__viewport {
+        transition: none;
+    }
+}
+
+.week-history__heading {
+    flex: 1;
+    min-width: 0;
+    padding-top: 0.125rem;
+}
+
+.week-history__close {
+    flex-shrink: 0;
+}
+
+.week-history__title {
+    font-size: 0.9rem;
+    font-weight: 700;
+    color: var(--ucdavis-blue-100);
+    line-height: 1.2;
+}
+
+.week-history__subtitle {
+    margin-top: 0.125rem;
+    font-size: 0.75rem;
+    color: var(--ucdavis-black-70);
+}
+</style>
diff --git a/VueApp/src/ClinicalScheduler/components/WeekHistoryDialog.vue b/VueApp/src/ClinicalScheduler/components/WeekHistoryDialog.vue
new file mode 100644
index 000000000..7ed19d63c
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/components/WeekHistoryDialog.vue
@@ -0,0 +1,123 @@
+<template>
+    <!-- Top-anchored so the card grows downward from a fixed edge; the header (and its
+         back/forward nav) stays put between weeks of different heights, not re-centered.
+         Pin the scale transition: top-anchored dialogs otherwise default to a slide, which
+         would make this the only modal that doesn't open/close like the rest of the app. -->
+    <q-dialog
+        v-model="open"
+        position="top"
+        transition-show="scale"
+        transition-hide="scale"
+        :aria-labelledby="titleId"
+    >
+        <q-card class="week-history-dialog-card">
+            <WeekHistoryContent
+                v-if="activeWeek"
+                fluid
+                :title-id="titleId"
+                :view-mode="viewMode"
+                :week-number="activeWeek.weekNumber"
+                :week-date-start="activeWeek.dateStart"
+                :context-label="contextLabel"
+                :entries="entries"
+                :is-loading="isLoading"
+                :error="error"
+                :can-prev="canPrev"
+                :can-next="canNext"
+                @prev="goPrev"
+                @next="goNext"
+                @retry="loadHistory"
+            />
+        </q-card>
+    </q-dialog>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, useId, watch } from "vue"
+import { onKeyStroke } from "@vueuse/core"
+import { AuditLogService } from "../services/audit-log-service"
+import { useAuditEntries } from "../composables/use-audit-entries"
+import WeekHistoryContent from "./WeekHistoryContent.vue"
+import type { WeekItem } from "./schedule-view-types"
+
+const props = defineProps<{
+    /** "rotation" reads rotation+week history; "clinician" reads clinician+week history */
+    viewMode: "rotation" | "clinician"
+    /** Rotation id (rotation view) or clinician MothraID (clinician view) */
+    contextId: number | string | null
+    /** Rotation name or clinician name, shown in the header */
+    contextLabel: string
+    /** Every week in schedule order; Previous/Next page through the whole list */
+    weeks: WeekItem[]
+    /** Week whose icon was clicked; the dialog opens on this week */
+    startWeekId: number | null
+}>()
+
+const open = defineModel<boolean>({ required: true })
+
+const titleId = `week-history-title-${useId()}`
+
+// Index into props.weeks of the shown week; re-seeded on open, then moved by the nav.
+const activeIndex = ref(0)
+const activeWeek = computed<WeekItem | null>(() => props.weeks[activeIndex.value] ?? null)
+const canPrev = computed(() => activeIndex.value > 0)
+const canNext = computed(() => activeIndex.value < props.weeks.length - 1)
+
+const { entries, isLoading, error, load, reset } = useAuditEntries()
+
+// Seed + load on open (not @show, which fires post-transition) so the first frame is
+// the right week loading, not a flash of the empty/wrong-week box.
+watch(open, (isOpen) => {
+    if (!isOpen) return
+    const idx = props.weeks.findIndex((w) => w.weekId === props.startWeekId)
+    activeIndex.value = idx >= 0 ? idx : 0
+    reset()
+    loadHistory()
+})
+
+// Reload on each open/week change so it reflects the latest grid edits.
+async function loadHistory() {
+    const week = activeWeek.value
+    if (!week || props.contextId === null) return
+    await load(() =>
+        props.viewMode === "rotation"
+            ? AuditLogService.getRotationWeekHistory(Number(props.contextId), week.weekId)
+            : AuditLogService.getClinicianWeekHistory(String(props.contextId), week.weekId),
+    )
+}
+
+function goPrev() {
+    if (!canPrev.value) return
+    activeIndex.value -= 1
+    loadHistory()
+}
+
+function goNext() {
+    if (!canNext.value) return
+    activeIndex.value += 1
+    loadHistory()
+}
+
+// Arrow keys page weeks while open (guarded so they're inert when closed).
+onKeyStroke("ArrowLeft", (e) => {
+    if (!open.value) return
+    e.preventDefault()
+    goPrev()
+})
+onKeyStroke("ArrowRight", (e) => {
+    if (!open.value) return
+    e.preventDefault()
+    goNext()
+})
+</script>
+
+<style scoped>
+.week-history-dialog-card {
+    /* Fixed width, not vw, which would overflow the dialog inset and clip the close button */
+    width: 22rem;
+    max-width: 100%;
+
+    /* Drop below the top edge so the top-anchored dialog doesn't sit flush against it */
+    margin-top: 10vh;
+}
+</style>
diff --git a/VueApp/src/ClinicalScheduler/composables/use-audit-entries.ts b/VueApp/src/ClinicalScheduler/composables/use-audit-entries.ts
new file mode 100644
index 000000000..753aec6f2
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/composables/use-audit-entries.ts
@@ -0,0 +1,70 @@
+import { ref } from "vue"
+import type { Ref } from "vue"
+import type { ApiResult } from "../types/api"
+import type { AuditLogEntry } from "../types/audit-types"
+
+const LOAD_FAILED = "Failed to load the audit trail"
+const LOAD_ERROR = "An error occurred while loading the audit trail"
+
+export interface UseAuditEntries {
+    entries: Ref<AuditLogEntry[]>
+    isLoading: Ref<boolean>
+    error: Ref<string | null>
+    load: (request: () => Promise<ApiResult<AuditLogEntry[]>>) => Promise<void>
+    /** Clear entries/error so the next load shows a clean loading state, not stale content */
+    reset: () => void
+}
+
+/**
+ * Shared loader for audit-trail surfaces (the full page and the inline per-week
+ * popover): owns the entries/loading/error state and applies one consistent
+ * success/failure handling, so each caller stays a thin wrapper around its request.
+ */
+export function useAuditEntries(): UseAuditEntries {
+    const entries = ref<AuditLogEntry[]>([])
+    const isLoading = ref(false)
+    const error = ref<string | null>(null)
+    let latestRequestId = 0
+
+    async function load(request: () => Promise<ApiResult<AuditLogEntry[]>>): Promise<void> {
+        // Overlapping loads (debounced filter edits, retry) can resolve out of order;
+        // only the latest request may commit state, or stale results win the race.
+        latestRequestId += 1
+        const requestId = latestRequestId
+        isLoading.value = true
+        error.value = null
+        try {
+            const response = await request()
+            if (requestId !== latestRequestId) {
+                return
+            }
+            if (response.success) {
+                entries.value = response.result
+            } else {
+                entries.value = []
+                error.value = response.errors?.join(", ") || LOAD_FAILED
+            }
+        } catch (err) {
+            if (requestId !== latestRequestId) {
+                return
+            }
+            entries.value = []
+            error.value = err instanceof Error ? err.message : LOAD_ERROR
+        } finally {
+            if (requestId === latestRequestId) {
+                isLoading.value = false
+            }
+        }
+    }
+
+    // Drop the current result (and invalidate any in-flight load) so a reopened
+    // surface shows its loading state, not stale rows.
+    function reset(): void {
+        latestRequestId += 1
+        entries.value = []
+        error.value = null
+        isLoading.value = false
+    }
+
+    return { entries, isLoading, error, load, reset }
+}
diff --git a/VueApp/src/ClinicalScheduler/constants/permission-messages.ts b/VueApp/src/ClinicalScheduler/constants/permission-messages.ts
index 6ab4b589b..71ee5dcc2 100644
--- a/VueApp/src/ClinicalScheduler/constants/permission-messages.ts
+++ b/VueApp/src/ClinicalScheduler/constants/permission-messages.ts
@@ -8,6 +8,7 @@ const ACCESS_DENIED_MESSAGES = {
     ROTATION_VIEW: "You do not have permission to access the Schedule by Rotation view.",
     CLINICIAN_VIEW: "You do not have permission to access the Schedule by Clinician view.",
     UNAUTHORIZED_ROTATION: "You do not have permission to view this rotation.",
+    AUDIT_LOG: "You do not have permission to view the Clinical Scheduler audit trail.",
 } as const
 
 // Subtitle messages for access denied components
@@ -18,6 +19,7 @@ const ACCESS_DENIED_SUBTITLES = {
     CLINICIAN_VIEW:
         "This feature is not available with rotation-specific permissions. Contact your administrator if you need full access to scheduling features.",
     UNAUTHORIZED_ROTATION: "You can only access rotations that you have been granted permission to edit.",
+    AUDIT_LOG: "The audit trail is available to schedule managers. Contact your administrator if you need access.",
 } as const
 
 // Error messages for schedule operations
diff --git a/VueApp/src/ClinicalScheduler/pages/AuditLogPage.vue b/VueApp/src/ClinicalScheduler/pages/AuditLogPage.vue
new file mode 100644
index 000000000..5e5fc8b6d
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/pages/AuditLogPage.vue
@@ -0,0 +1,408 @@
+<template>
+    <div class="clinical-scheduler-container position-relative">
+        <h1 class="sr-only">Clinical Scheduler Audit Trail</h1>
+        <SchedulerNavigation />
+
+        <!-- Loading permissions state -->
+        <div
+            v-if="isLoadingPermissions"
+            class="text-center q-my-lg"
+        >
+            <q-spinner-dots
+                size="3rem"
+                color="primary"
+            />
+            <div class="q-mt-md text-body1">Loading...</div>
+        </div>
+
+        <!-- Access denied for users without manage permission -->
+        <AccessDeniedCard
+            v-else-if="!permissionsStore.hasManagePermission"
+            :message="ACCESS_DENIED_MESSAGES.AUDIT_LOG"
+            :subtitle="ACCESS_DENIED_SUBTITLES.AUDIT_LOG"
+        >
+            <template #actions>
+                <q-btn
+                    color="primary"
+                    label="Return to Home"
+                    @click="goToHome"
+                />
+            </template>
+        </AccessDeniedCard>
+
+        <!-- Main content -->
+        <div v-else>
+            <h2 class="text-h5 q-mb-md">Audit Trail</h2>
+
+            <StatusBanner
+                v-if="error"
+                type="error"
+            >
+                <strong>Error: </strong>{{ error }}
+                <template #action>
+                    <q-btn
+                        flat
+                        color="negative"
+                        label="Retry"
+                        :loading="isLoading"
+                        @click="initialize"
+                    />
+                </template>
+            </StatusBanner>
+
+            <!-- Filters - always visible on desktop, collapsible on mobile -->
+            <q-expansion-item
+                v-model="filtersExpandedComputed"
+                icon="filter_list"
+                label="Filters"
+                header-class="bg-grey-2 lt-md"
+                class="q-mb-md"
+            >
+                <q-card flat>
+                    <q-card-section :class="filterSectionClass">
+                        <div class="row q-col-gutter-sm">
+                            <div :class="filterColClass">
+                                <q-select
+                                    v-model="currentYear"
+                                    :options="yearOptions"
+                                    label="Grad Year"
+                                    dense
+                                    options-dense
+                                    outlined
+                                    @update:model-value="onYearChange"
+                                />
+                            </div>
+                            <div :class="filterColClass">
+                                <q-select
+                                    v-model="selectedTermCode"
+                                    :options="termOptions"
+                                    label="Term"
+                                    :display-value="termDisplayValue"
+                                    dense
+                                    options-dense
+                                    outlined
+                                    clearable
+                                    emit-value
+                                    map-options
+                                />
+                            </div>
+                            <div :class="filterColClass">
+                                <q-select
+                                    v-model="selectedRotationId"
+                                    :options="rotationOptions"
+                                    label="Rotation"
+                                    :display-value="rotationDisplayValue"
+                                    dense
+                                    options-dense
+                                    outlined
+                                    clearable
+                                    emit-value
+                                    map-options
+                                />
+                            </div>
+                            <div :class="filterColClass">
+                                <q-select
+                                    v-model="selectedArea"
+                                    :options="areaOptions"
+                                    label="Area"
+                                    :display-value="areaDisplayValue"
+                                    dense
+                                    options-dense
+                                    outlined
+                                    clearable
+                                    emit-value
+                                    map-options
+                                />
+                            </div>
+                            <div :class="filterColClass">
+                                <q-select
+                                    v-model="selectedModifier"
+                                    :options="filteredModifierOptions"
+                                    label="Modified By"
+                                    stack-label
+                                    placeholder="All users"
+                                    dense
+                                    options-dense
+                                    outlined
+                                    clearable
+                                    emit-value
+                                    map-options
+                                    use-input
+                                    :input-debounce="INPUT_DEBOUNCE_MS"
+                                    @filter="filterModifiers"
+                                />
+                            </div>
+                            <div :class="filterColClass">
+                                <q-select
+                                    v-model="selectedPerson"
+                                    :options="filteredPersonOptions"
+                                    label="Person"
+                                    stack-label
+                                    placeholder="All people"
+                                    dense
+                                    options-dense
+                                    outlined
+                                    clearable
+                                    emit-value
+                                    map-options
+                                    use-input
+                                    :input-debounce="INPUT_DEBOUNCE_MS"
+                                    @filter="filterPersons"
+                                />
+                            </div>
+                            <div :class="dateColClass">
+                                <q-input
+                                    v-model="fromDate"
+                                    type="date"
+                                    label="Date From"
+                                    dense
+                                    outlined
+                                    clearable
+                                />
+                            </div>
+                            <div :class="dateColClass">
+                                <q-input
+                                    v-model="toDate"
+                                    type="date"
+                                    label="Date To"
+                                    dense
+                                    outlined
+                                    clearable
+                                />
+                            </div>
+                        </div>
+                        <div class="row q-mt-sm">
+                            <div class="col-12 text-right">
+                                <q-btn
+                                    label="Clear Filters"
+                                    color="secondary"
+                                    dense
+                                    flat
+                                    @click="clearFilters"
+                                />
+                            </div>
+                        </div>
+                    </q-card-section>
+                </q-card>
+            </q-expansion-item>
+
+            <!-- Results -->
+            <AuditLogResultsTable
+                :entries="entries"
+                :is-loading="isLoading"
+            />
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted, watch } from "vue"
+import { useQuasar } from "quasar"
+import { useDebounceFn } from "@vueuse/core"
+import { usePermissionsStore } from "../stores/permissions"
+import { usePermissionChecks } from "../composables/use-permission-checks"
+import { AuditLogService } from "../services/audit-log-service"
+import { RotationService } from "../services/rotation-service"
+import { PageDataService } from "../services/page-data-service"
+import StatusBanner from "@/components/StatusBanner.vue"
+import SchedulerNavigation from "../components/SchedulerNavigation.vue"
+import AccessDeniedCard from "../components/AccessDeniedCard.vue"
+import AuditLogResultsTable from "../components/AuditLogResultsTable.vue"
+import { ACCESS_DENIED_MESSAGES, ACCESS_DENIED_SUBTITLES } from "../constants/permission-messages"
+import { useAuditEntries } from "../composables/use-audit-entries"
+
+const INPUT_DEBOUNCE_MS = 300
+
+const permissionsStore = usePermissionsStore()
+const { isLoadingPermissions, goToHome } = usePermissionChecks()
+const $q = useQuasar()
+
+const { entries, isLoading, error, load } = useAuditEntries()
+const ready = ref(false)
+
+// Filters
+const currentYear = ref<number | null>(null)
+const selectedTermCode = ref<number | null>(null)
+const selectedRotationId = ref<number | null>(null)
+const selectedArea = ref<string | null>(null)
+const selectedModifier = ref<string | null>(null)
+const selectedPerson = ref<string | null>(null)
+// string | null: Quasar clearable date inputs emit null when cleared (API filters accept it)
+const fromDate = ref<string | null>(null)
+const toDate = ref<string | null>(null)
+
+// Filter dropdown options
+const yearOptions = ref<number[]>([])
+const termOptions = ref<{ label: string; value: number }[]>([])
+const rotationOptions = ref<{ label: string; value: number }[]>([])
+const modifierOptions = ref<{ label: string; value: string }[]>([])
+const filteredModifierOptions = ref<{ label: string; value: string }[]>([])
+const personOptions = ref<{ label: string; value: string }[]>([])
+const filteredPersonOptions = ref<{ label: string; value: string }[]>([])
+
+const areaOptions: { label: string; value: string }[] = [
+    { label: "Clinician Schedules", value: "Clinicians" },
+    { label: "Student Schedules", value: "Students" },
+]
+
+// Responsive layout classes, computed once so the template stays branch-free.
+const filterColClass = computed(() => ($q.screen.gt.sm ? "col-12 col-md-6 col-lg-3" : "col-12"))
+const dateColClass = computed(() => ($q.screen.gt.sm ? "col-12 col-md-6 col-lg-3" : "col-6"))
+const filterSectionClass = computed(() => ($q.screen.gt.sm ? "q-pa-none" : ""))
+
+// "All ..." placeholder text while a clearable filter is empty.
+const termDisplayValue = computed(() => (selectedTermCode.value === null ? "All terms" : undefined))
+const rotationDisplayValue = computed(() => (selectedRotationId.value === null ? "All rotations" : undefined))
+const areaDisplayValue = computed(() => (selectedArea.value === null ? "All schedules" : undefined))
+
+// Filters panel: always open on desktop, collapsible on mobile (mirrors the Effort audit trail).
+const filtersExpanded = ref(false)
+const filtersExpandedComputed = computed({
+    get: () => ($q.screen.gt.sm ? true : filtersExpanded.value),
+    set: (val: boolean) => {
+        filtersExpanded.value = val
+    },
+})
+
+function filterModifiers(val: string, update: (fn: () => void) => void) {
+    update(() => {
+        if (!val) {
+            filteredModifierOptions.value = modifierOptions.value
+        } else {
+            const needle = val.toLowerCase()
+            filteredModifierOptions.value = modifierOptions.value.filter((m) => m.label.toLowerCase().includes(needle))
+        }
+    })
+}
+
+function filterPersons(val: string, update: (fn: () => void) => void) {
+    update(() => {
+        if (!val) {
+            filteredPersonOptions.value = personOptions.value
+        } else {
+            const needle = val.toLowerCase()
+            filteredPersonOptions.value = personOptions.value.filter((p) => p.label.toLowerCase().includes(needle))
+        }
+    })
+}
+
+async function loadAuditTrail() {
+    if (!permissionsStore.hasManagePermission) {
+        return
+    }
+    await load(() =>
+        AuditLogService.getAuditLog({
+            year: currentYear.value,
+            termCode: selectedTermCode.value,
+            rotationId: selectedRotationId.value,
+            area: selectedArea.value,
+            modifiedBy: selectedModifier.value,
+            person: selectedPerson.value,
+            from: fromDate.value,
+            to: toDate.value,
+        }),
+    )
+}
+
+const debouncedLoad = useDebounceFn(() => {
+    void loadAuditTrail()
+}, INPUT_DEBOUNCE_MS)
+
+async function loadPageData() {
+    try {
+        const pageData = await PageDataService.getPageData()
+        yearOptions.value = pageData.availableGradYears
+        if (currentYear.value === null) {
+            currentYear.value = pageData.currentGradYear
+        }
+    } catch (err) {
+        error.value = err instanceof Error ? err.message : "Failed to load the available years"
+    }
+}
+
+async function loadFilterOptions() {
+    const [rotations, modifiers, persons] = await Promise.all([
+        RotationService.getRotations(),
+        AuditLogService.getModifiers(),
+        AuditLogService.getPersons(),
+    ])
+    if (rotations.success) {
+        rotationOptions.value = rotations.result
+            .map((rotation) => ({ label: rotation.name, value: rotation.rotId }))
+            .sort((a, b) => a.label.localeCompare(b.label))
+    }
+    if (modifiers.success) {
+        modifierOptions.value = modifiers.result.map((modifier) => ({
+            label: modifier.displayName,
+            value: modifier.mothraId,
+        }))
+        filteredModifierOptions.value = modifierOptions.value
+    }
+    if (persons.success) {
+        personOptions.value = persons.result.map((person) => ({
+            label: person.displayName,
+            value: person.mothraId,
+        }))
+        filteredPersonOptions.value = personOptions.value
+    }
+}
+
+let latestTermRequestId = 0
+
+async function loadTermOptions(year = currentYear.value) {
+    const requestId = ++latestTermRequestId
+    const response = await AuditLogService.getTerms(year ?? undefined)
+    // Out-of-order getTerms responses (rapid year changes) must not overwrite newer options.
+    if (requestId === latestTermRequestId && response.success) {
+        termOptions.value = response.result.map((term) => ({ label: term.term, value: term.termCode }))
+    }
+}
+
+async function onYearChange() {
+    const year = currentYear.value
+    // Terms are grad-year specific, so reset the term filter and reload its options.
+    selectedTermCode.value = null
+    await loadTermOptions(year)
+    if (year !== currentYear.value) return
+    void loadAuditTrail()
+}
+
+function clearFilters() {
+    selectedTermCode.value = null
+    selectedRotationId.value = null
+    selectedArea.value = null
+    selectedModifier.value = null
+    selectedPerson.value = null
+    fromDate.value = null
+    toDate.value = null
+}
+
+// Auto-apply when any filter other than the year changes (the year loads immediately via onYearChange).
+watch([selectedRotationId, selectedTermCode, selectedArea, selectedModifier, selectedPerson, fromDate, toDate], () => {
+    if (!ready.value) {
+        return
+    }
+    debouncedLoad()
+})
+
+async function initialize() {
+    try {
+        if (!permissionsStore.userPermissions) {
+            await permissionsStore.initialize()
+        }
+        if (permissionsStore.hasManagePermission) {
+            await Promise.all([loadPageData(), loadFilterOptions()])
+            await loadTermOptions()
+            await loadAuditTrail()
+        }
+    } catch (err) {
+        error.value = err instanceof Error ? err.message : "Failed to load the audit trail"
+    } finally {
+        ready.value = true
+    }
+}
+
+onMounted(() => {
+    void initialize()
+})
+</script>
diff --git a/VueApp/src/ClinicalScheduler/pages/ClinicianScheduleView.vue b/VueApp/src/ClinicalScheduler/pages/ClinicianScheduleView.vue
index 5f2f0dc20..b25e2e223 100644
--- a/VueApp/src/ClinicalScheduler/pages/ClinicianScheduleView.vue
+++ b/VueApp/src/ClinicalScheduler/pages/ClinicianScheduleView.vue
@@ -140,6 +140,9 @@
                     :is-loading="loadingSchedule"
                     :error="scheduleError"
                     :can-edit="!isPastYear"
+                    :can-view-history="permissionsStore.hasManagePermission"
+                    :history-context-id="selectedClinician?.mothraId ?? null"
+                    :history-context-label="selectedClinician?.fullName ?? ''"
                     :show-legend="true"
                     :show-warning-icon="false"
                     :show-primary-toggle="true"
diff --git a/VueApp/src/ClinicalScheduler/pages/RotationScheduleView.vue b/VueApp/src/ClinicalScheduler/pages/RotationScheduleView.vue
index d29934a5a..b4990f64a 100644
--- a/VueApp/src/ClinicalScheduler/pages/RotationScheduleView.vue
+++ b/VueApp/src/ClinicalScheduler/pages/RotationScheduleView.vue
@@ -170,6 +170,9 @@
                 :is-loading="isLoadingSchedule"
                 :error="scheduleError"
                 :can-edit="canEditRotation"
+                :can-view-history="permissionsStore.hasManagePermission"
+                :history-context-id="selectedRotation.rotId"
+                :history-context-label="selectedRotation.name"
                 :show-legend="true"
                 :show-warning-in-legend="true"
                 :show-warning-icon="true"
diff --git a/VueApp/src/ClinicalScheduler/router/routes.ts b/VueApp/src/ClinicalScheduler/router/routes.ts
index 9a25d957a..e165cc837 100644
--- a/VueApp/src/ClinicalScheduler/router/routes.ts
+++ b/VueApp/src/ClinicalScheduler/router/routes.ts
@@ -36,6 +36,12 @@ const routes = [
         component: () => import("@/ClinicalScheduler/pages/ClinicianScheduleView.vue"),
         name: "ClinicianScheduleWithId",
     },
+    {
+        path: "/ClinicalScheduler/audit",
+        meta: { layout: ViperLayout },
+        component: () => import("@/ClinicalScheduler/pages/AuditLogPage.vue"),
+        name: "AuditLog",
+    },
 ]
 
 export { routes as clinicalSchedulerRoutes }
diff --git a/VueApp/src/ClinicalScheduler/services/audit-log-service.ts b/VueApp/src/ClinicalScheduler/services/audit-log-service.ts
new file mode 100644
index 000000000..0a2b8df32
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/services/audit-log-service.ts
@@ -0,0 +1,132 @@
+import { useFetch } from "../../composables/ViperFetch"
+import type { ApiResult } from "../types/api"
+import type { AuditLogEntry, AuditModifier, AuditTerm } from "../types/audit-types"
+
+interface AuditLogFilters {
+    year?: number | null
+    rotationId?: number | null
+    termCode?: number | null
+    person?: string | null
+    modifiedBy?: string | null
+    area?: string | null
+    from?: string | null
+    to?: string | null
+}
+
+class AuditLogService {
+    private static readonly BASE_URL = `${import.meta.env.VITE_API_URL}clinicalscheduler/audit`
+
+    private static buildUrl(baseUrl: string, params: Record<string, string | number | null | undefined>): string {
+        const search = new URLSearchParams()
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null && `${value}`.length > 0) {
+                search.set(key, value.toString())
+            }
+        }
+        const queryString = search.toString()
+        return queryString ? `${baseUrl}?${queryString}` : baseUrl
+    }
+
+    /**
+     * Get the filtered audit log. An empty/omitted year defaults to the current grad year server-side.
+     */
+    static async getAuditLog(filters: AuditLogFilters = {}): Promise<ApiResult<AuditLogEntry[]>> {
+        try {
+            const url = AuditLogService.buildUrl(AuditLogService.BASE_URL, { ...filters })
+            const { get } = useFetch()
+            return await get(url)
+        } catch (error) {
+            return {
+                result: [],
+                success: false,
+                errors: [error instanceof Error ? error.message : "Unknown error occurred"],
+            }
+        }
+    }
+
+    /**
+     * Get the distinct users who have made audited changes, for the "Modified By" filter.
+     */
+    static async getModifiers(): Promise<ApiResult<AuditModifier[]>> {
+        try {
+            const { get } = useFetch()
+            return await get(`${AuditLogService.BASE_URL}/modifiers`)
+        } catch (error) {
+            return {
+                result: [],
+                success: false,
+                errors: [error instanceof Error ? error.message : "Unknown error occurred"],
+            }
+        }
+    }
+
+    /**
+     * Get the terms (semesters) within a grad year, for the "Term" filter.
+     */
+    static async getTerms(year?: number): Promise<ApiResult<AuditTerm[]>> {
+        try {
+            const url = AuditLogService.buildUrl(`${AuditLogService.BASE_URL}/terms`, { year })
+            const { get } = useFetch()
+            return await get(url)
+        } catch (error) {
+            return {
+                result: [],
+                success: false,
+                errors: [error instanceof Error ? error.message : "Unknown error occurred"],
+            }
+        }
+    }
+
+    /**
+     * Get the distinct affected students/clinicians in the audit trail, for the "Person" filter.
+     */
+    static async getPersons(): Promise<ApiResult<AuditModifier[]>> {
+        try {
+            const { get } = useFetch()
+            return await get(`${AuditLogService.BASE_URL}/persons`)
+        } catch (error) {
+            return {
+                result: [],
+                success: false,
+                errors: [error instanceof Error ? error.message : "Unknown error occurred"],
+            }
+        }
+    }
+
+    /**
+     * Get the audit trail for a single rotation + week (Schedule-by-Rotation inline popover).
+     */
+    static async getRotationWeekHistory(rotationId: number, weekId: number): Promise<ApiResult<AuditLogEntry[]>> {
+        try {
+            const url = AuditLogService.buildUrl(`${AuditLogService.BASE_URL}/rotation-week`, { rotationId, weekId })
+            const { get } = useFetch()
+            return await get(url)
+        } catch (error) {
+            return {
+                result: [],
+                success: false,
+                errors: [error instanceof Error ? error.message : "Unknown error occurred"],
+            }
+        }
+    }
+
+    /**
+     * Get the audit trail for a single clinician + week (Schedule-by-Clinician inline popover).
+     */
+    static async getClinicianWeekHistory(mothraId: string, weekId: number): Promise<ApiResult<AuditLogEntry[]>> {
+        try {
+            const url = AuditLogService.buildUrl(`${AuditLogService.BASE_URL}/clinician-week`, { mothraId, weekId })
+            const { get } = useFetch()
+            return await get(url)
+        } catch (error) {
+            return {
+                result: [],
+                success: false,
+                errors: [error instanceof Error ? error.message : "Unknown error occurred"],
+            }
+        }
+    }
+}
+
+export { AuditLogService }
+export type { AuditLogFilters }
diff --git a/VueApp/src/ClinicalScheduler/types/audit-types.ts b/VueApp/src/ClinicalScheduler/types/audit-types.ts
new file mode 100644
index 000000000..b7c6be6d5
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/types/audit-types.ts
@@ -0,0 +1,35 @@
+/**
+ * Types for the schedule-change audit log.
+ */
+
+interface AuditLogEntry {
+    scheduleAuditId: number
+    area: string
+    mothraId: string | null
+    personName: string
+    action: string
+    rotationId: number | null
+    rotationName: string
+    weekId: number | null
+    weekNum: number
+    weekStart: string | null
+    term: string
+    modifiedBy: string
+    modifiedByName: string
+    timeStamp: string
+}
+
+// A selectable person option in the audit trail filters — reused for both the
+// "Modified By" (change author) and "Person" (affected student/clinician) dropdowns.
+interface AuditModifier {
+    mothraId: string
+    displayName: string
+}
+
+// A selectable term option for the audit trail "Term" filter, scoped to a grad year.
+interface AuditTerm {
+    termCode: number
+    term: string
+}
+
+export type { AuditLogEntry, AuditModifier, AuditTerm }
diff --git a/VueApp/src/ClinicalScheduler/utils/audit-actions.ts b/VueApp/src/ClinicalScheduler/utils/audit-actions.ts
new file mode 100644
index 000000000..fff72b4d7
--- /dev/null
+++ b/VueApp/src/ClinicalScheduler/utils/audit-actions.ts
@@ -0,0 +1,17 @@
+/**
+ * Shared mapping of schedule-audit actions to semantic Quasar colors, used by both the
+ * standalone Audit Trail page and the inline per-week history popover so the colored
+ * action badges stay consistent across the feature.
+ */
+const ACTION_COLORS: Record<string, string> = {
+    "Added to rotation": "positive",
+    "Removed from rotation": "negative",
+    "Made primary evaluator": "primary",
+    "Primary evaluator flag removed": "warning",
+}
+
+function getAuditActionColor(action: string): string {
+    return ACTION_COLORS[action] ?? "grey-8"
+}
+
+export { getAuditActionColor }
diff --git a/VueApp/src/Effort/__tests__/audit-change-detail.test.ts b/VueApp/src/Effort/__tests__/audit-change-detail.test.ts
new file mode 100644
index 000000000..2190f5da5
--- /dev/null
+++ b/VueApp/src/Effort/__tests__/audit-change-detail.test.ts
@@ -0,0 +1,49 @@
+import { mount } from "@vue/test-utils"
+import AuditChangeDetail from "../components/AuditChangeDetail.vue"
+import type { ChangeDetail } from "../types"
+
+function mountDetail(name: string, detail: ChangeDetail) {
+    return mount(AuditChangeDetail, { props: { name, detail } })
+}
+
+describe("auditChangeDetail", () => {
+    it("shows a reference value once without diff styling", () => {
+        expect.assertions(3)
+
+        const wrapper = mountDetail("Course", { oldValue: "VET 410", newValue: "VET 410" })
+
+        expect(wrapper.text()).toContain("Course:")
+        expect(wrapper.text()).toContain("VET 410")
+        expect(wrapper.find(".text-negative").exists()).toBeFalsy()
+    })
+
+    it("shows old and new values with diff styling when changed", () => {
+        expect.assertions(3)
+
+        const wrapper = mountDetail("Hours", { oldValue: "10", newValue: "12" })
+
+        expect(wrapper.find(".text-negative").text()).toBe("10")
+        expect(wrapper.find(".text-positive").text()).toBe("12")
+        expect(wrapper.text()).toContain("→")
+    })
+
+    it("omits the old value and arrow when the value was added", () => {
+        expect.assertions(3)
+
+        const wrapper = mountDetail("Role", { oldValue: null, newValue: "Instructor" })
+
+        expect(wrapper.find(".text-negative").exists()).toBeFalsy()
+        expect(wrapper.find(".text-positive").text()).toBe("Instructor")
+        expect(wrapper.text()).not.toContain("→")
+    })
+
+    it("omits the new value and arrow when the value was removed", () => {
+        expect.assertions(3)
+
+        const wrapper = mountDetail("Role", { oldValue: "Instructor", newValue: null })
+
+        expect(wrapper.find(".text-negative").text()).toBe("Instructor")
+        expect(wrapper.find(".text-positive").exists()).toBeFalsy()
+        expect(wrapper.text()).not.toContain("→")
+    })
+})
diff --git a/VueApp/src/Effort/components/AuditChangeDetail.vue b/VueApp/src/Effort/components/AuditChangeDetail.vue
new file mode 100644
index 000000000..98366020b
--- /dev/null
+++ b/VueApp/src/Effort/components/AuditChangeDetail.vue
@@ -0,0 +1,30 @@
+<template>
+    <strong>{{ name }}:</strong>
+    <!-- Reference value (old === new): show once without diff styling -->
+    <template v-if="detail.oldValue === detail.newValue">
+        <span>{{ detail.oldValue }}</span>
+    </template>
+    <!-- Changed value: show old → new -->
+    <template v-else>
+        <span
+            v-if="detail.oldValue !== null"
+            class="text-negative"
+            >{{ detail.oldValue }}</span
+        >
+        <span v-if="detail.oldValue !== null && detail.newValue !== null"> &rarr; </span>
+        <span
+            v-if="detail.newValue !== null"
+            class="text-positive"
+            >{{ detail.newValue }}</span
+        >
+    </template>
+</template>
+
+<script setup lang="ts">
+import type { ChangeDetail } from "../types"
+
+defineProps<{
+    name: string
+    detail: ChangeDetail
+}>()
+</script>
diff --git a/VueApp/src/Effort/pages/AuditList.vue b/VueApp/src/Effort/pages/AuditList.vue
index 7574edd91..051b8ac10 100644
--- a/VueApp/src/Effort/pages/AuditList.vue
+++ b/VueApp/src/Effort/pages/AuditList.vue
@@ -21,6 +21,7 @@
                                 option-label="termName"
                                 option-value="termCode"
                                 label="Term"
+                                :display-value="filter.termCode == null ? 'All terms' : undefined"
                                 dense
                                 options-dense
                                 outlined
@@ -35,6 +36,7 @@
                                 v-model="filter.action"
                                 :options="actions"
                                 label="Action"
+                                :display-value="filter.action == null ? 'All actions' : undefined"
                                 dense
                                 options-dense
                                 outlined
@@ -48,6 +50,8 @@
                                 option-label="fullName"
                                 option-value="personId"
                                 label="Modified By"
+                                stack-label
+                                placeholder="All users"
                                 dense
                                 options-dense
                                 outlined
@@ -66,6 +70,8 @@
                                 option-label="fullName"
                                 option-value="personId"
                                 label="Instructor"
+                                stack-label
+                                placeholder="All instructors"
                                 dense
                                 options-dense
                                 outlined
@@ -77,15 +83,6 @@
                                 @filter="filterInstructors"
                             />
                         </div>
-                        <div :class="$q.screen.gt.sm ? 'col-12 col-md-6 col-lg-3' : 'col-12'">
-                            <q-input
-                                v-model="filter.searchText"
-                                label="Search Changes"
-                                dense
-                                outlined
-                                clearable
-                            />
-                        </div>
                         <div :class="$q.screen.gt.sm ? 'col-12 col-md-6 col-lg-3' : 'col-6'">
                             <q-input
                                 v-model="filter.dateFrom"
@@ -111,6 +108,8 @@
                                 v-model="filter.subjectCode"
                                 :options="subjectCodes"
                                 label="Subject Code"
+                                stack-label
+                                placeholder="All subjects"
                                 dense
                                 options-dense
                                 outlined
@@ -124,6 +123,8 @@
                                 v-model="filter.courseNumber"
                                 :options="courseNumbers"
                                 label="Course Number"
+                                stack-label
+                                placeholder="All courses"
                                 dense
                                 options-dense
                                 outlined
@@ -148,6 +149,22 @@
             </q-card>
         </q-expansion-item>
 
+        <!-- Free-text search across change details, on top of the results table -->
+        <div class="row q-mb-md">
+            <q-input
+                v-model="filter.searchText"
+                :class="$q.screen.gt.sm ? 'col-12 col-md-6 col-lg-4' : 'col-12'"
+                label="Search changes"
+                dense
+                outlined
+                clearable
+            >
+                <template #prepend>
+                    <q-icon name="search" />
+                </template>
+            </q-input>
+        </div>
+
         <!-- Results Table - Desktop view (lg and up) -->
         <q-table
             v-if="$q.screen.gt.md"
@@ -290,27 +307,10 @@
                                     :key="key"
                                 >
                                     <span v-if="idx > 0"> &bull; </span>
-                                    <strong>{{ key }}:</strong>
-                                    <!-- Reference value (old === new): show once without diff styling -->
-                                    <template v-if="detail.oldValue === detail.newValue">
-                                        <span>{{ detail.oldValue }}</span>
-                                    </template>
-                                    <!-- Changed value: show old → new -->
-                                    <template v-else>
-                                        <span
-                                            v-if="detail.oldValue !== null"
-                                            class="text-negative"
-                                            >{{ detail.oldValue }}</span
-                                        >
-                                        <span v-if="detail.oldValue !== null && detail.newValue !== null">
-                                            &rarr;
-                                        </span>
-                                        <span
-                                            v-if="detail.newValue !== null"
-                                            class="text-positive"
-                                            >{{ detail.newValue }}</span
-                                        >
-                                    </template>
+                                    <AuditChangeDetail
+                                        :name="key"
+                                        :detail="detail"
+                                    />
                                 </span>
                             </div>
                             <span
@@ -389,27 +389,10 @@
                                     v-for="(detail, key) in props.row.changesDetail"
                                     :key="key"
                                 >
-                                    <strong>{{ key }}:</strong>
-                                    <!-- Reference value (old === new): show once without diff styling -->
-                                    <template v-if="detail.oldValue === detail.newValue">
-                                        <span>{{ detail.oldValue }}</span>
-                                    </template>
-                                    <!-- Changed value: show old → new -->
-                                    <template v-else>
-                                        <span
-                                            v-if="detail.oldValue !== null"
-                                            class="text-negative"
-                                            >{{ detail.oldValue }}</span
-                                        >
-                                        <span v-if="detail.oldValue !== null && detail.newValue !== null">
-                                            &rarr;
-                                        </span>
-                                        <span
-                                            v-if="detail.newValue !== null"
-                                            class="text-positive"
-                                            >{{ detail.newValue }}</span
-                                        >
-                                    </template>
+                                    <AuditChangeDetail
+                                        :name="String(key)"
+                                        :detail="detail"
+                                    />
                                 </div>
                             </div>
                             <div
@@ -437,6 +420,7 @@ import { effortAuditService } from "../services/audit-service"
 import { termService } from "../services/term-service"
 import { useDateFunctions } from "@/composables/DateFunctions"
 import StatusBadge from "@/components/StatusBadge.vue"
+import AuditChangeDetail from "../components/AuditChangeDetail.vue"
 import type { ChangeDetail, EffortAuditRow, ModifierInfo, TermDto } from "../types"
 
 // Constants
diff --git a/test/ClinicalScheduler/ScheduleAuditServiceTest.cs b/test/ClinicalScheduler/ScheduleAuditServiceTest.cs
index b3df5637f..ff4ab3218 100644
--- a/test/ClinicalScheduler/ScheduleAuditServiceTest.cs
+++ b/test/ClinicalScheduler/ScheduleAuditServiceTest.cs
@@ -121,6 +121,7 @@ public async Task GetInstructorScheduleAuditHistoryAsync_ReturnsAuditEntriesForS
             var auditEntry1 = CreateAuditEntry("test123", 1, 1, "modifier", ScheduleAuditActions.InstructorAdded);
             var auditEntry2 = CreateAuditEntry("test123", 1, 1, "modifier", ScheduleAuditActions.PrimaryEvaluatorSet);
             var auditEntry3 = CreateAuditEntry("other456", 2, 1, "modifier", ScheduleAuditActions.InstructorAdded); // Different rotation
+            var auditEntry4 = CreateAuditEntry("test123", 1, 1, "modifier", ScheduleAuditActions.InstructorAdded, ScheduleAuditAreas.Students); // Student area
 
             // Create an InstructorSchedule record first since the method looks it up
             await _context.InstructorSchedules.AddAsync(new InstructorSchedule
@@ -132,7 +133,7 @@ await _context.InstructorSchedules.AddAsync(new InstructorSchedule
                 Evaluator = false
             });
 
-            await _context.ScheduleAudits.AddRangeAsync(auditEntry1, auditEntry2, auditEntry3);
+            await _context.ScheduleAudits.AddRangeAsync(auditEntry1, auditEntry2, auditEntry3, auditEntry4);
             await _context.SaveChangesAsync();
 
             // Act
@@ -157,8 +158,9 @@ public async Task GetRotationWeekAuditHistoryAsync_ReturnsAuditEntriesForRotatio
             var auditEntry2 = CreateAuditEntry("test456", rotationId, weekId, "modifier", ScheduleAuditActions.InstructorRemoved);
             var auditEntry3 = CreateAuditEntry("test789", 2, weekId, "modifier", ScheduleAuditActions.InstructorAdded); // Different rotation
             var auditEntry4 = CreateAuditEntry("test321", rotationId, 2, "modifier", ScheduleAuditActions.InstructorAdded); // Different week
+            var auditEntry5 = CreateAuditEntry("student1", rotationId, weekId, "modifier", ScheduleAuditActions.InstructorAdded, ScheduleAuditAreas.Students); // Student area
 
-            await _context.ScheduleAudits.AddRangeAsync(auditEntry1, auditEntry2, auditEntry3, auditEntry4);
+            await _context.ScheduleAudits.AddRangeAsync(auditEntry1, auditEntry2, auditEntry3, auditEntry4, auditEntry5);
             await _context.SaveChangesAsync();
 
             // Act
@@ -175,6 +177,40 @@ public async Task GetRotationWeekAuditHistoryAsync_ReturnsAuditEntriesForRotatio
             Assert.Contains(result, entry => entry.MothraId == "test456");
         }
 
+        [Fact]
+        public async Task GetRotationWeekAuditAsync_ExcludesStudentAreaEntries()
+        {
+            // The shared audit table also records student schedule changes for the
+            // same rotation/week; the clinician-page popover must not show them.
+            var clinicianEntry = CreateAuditEntry("test123", 1, 1, "modifier", ScheduleAuditActions.InstructorAdded);
+            var studentEntry = CreateAuditEntry("student1", 1, 1, "modifier", ScheduleAuditActions.InstructorAdded, ScheduleAuditAreas.Students);
+            await _context.ScheduleAudits.AddRangeAsync(clinicianEntry, studentEntry);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+            var result = await _service.GetRotationWeekAuditAsync(1, 1, TestContext.Current.CancellationToken);
+
+            var entry = Assert.Single(result);
+            Assert.Equal("test123", entry.MothraId);
+            Assert.Equal(ScheduleAuditAreas.Clinicians, entry.Area);
+        }
+
+        [Fact]
+        public async Task GetClinicianWeekAuditAsync_ExcludesStudentAreaEntries()
+        {
+            // A clinician who was previously a UCD student must not see their
+            // student-era entries mixed into their clinician week history.
+            var clinicianEntry = CreateAuditEntry("test123", 1, 1, "modifier", ScheduleAuditActions.InstructorAdded);
+            var studentEntry = CreateAuditEntry("test123", 2, 1, "modifier", ScheduleAuditActions.InstructorAdded, ScheduleAuditAreas.Students);
+            await _context.ScheduleAudits.AddRangeAsync(clinicianEntry, studentEntry);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+            var result = await _service.GetClinicianWeekAuditAsync("test123", 1, TestContext.Current.CancellationToken);
+
+            var entry = Assert.Single(result);
+            Assert.Equal(1, entry.RotationId);
+            Assert.Equal(ScheduleAuditAreas.Clinicians, entry.Area);
+        }
+
         [Fact]
         public async Task GetInstructorScheduleAuditHistoryAsync_EmptyResult_ReturnsEmptyList()
         {
@@ -202,7 +238,7 @@ public async Task GetRotationWeekAuditHistoryAsync_EmptyResult_ReturnsEmptyList(
             Assert.Empty(result);
         }
 
-        private ScheduleAudit CreateAuditEntry(string mothraId, int rotationId, int weekId, string modifiedBy, string action)
+        private ScheduleAudit CreateAuditEntry(string mothraId, int rotationId, int weekId, string modifiedBy, string action, string area = ScheduleAuditAreas.Clinicians)
         {
             return new ScheduleAudit
             {
@@ -212,7 +248,7 @@ private ScheduleAudit CreateAuditEntry(string mothraId, int rotationId, int week
                 Action = action,
                 ModifiedBy = modifiedBy,
                 TimeStamp = DateTime.UtcNow,
-                Area = "Clinicians"
+                Area = area
             };
         }
 
diff --git a/test/ClinicalScheduler/ScheduleEditServiceRollbackTest.cs b/test/ClinicalScheduler/ScheduleEditServiceRollbackTest.cs
new file mode 100644
index 000000000..7d08884f6
--- /dev/null
+++ b/test/ClinicalScheduler/ScheduleEditServiceRollbackTest.cs
@@ -0,0 +1,149 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+using Viper.Areas.ClinicalScheduler.Services;
+using Viper.Classes.SQLContext;
+using Viper.EmailTemplates.Services;
+using Viper.Services;
+
+namespace Viper.test.ClinicalScheduler
+{
+    /// <summary>
+    /// Runs the real ScheduleEditService (with its production transaction handling)
+    /// against SQLite, which supports transactions, unlike the in-memory provider
+    /// used by ScheduleEditServiceTest via TestableScheduleEditService. These tests
+    /// prove a failed audit write rolls the schedule change back, not just that the
+    /// exception surfaces.
+    /// </summary>
+    public class ScheduleEditServiceRollbackTest : IDisposable
+    {
+        private readonly SqliteConnection _connection;
+        private readonly ClinicalSchedulerContext _context;
+        private readonly IScheduleAuditService _mockAuditService;
+        private readonly ScheduleEditService _service;
+        private bool _disposed;
+
+        public ScheduleEditServiceRollbackTest()
+        {
+            _connection = new SqliteConnection("Filename=:memory:");
+            _connection.Open();
+            var options = new DbContextOptionsBuilder<ClinicalSchedulerContext>()
+                .UseSqlite(_connection)
+                .Options;
+            _context = new ClinicalSchedulerContext(options);
+            _context.Database.EnsureCreated();
+
+            var gradYear = DateTime.Now.Year + 1;
+            _context.Services.Add(TestDataBuilder.CreateService(1, "Cardiology"));
+            _context.Rotations.Add(TestDataBuilder.CreateRotation(1, "Cardiology Rotation", 1));
+            var (week, weekGradYear) = TestDataBuilder.CreateWeekScenario(1, gradYear);
+            _context.Weeks.Add(week);
+            _context.WeekGradYears.Add(weekGradYear);
+            _context.Persons.Add(TestDataBuilder.CreatePerson("test123"));
+            _context.SaveChanges();
+
+            _mockAuditService = Substitute.For<IScheduleAuditService>();
+
+            var permissionValidator = Substitute.For<IPermissionValidator>();
+            permissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(TestDataBuilder.CreateUser("currentuser"));
+
+            var gradYearService = Substitute.For<IGradYearService>();
+            gradYearService.GetCurrentGradYearAsync().Returns(DateTime.Now.Year);
+
+            var emailNotificationOptions = Substitute.For<IOptions<EmailNotificationSettings>>();
+            emailNotificationOptions.Value.Returns(new EmailNotificationSettings());
+            var emailSettingsOptions = Substitute.For<IOptions<EmailSettings>>();
+            emailSettingsOptions.Value.Returns(new EmailSettings());
+
+            _service = new ScheduleEditService(
+                _context,
+                _mockAuditService,
+                Substitute.For<ILogger<ScheduleEditService>>(),
+                Substitute.For<IEmailService>(),
+                emailNotificationOptions,
+                emailSettingsOptions,
+                gradYearService,
+                permissionValidator,
+                Substitute.For<IEmailTemplateRenderer>());
+        }
+
+        [Fact]
+        public async Task AddInstructorAsync_AuditWriteFails_RollsBackScheduleInsert()
+        {
+            _mockAuditService.LogInstructorAddedAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
+                Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .ThrowsAsync(new InvalidOperationException("Failed to create audit entry"));
+
+            await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                _service.AddInstructorAsync("test123", 1, new[] { 1 }, DateTime.Now.Year + 1, false, TestContext.Current.CancellationToken));
+
+            // The insert committed nothing: the schedule row must not survive the rollback
+            Assert.Empty(await _context.InstructorSchedules.AsNoTracking().ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task RemoveInstructorScheduleAsync_AuditWriteFails_RollsBackDelete()
+        {
+            var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
+            _context.InstructorSchedules.Add(schedule);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+            _mockAuditService.LogInstructorRemovedAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
+                Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .ThrowsAsync(new InvalidOperationException("Failed to create audit entry"));
+
+            await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId, TestContext.Current.CancellationToken));
+
+            // The delete rolled back: no unaudited removals
+            Assert.NotNull(await _context.InstructorSchedules.AsNoTracking()
+                .FirstOrDefaultAsync(s => s.InstructorScheduleId == schedule.InstructorScheduleId, TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task SetPrimaryEvaluatorAsync_AuditWriteFails_RollsBackEvaluatorFlag()
+        {
+            var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
+            _context.InstructorSchedules.Add(schedule);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+            _mockAuditService.LogPrimaryEvaluatorSetAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
+                Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .ThrowsAsync(new InvalidOperationException("Failed to create audit entry"));
+
+            await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                _service.SetPrimaryEvaluatorAsync(schedule.InstructorScheduleId, true, TestContext.Current.CancellationToken));
+
+            // The flag update rolled back
+            var reloaded = await _context.InstructorSchedules.AsNoTracking()
+                .FirstAsync(s => s.InstructorScheduleId == schedule.InstructorScheduleId, TestContext.Current.CancellationToken);
+            Assert.False(reloaded.Evaluator);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _context.Dispose();
+                _connection.Dispose();
+            }
+
+            _disposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}
diff --git a/test/ClinicalScheduler/ScheduleEditServiceTest.cs b/test/ClinicalScheduler/ScheduleEditServiceTest.cs
index 06f14baa3..999376d16 100644
--- a/test/ClinicalScheduler/ScheduleEditServiceTest.cs
+++ b/test/ClinicalScheduler/ScheduleEditServiceTest.cs
@@ -206,6 +206,69 @@ await _mockAuditService.Received(2).LogInstructorAddedAsync(mothraId, rotationId
                 user.MothraId, Arg.Any<CancellationToken>());
         }
 
+        [Fact]
+        public async Task AddInstructorAsync_AuditWriteFails_ThrowsInsteadOfSwallowing()
+        {
+            // Audit writes run inside the schedule transaction, so a failed audit
+            // must fail the whole operation (rolled back in production) rather
+            // than being silently swallowed.
+            var user = TestDataBuilder.CreateUser("currentuser");
+            _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(user);
+            _mockAuditService.LogInstructorAddedAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
+                Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .ThrowsAsync(new InvalidOperationException("Failed to create audit entry"));
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                _service.AddInstructorAsync("test123", 1, new[] { 1 }, DateTime.Now.Year + 1, false, TestContext.Current.CancellationToken));
+
+            Assert.Contains("audit", ex.Message, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Fact]
+        public async Task RemoveInstructorScheduleAsync_AuditWriteFails_ThrowsInsteadOfSwallowing()
+        {
+            // Same fail-closed guarantee for removals: no unaudited deletes.
+            var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+            var user = TestDataBuilder.CreateUser("currentuser");
+            _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(user);
+            _mockAuditService.LogInstructorRemovedAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
+                Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .ThrowsAsync(new InvalidOperationException("Failed to create audit entry"));
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId, TestContext.Current.CancellationToken));
+
+            Assert.Contains("audit", ex.Message, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Fact]
+        public async Task SetPrimaryEvaluatorAsync_AuditWriteFails_ThrowsInsteadOfSwallowing()
+        {
+            // Same fail-closed guarantee for primary evaluator changes. This method wraps
+            // failures in its generic operation-failed message, so the audit cause is
+            // asserted on the inner exception.
+            var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+            var user = TestDataBuilder.CreateUser("currentuser");
+            _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(user);
+            _mockAuditService.LogPrimaryEvaluatorSetAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
+                Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .ThrowsAsync(new InvalidOperationException("Failed to create audit entry"));
+
+            var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                _service.SetPrimaryEvaluatorAsync(schedule.InstructorScheduleId, true, TestContext.Current.CancellationToken));
+
+            Assert.Contains("audit", ex.InnerException!.Message, StringComparison.OrdinalIgnoreCase);
+        }
+
         [Fact]
         public async Task AddInstructorAsync_WithPrimaryEvaluator_ClearsPreviousPrimaryAndSetsNew()
         {
@@ -218,8 +281,8 @@ public async Task AddInstructorAsync_WithPrimaryEvaluator_ClearsPreviousPrimaryA
 
             // Create existing primary evaluator
             var existingPrimary = TestDataBuilder.CreateInstructorSchedule("existing456", rotationId, weekId, true);
-            await _context.InstructorSchedules.AddAsync(existingPrimary);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(existingPrimary, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Override default permission validator to return the specific user for this test
             _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
@@ -244,7 +307,7 @@ public async Task AddInstructorAsync_WithPrimaryEvaluator_ClearsPreviousPrimaryA
             Assert.True(newSchedule.Evaluator);
 
             // Check that existing primary evaluator was cleared
-            var updatedExisting = await _context.InstructorSchedules.FindAsync(existingPrimary.InstructorScheduleId);
+            var updatedExisting = await _context.InstructorSchedules.FindAsync(new object?[] { existingPrimary.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.False(updatedExisting!.Evaluator);
 
             // Verify audit logging
@@ -349,8 +412,8 @@ public async Task RemoveInstructorScheduleAsync_WithoutPermissionForOwnSchedule_
         {
             // Arrange - User tries to remove their own schedule but lacks EditOwnSchedule permission
             var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
-            await _context.InstructorSchedules.AddAsync(schedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Set up audit service mock
             _mockAuditService.LogInstructorRemovedAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
@@ -363,7 +426,7 @@ public async Task RemoveInstructorScheduleAsync_WithoutPermissionForOwnSchedule_
 
             // Act & Assert - Should throw UnauthorizedAccessException
             var exception = await Assert.ThrowsAsync<UnauthorizedAccessException>(() =>
-                _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId));
+                _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId, TestContext.Current.CancellationToken));
 
             Assert.Contains("does not have permission", exception.Message);
         }
@@ -373,8 +436,8 @@ public async Task RemoveInstructorScheduleAsync_UserTriesToRemoveOtherUserSchedu
         {
             // Arrange - User tries to remove another user's schedule without general rotation permission
             var schedule = TestDataBuilder.CreateInstructorSchedule("other456", 1, 1);
-            await _context.InstructorSchedules.AddAsync(schedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Set up audit service mock
             _mockAuditService.LogInstructorRemovedAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<int>(),
@@ -387,7 +450,7 @@ public async Task RemoveInstructorScheduleAsync_UserTriesToRemoveOtherUserSchedu
 
             // Act & Assert - Should throw UnauthorizedAccessException
             var exception = await Assert.ThrowsAsync<UnauthorizedAccessException>(() =>
-                _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId));
+                _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId, TestContext.Current.CancellationToken));
 
             Assert.Contains("does not have permission", exception.Message);
         }
@@ -404,8 +467,8 @@ public async Task AddInstructorAsync_WithScheduleConflicts_ThrowsInvalidOperatio
 
             // Create conflicting schedule - same instructor, same rotation, same week
             var conflictingSchedule = TestDataBuilder.CreateInstructorSchedule(mothraId, rotationId, weekId);
-            await _context.InstructorSchedules.AddAsync(conflictingSchedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(conflictingSchedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Override default permission validator to return the specific user for this test
             _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
@@ -483,8 +546,8 @@ public async Task RemoveInstructorScheduleAsync_ValidSchedule_RemovesSuccessfull
         {
             // Arrange
             var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
-            await _context.InstructorSchedules.AddAsync(schedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             var user = TestDataBuilder.CreateUser("currentuser");
             _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
@@ -494,11 +557,11 @@ public async Task RemoveInstructorScheduleAsync_ValidSchedule_RemovesSuccessfull
                 .Returns(new ScheduleAudit());
 
             // Act
-            var result = await _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId);
+            var result = await _service.RemoveInstructorScheduleAsync(schedule.InstructorScheduleId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result.success);
-            var removedSchedule = await _context.InstructorSchedules.FindAsync(schedule.InstructorScheduleId);
+            var removedSchedule = await _context.InstructorSchedules.FindAsync(new object?[] { schedule.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.Null(removedSchedule);
 
             // Verify the permission validator was called
@@ -517,7 +580,7 @@ public async Task RemoveInstructorScheduleAsync_PrimaryEvaluatorWithOtherInstruc
             var otherSchedule = TestDataBuilder.CreateInstructorSchedule("other456", 1, 1);
 
             await _context.InstructorSchedules.AddRangeAsync(primarySchedule, otherSchedule);
-            await _context.SaveChangesAsync();
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             var user = TestDataBuilder.CreateUser("currentuser");
             _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
@@ -530,11 +593,11 @@ public async Task RemoveInstructorScheduleAsync_PrimaryEvaluatorWithOtherInstruc
                 .Returns(new ScheduleAudit());
 
             // Act
-            var result = await _service.RemoveInstructorScheduleAsync(primarySchedule.InstructorScheduleId);
+            var result = await _service.RemoveInstructorScheduleAsync(primarySchedule.InstructorScheduleId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result.success);
-            var removedSchedule = await _context.InstructorSchedules.FindAsync(primarySchedule.InstructorScheduleId);
+            var removedSchedule = await _context.InstructorSchedules.FindAsync(new object?[] { primarySchedule.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.Null(removedSchedule);
 
             // Verify primary evaluator unset audit log
@@ -547,8 +610,8 @@ public async Task RemoveInstructorScheduleAsync_PrimaryEvaluatorWithoutOtherInst
         {
             // Arrange
             var primarySchedule = TestDataBuilder.CreateInstructorSchedule("primary123", 2, 2, true);
-            await _context.InstructorSchedules.AddAsync(primarySchedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(primarySchedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             var user = TestDataBuilder.CreateUser("currentuser");
             _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(2, "primary123", Arg.Any<CancellationToken>())
@@ -561,11 +624,11 @@ public async Task RemoveInstructorScheduleAsync_PrimaryEvaluatorWithoutOtherInst
                 .Returns(new ScheduleAudit());
 
             // Act
-            var result = await _service.RemoveInstructorScheduleAsync(primarySchedule.InstructorScheduleId);
+            var result = await _service.RemoveInstructorScheduleAsync(primarySchedule.InstructorScheduleId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result.success);
-            var removedSchedule = await _context.InstructorSchedules.FindAsync(primarySchedule.InstructorScheduleId);
+            var removedSchedule = await _context.InstructorSchedules.FindAsync(new object?[] { primarySchedule.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.Null(removedSchedule);
         }
 
@@ -574,8 +637,8 @@ public async Task SetPrimaryEvaluatorAsync_ValidSchedule_UpdatesSuccessfully()
         {
             // Arrange
             var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
-            await _context.InstructorSchedules.AddAsync(schedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             var user = TestDataBuilder.CreateUser("currentuser");
             _mockPermissionValidator.ValidateEditPermissionAndGetUserAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
@@ -585,11 +648,11 @@ public async Task SetPrimaryEvaluatorAsync_ValidSchedule_UpdatesSuccessfully()
                 .Returns(new ScheduleAudit());
 
             // Act
-            var result = await _service.SetPrimaryEvaluatorAsync(schedule.InstructorScheduleId, true);
+            var result = await _service.SetPrimaryEvaluatorAsync(schedule.InstructorScheduleId, true, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result.success);
-            var updatedSchedule = await _context.InstructorSchedules.FindAsync(schedule.InstructorScheduleId);
+            var updatedSchedule = await _context.InstructorSchedules.FindAsync(new object?[] { schedule.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.True(updatedSchedule!.Evaluator);
 
             // Verify audit logging
@@ -602,11 +665,11 @@ public async Task CanRemoveInstructorAsync_NonPrimaryEvaluator_ReturnsTrue()
         {
             // Arrange
             var schedule = TestDataBuilder.CreateInstructorSchedule("test123", 1, 1);
-            await _context.InstructorSchedules.AddAsync(schedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(schedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act
-            var result = await _service.CanRemoveInstructorAsync(schedule.InstructorScheduleId);
+            var result = await _service.CanRemoveInstructorAsync(schedule.InstructorScheduleId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result);
@@ -620,10 +683,10 @@ public async Task CanRemoveInstructorAsync_PrimaryEvaluatorWithOtherInstructors_
             var otherSchedule = TestDataBuilder.CreateInstructorSchedule("other456", 1, 1);
 
             await _context.InstructorSchedules.AddRangeAsync(primarySchedule, otherSchedule);
-            await _context.SaveChangesAsync();
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act
-            var result = await _service.CanRemoveInstructorAsync(primarySchedule.InstructorScheduleId);
+            var result = await _service.CanRemoveInstructorAsync(primarySchedule.InstructorScheduleId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result);
@@ -634,11 +697,11 @@ public async Task CanRemoveInstructorAsync_PrimaryEvaluatorWithoutOtherInstructo
         {
             // Arrange
             var primarySchedule = TestDataBuilder.CreateInstructorSchedule("primary123", 2, 2, true);
-            await _context.InstructorSchedules.AddAsync(primarySchedule);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(primarySchedule, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act
-            var result = await _service.CanRemoveInstructorAsync(primarySchedule.InstructorScheduleId);
+            var result = await _service.CanRemoveInstructorAsync(primarySchedule.InstructorScheduleId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result);
@@ -655,11 +718,11 @@ public async Task GetOtherRotationSchedulesAsync_WithConflicts_ReturnsConflictin
             var conflictSchedule2 = TestDataBuilder.CreateInstructorSchedule(mothraId, 2, 2);
 
             await _context.InstructorSchedules.AddRangeAsync(conflictSchedule1, conflictSchedule2);
-            await _context.SaveChangesAsync();
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act
             var testYear = DateTime.Now.Year + 1;
-            var result = await _service.GetOtherRotationSchedulesAsync(mothraId, weekIds, testYear);
+            var result = await _service.GetOtherRotationSchedulesAsync(mothraId, weekIds, testYear, cancellationToken: TestContext.Current.CancellationToken);
 
             // Assert
             Assert.Equal(2, result.Count);
@@ -678,11 +741,11 @@ public async Task GetOtherRotationSchedulesAsync_WithExcludedRotation_ExcludesSp
             var excludedSchedule = TestDataBuilder.CreateInstructorSchedule(mothraId, 2, 1);
 
             await _context.InstructorSchedules.AddRangeAsync(includedSchedule, excludedSchedule);
-            await _context.SaveChangesAsync();
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act
             var testYear = DateTime.Now.Year + 1;
-            var result = await _service.GetOtherRotationSchedulesAsync(mothraId, weekIds, testYear, excludeRotationId);
+            var result = await _service.GetOtherRotationSchedulesAsync(mothraId, weekIds, testYear, excludeRotationId, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.Single(result);
@@ -695,8 +758,8 @@ public async Task GetOtherRotationSchedulesAsync_NoConflicts_ReturnsEmptyList()
             // Arrange
             // Create instructor schedule for different weeks (no conflicts)
             var scheduleNoConflict = TestDataBuilder.CreateInstructorSchedule("12345", 1, 5);
-            await _context.InstructorSchedules.AddAsync(scheduleNoConflict);
-            await _context.SaveChangesAsync();
+            await _context.InstructorSchedules.AddAsync(scheduleNoConflict, TestContext.Current.CancellationToken);
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act - Check for conflicts on different weeks
             var testYear = DateTime.Now.Year + 1;
@@ -715,7 +778,7 @@ public async Task GetOtherRotationSchedulesAsync_WithMultipleConflicts_ReturnsAl
             var schedule2 = TestDataBuilder.CreateInstructorSchedule("12345", 2, 15);
             var schedule3 = TestDataBuilder.CreateInstructorSchedule("12345", 3, 20);
             await _context.InstructorSchedules.AddRangeAsync(schedule1, schedule2, schedule3);
-            await _context.SaveChangesAsync();
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             // Act - Check for conflicts on all these weeks for a different rotation
             var testYear = DateTime.Now.Year + 1;
@@ -740,7 +803,7 @@ public async Task SetPrimaryEvaluatorAsync_SwitchPrimaryEvaluator_ClearsOldAndSe
             var instructor2 = TestDataBuilder.CreateInstructorSchedule("test456", rotationId, weekId); // Not primary
 
             await _context.InstructorSchedules.AddRangeAsync(instructor1, instructor2);
-            await _context.SaveChangesAsync();
+            await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
             var user = TestDataBuilder.CreateUser("currentuser");
             _mockUserHelper.GetCurrentUser().Returns(user);
@@ -751,17 +814,17 @@ public async Task SetPrimaryEvaluatorAsync_SwitchPrimaryEvaluator_ClearsOldAndSe
                 .Returns(new ScheduleAudit());
 
             // Act - Switch primary evaluator from instructor1 to instructor2
-            var result = await _service.SetPrimaryEvaluatorAsync(instructor2.InstructorScheduleId, true);
+            var result = await _service.SetPrimaryEvaluatorAsync(instructor2.InstructorScheduleId, true, TestContext.Current.CancellationToken);
 
             // Assert
             Assert.True(result.success);
 
             // Verify instructor1 is no longer primary
-            var updatedInstructor1 = await _context.InstructorSchedules.FindAsync(instructor1.InstructorScheduleId);
+            var updatedInstructor1 = await _context.InstructorSchedules.FindAsync(new object?[] { instructor1.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.False(updatedInstructor1!.Evaluator);
 
             // Verify instructor2 is now primary
-            var updatedInstructor2 = await _context.InstructorSchedules.FindAsync(instructor2.InstructorScheduleId);
+            var updatedInstructor2 = await _context.InstructorSchedules.FindAsync(new object?[] { instructor2.InstructorScheduleId }, TestContext.Current.CancellationToken);
             Assert.True(updatedInstructor2!.Evaluator);
         }
 
diff --git a/web/Areas/ClinicalScheduler/Controllers/ScheduleAuditController.cs b/web/Areas/ClinicalScheduler/Controllers/ScheduleAuditController.cs
new file mode 100644
index 000000000..431fd3027
--- /dev/null
+++ b/web/Areas/ClinicalScheduler/Controllers/ScheduleAuditController.cs
@@ -0,0 +1,206 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Viper.Areas.ClinicalScheduler.Models.DTOs.Responses;
+using Viper.Areas.ClinicalScheduler.Services;
+using Viper.Classes.Utilities;
+using Web.Authorization;
+
+namespace Viper.Areas.ClinicalScheduler.Controllers
+{
+    /// <summary>
+    /// Read-only access to the schedule-change audit log. Replaces the legacy
+    /// "Schedule Changes Audit log" page and is gated by the same Manage permission.
+    /// </summary>
+    [Route("api/clinicalscheduler/audit")]
+    [ApiController]
+    [Permission(Allow = ClinicalSchedulePermissions.Manage)]
+    public class ScheduleAuditController : BaseClinicalSchedulerController
+    {
+        private readonly IScheduleAuditService _auditService;
+
+        public ScheduleAuditController(
+            IScheduleAuditService auditService,
+            IGradYearService gradYearService,
+            ILogger<ScheduleAuditController> logger)
+            : base(gradYearService, logger)
+        {
+            _auditService = auditService;
+        }
+
+        /// <summary>
+        /// Get the filtered audit log for a grad year (defaults to the current grad year).
+        /// </summary>
+        /// <param name="year">Grad year; defaults to the current grad year when omitted</param>
+        /// <param name="rotationId">Optional rotation filter</param>
+        /// <param name="termCode">Optional term (semester) filter, scoped to the grad year</param>
+        /// <param name="person">Optional MothraID of the affected student/clinician</param>
+        /// <param name="modifiedBy">Optional MothraID of the user who made the change</param>
+        /// <param name="area">Optional area filter (Students / Clinicians)</param>
+        /// <param name="from">Optional inclusive lower bound on the change date</param>
+        /// <param name="to">Optional inclusive upper bound on the change date</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        [HttpGet]
+        [ProducesResponseType(typeof(List<AuditLogEntryDto>), 200)]
+        public async Task<IActionResult> GetAuditLog(
+            [FromQuery] int? year = null,
+            [FromQuery] int? rotationId = null,
+            [FromQuery] int? termCode = null,
+            [FromQuery] string? person = null,
+            [FromQuery] string? modifiedBy = null,
+            [FromQuery] string? area = null,
+            [FromQuery] DateTime? from = null,
+            [FromQuery] DateTime? to = null,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var gradYear = await GetTargetYearAsync(year);
+                var log = await _auditService.GetAuditLogAsync(
+                    gradYear, rotationId, termCode, person, modifiedBy, area, from, to, cancellationToken);
+                return Ok(log);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit log for year {Year}", LogSanitizer.SanitizeYear(year));
+                return StatusCode(500, "An error occurred while retrieving the audit log");
+            }
+        }
+
+        /// <summary>
+        /// Get the terms (semesters) within a grad year, for the audit trail "Term" filter.
+        /// </summary>
+        /// <param name="year">Grad year; defaults to the current grad year when omitted</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        [HttpGet("terms")]
+        [ProducesResponseType(typeof(List<AuditTermDto>), 200)]
+        public async Task<IActionResult> GetTerms(
+            [FromQuery] int? year = null,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var gradYear = await GetTargetYearAsync(year);
+                var terms = await _auditService.GetAuditTermsAsync(gradYear, cancellationToken);
+                return Ok(terms);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit terms for year {Year}", LogSanitizer.SanitizeYear(year));
+                return StatusCode(500, "An error occurred while retrieving the terms");
+            }
+        }
+
+        /// <summary>
+        /// Get the distinct users who have made audited schedule changes, for the "Modified By" filter.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token</param>
+        [HttpGet("modifiers")]
+        [ProducesResponseType(typeof(List<AuditModifierDto>), 200)]
+        public async Task<IActionResult> GetModifiers(CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var modifiers = await _auditService.GetAuditModifiersAsync(cancellationToken);
+                return Ok(modifiers);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit log modifiers");
+                return StatusCode(500, "An error occurred while retrieving the audit modifiers");
+            }
+        }
+
+        /// <summary>
+        /// Get the distinct affected students/clinicians in the audit trail, for the "Person" filter.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token</param>
+        [HttpGet("persons")]
+        [ProducesResponseType(typeof(List<AuditModifierDto>), 200)]
+        public async Task<IActionResult> GetPersons(CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var persons = await _auditService.GetAuditPersonsAsync(cancellationToken);
+                return Ok(persons);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit log persons");
+                return StatusCode(500, "An error occurred while retrieving the audited persons");
+            }
+        }
+
+        /// <summary>
+        /// Get the audit trail for a single rotation + week (inline per-week audit popover,
+        /// Schedule-by-Rotation grid).
+        /// </summary>
+        /// <param name="rotationId">Rotation the week belongs to</param>
+        /// <param name="weekId">Week to scope the history to</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        [HttpGet("rotation-week")]
+        [ProducesResponseType(typeof(List<AuditLogEntryDto>), 200)]
+        public async Task<IActionResult> GetRotationWeekHistory(
+            [FromQuery] int rotationId,
+            [FromQuery] int weekId,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                if (rotationId <= 0)
+                {
+                    return BadRequest("A valid rotation is required.");
+                }
+
+                if (weekId <= 0)
+                {
+                    return BadRequest("A valid week is required.");
+                }
+
+                var history = await _auditService.GetRotationWeekAuditAsync(rotationId, weekId, cancellationToken);
+                return Ok(history);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit history for rotation {RotationId}, week {WeekId}", rotationId, weekId);
+                return StatusCode(500, "An error occurred while retrieving the week's audit trail");
+            }
+        }
+
+        /// <summary>
+        /// Get the audit trail for a single clinician + week across all rotations (inline
+        /// per-week audit popover, Schedule-by-Clinician grid).
+        /// </summary>
+        /// <param name="mothraId">MothraID of the affected clinician</param>
+        /// <param name="weekId">Week to scope the history to</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        [HttpGet("clinician-week")]
+        [ProducesResponseType(typeof(List<AuditLogEntryDto>), 200)]
+        public async Task<IActionResult> GetClinicianWeekHistory(
+            [FromQuery] string mothraId,
+            [FromQuery] int weekId,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(mothraId))
+                {
+                    return BadRequest("A clinician (mothraId) is required.");
+                }
+
+                if (weekId <= 0)
+                {
+                    return BadRequest("A valid week is required.");
+                }
+
+                var history = await _auditService.GetClinicianWeekAuditAsync(mothraId, weekId, cancellationToken);
+                return Ok(history);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit history for clinician {MothraId}, week {WeekId}", LogSanitizer.SanitizeString(mothraId), weekId);
+                return StatusCode(500, "An error occurred while retrieving the week's audit trail");
+            }
+        }
+    }
+}
diff --git a/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditLogEntryDto.cs b/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditLogEntryDto.cs
new file mode 100644
index 000000000..0de4e9ed3
--- /dev/null
+++ b/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditLogEntryDto.cs
@@ -0,0 +1,26 @@
+namespace Viper.Areas.ClinicalScheduler.Models.DTOs.Responses
+{
+    /// <summary>
+    /// A single schedule-change audit entry, enriched with display names for the
+    /// affected person, modifier, rotation, and week. Mirrors the legacy "Schedule
+    /// Changes Audit log" row (Area / Person / Action / Rotation / Week / Modified By / Date).
+    /// </summary>
+    public class AuditLogEntryDto
+    {
+        public int ScheduleAuditId { get; set; }
+        public string Area { get; set; } = string.Empty;
+        public string? MothraId { get; set; }
+        public string PersonName { get; set; } = string.Empty;
+        public string Action { get; set; } = string.Empty;
+        public int? RotationId { get; set; }
+        public string RotationName { get; set; } = string.Empty;
+        public int? WeekId { get; set; }
+        public int WeekNum { get; set; }
+        public DateTime? WeekStart { get; set; }
+        public int TermCode { get; set; }
+        public string Term { get; set; } = string.Empty;
+        public string ModifiedBy { get; set; } = string.Empty;
+        public string ModifiedByName { get; set; } = string.Empty;
+        public DateTime TimeStamp { get; set; }
+    }
+}
diff --git a/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditModifierDto.cs b/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditModifierDto.cs
new file mode 100644
index 000000000..c36362de3
--- /dev/null
+++ b/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditModifierDto.cs
@@ -0,0 +1,13 @@
+namespace Viper.Areas.ClinicalScheduler.Models.DTOs.Responses
+{
+    /// <summary>
+    /// A distinct person referenced by an audited schedule change, used to populate the
+    /// audit trail's person picklists — both "Modified By" (the user who made the change)
+    /// and "Person" (the affected student/clinician).
+    /// </summary>
+    public class AuditModifierDto
+    {
+        public string MothraId { get; set; } = string.Empty;
+        public string DisplayName { get; set; } = string.Empty;
+    }
+}
diff --git a/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditTermDto.cs b/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditTermDto.cs
new file mode 100644
index 000000000..ca1ef5851
--- /dev/null
+++ b/web/Areas/ClinicalScheduler/Models/DTOs/Responses/AuditTermDto.cs
@@ -0,0 +1,11 @@
+namespace Viper.Areas.ClinicalScheduler.Models.DTOs.Responses
+{
+    /// <summary>
+    /// A selectable term (semester) option for the audit trail "Term" filter, scoped to a grad year.
+    /// </summary>
+    public class AuditTermDto
+    {
+        public int TermCode { get; set; }
+        public string Term { get; set; } = string.Empty;
+    }
+}
diff --git a/web/Areas/ClinicalScheduler/Services/ClinicalSchedulerNavMenu.cs b/web/Areas/ClinicalScheduler/Services/ClinicalSchedulerNavMenu.cs
index 8136d1d26..66b58e1fc 100644
--- a/web/Areas/ClinicalScheduler/Services/ClinicalSchedulerNavMenu.cs
+++ b/web/Areas/ClinicalScheduler/Services/ClinicalSchedulerNavMenu.cs
@@ -20,6 +20,7 @@ public async Task<NavMenu> Nav(CancellationToken cancellationToken = default)
             var userHelper = new UserHelper();
             var user = userHelper.GetCurrentUser();
             var hasAccess = userHelper.HasPermission(_rapsContext, user, ClinicalSchedulePermissions.Base);
+            var hasManage = userHelper.HasPermission(_rapsContext, user, ClinicalSchedulePermissions.Manage);
 
             var nav = new List<NavMenuItem>
             {
@@ -44,6 +45,12 @@ public async Task<NavMenu> Nav(CancellationToken cancellationToken = default)
                     nav.Add(new NavMenuItem { MenuItemText = clinicianLabel, MenuItemURL = "~/ClinicalScheduler/clinician", IndentLevel = 1 });
                 }
 
+                if (hasManage)
+                {
+                    nav.Add(new NavMenuItem { MenuItemText = "Audit Trail", MenuItemURL = "~/ClinicalScheduler/audit", IndentLevel = 1 });
+                }
+
+
                 nav.Add(new NavMenuItem { MenuItemText = "Clinical Scheduler 1.0", MenuItemURL = $"{oldViperUrl}/clinicalScheduler/" });
             }
 
diff --git a/web/Areas/ClinicalScheduler/Services/IScheduleAuditService.cs b/web/Areas/ClinicalScheduler/Services/IScheduleAuditService.cs
index 60daf7577..58f20ec41 100644
--- a/web/Areas/ClinicalScheduler/Services/IScheduleAuditService.cs
+++ b/web/Areas/ClinicalScheduler/Services/IScheduleAuditService.cs
@@ -1,3 +1,4 @@
+using Viper.Areas.ClinicalScheduler.Models.DTOs.Responses;
 using Viper.Models.ClinicalScheduler;
 
 namespace Viper.Areas.ClinicalScheduler.Services
@@ -93,6 +94,87 @@ Task<List<ScheduleAudit>> GetRotationWeekAuditHistoryAsync(
             int weekId,
             CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Get a filtered, display-ready audit log for a grad year.
+        /// Mirrors the legacy "Schedule Changes Audit log" page query.
+        /// </summary>
+        /// <param name="gradYear">Grad year to scope results to (via the week's grad year)</param>
+        /// <param name="rotationId">Optional rotation filter</param>
+        /// <param name="termCode">Optional term (semester) filter, scoped to the grad year</param>
+        /// <param name="person">Optional MothraID of the affected student/clinician</param>
+        /// <param name="modifiedBy">Optional MothraID of the user who made the change</param>
+        /// <param name="area">Optional area filter (Students / Clinicians)</param>
+        /// <param name="fromDate">Optional inclusive lower bound on the change timestamp</param>
+        /// <param name="toDate">Optional inclusive upper bound on the change timestamp</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Up to 2500 enriched audit entries, newest first</returns>
+        Task<List<AuditLogEntryDto>> GetAuditLogAsync(
+            int gradYear,
+            int? rotationId,
+            int? termCode,
+            string? person,
+            string? modifiedBy,
+            string? area,
+            DateTime? fromDate,
+            DateTime? toDate,
+            CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Get the distinct terms (semesters) that fall within a grad year, for the audit
+        /// trail "Term" filter.
+        /// </summary>
+        /// <param name="gradYear">Grad year to scope the terms to</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Distinct terms ordered chronologically</returns>
+        Task<List<AuditTermDto>> GetAuditTermsAsync(
+            int gradYear,
+            CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Get the distinct set of users who have made an audited schedule change,
+        /// used to populate the audit trail "Modified By" filter.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Distinct modifiers ordered by display name</returns>
+        Task<List<AuditModifierDto>> GetAuditModifiersAsync(
+            CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Get the distinct set of affected students/clinicians that appear in the audit
+        /// trail, used to populate the audit trail "Person" filter.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Distinct affected persons ordered by display name</returns>
+        Task<List<AuditModifierDto>> GetAuditPersonsAsync(
+            CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Get the display-ready audit trail for a single rotation + week, newest first.
+        /// Powers the inline per-week audit popover in the Schedule-by-Rotation grid.
+        /// </summary>
+        /// <param name="rotationId">Rotation the week belongs to</param>
+        /// <param name="weekId">Week to scope the history to</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Enriched audit entries for the rotation/week, newest first</returns>
+        Task<List<AuditLogEntryDto>> GetRotationWeekAuditAsync(
+            int rotationId,
+            int weekId,
+            CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Get the display-ready audit trail for a single clinician + week, newest first
+        /// (across all rotations that week). Powers the inline per-week audit popover in
+        /// the Schedule-by-Clinician grid.
+        /// </summary>
+        /// <param name="mothraId">MothraID of the affected clinician</param>
+        /// <param name="weekId">Week to scope the history to</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Enriched audit entries for the clinician/week, newest first</returns>
+        Task<List<AuditLogEntryDto>> GetClinicianWeekAuditAsync(
+            string mothraId,
+            int weekId,
+            CancellationToken cancellationToken = default);
+
     }
 
 }
diff --git a/web/Areas/ClinicalScheduler/Services/ScheduleAuditService.cs b/web/Areas/ClinicalScheduler/Services/ScheduleAuditService.cs
index 81f78e4e0..3c3fe784c 100644
--- a/web/Areas/ClinicalScheduler/Services/ScheduleAuditService.cs
+++ b/web/Areas/ClinicalScheduler/Services/ScheduleAuditService.cs
@@ -1,6 +1,8 @@
 using Microsoft.Data.SqlClient;
 using Microsoft.EntityFrameworkCore;
 using Viper.Areas.ClinicalScheduler.Constants;
+using Viper.Areas.ClinicalScheduler.Models.DTOs.Responses;
+using Viper.Areas.Curriculum.Services;
 using Viper.Classes.SQLContext;
 using Viper.Classes.Utilities;
 using Viper.Models.ClinicalScheduler;
@@ -106,12 +108,15 @@ public async Task<List<ScheduleAudit>> GetInstructorScheduleAuditHistoryAsync(
                     return new List<ScheduleAudit>();
                 }
 
-                // Find audit entries matching the rotation, week, and instructor
+                // Find audit entries matching the rotation, week, and instructor.
+                // Clinicians only: the shared audit table also records student schedule
+                // changes, which are out of scope for an instructor schedule's history.
                 return await _context.ScheduleAudits
                     .AsNoTracking()
                     .Where(a => a.RotationId == schedule.RotationId
                         && a.WeekId == schedule.WeekId
-                        && a.MothraId == schedule.MothraId)
+                        && a.MothraId == schedule.MothraId
+                        && a.Area == ScheduleAuditAreas.Clinicians)
                     .OrderByDescending(a => a.TimeStamp)
                     .ToListAsync(cancellationToken);
             }
@@ -129,9 +134,10 @@ public async Task<List<ScheduleAudit>> GetRotationWeekAuditHistoryAsync(
         {
             try
             {
+                // Clinicians only; see GetInstructorScheduleAuditHistoryAsync
                 return await _context.ScheduleAudits
                     .AsNoTracking()
-                    .Where(a => a.RotationId == rotationId && a.WeekId == weekId)
+                    .Where(a => a.RotationId == rotationId && a.WeekId == weekId && a.Area == ScheduleAuditAreas.Clinicians)
                     .OrderByDescending(a => a.TimeStamp)
                     .ToListAsync(cancellationToken);
             }
@@ -142,6 +148,281 @@ public async Task<List<ScheduleAudit>> GetRotationWeekAuditHistoryAsync(
             }
         }
 
+        public async Task<List<AuditLogEntryDto>> GetAuditLogAsync(
+            int gradYear,
+            int? rotationId,
+            int? termCode,
+            string? person,
+            string? modifiedBy,
+            string? area,
+            DateTime? fromDate,
+            DateTime? toDate,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Scope to the grad year via vWeek (a week belongs to a grad year there),
+                // and left-join names so a missing person/rotation lookup never drops a row.
+                var query =
+                    from a in _context.ScheduleAudits.AsNoTracking()
+                    join vw in _context.VWeeks on a.WeekId equals vw.WeekId
+                    where vw.GradYear == gradYear
+                    join rot in _context.Rotations on a.RotationId equals rot.RotId into rotJoin
+                    from rot in rotJoin.DefaultIfEmpty()
+                    join ap in _context.Persons on a.MothraId equals ap.IdsMothraId into affectedJoin
+                    from ap in affectedJoin.DefaultIfEmpty()
+                    join mp in _context.Persons on a.ModifiedBy equals mp.IdsMothraId into modifierJoin
+                    from mp in modifierJoin.DefaultIfEmpty()
+                    select new { Audit = a, Week = vw, Rotation = rot, Affected = ap, Modifier = mp };
+
+                if (rotationId is { } selectedRotationId)
+                {
+                    query = query.Where(x => x.Audit.RotationId == selectedRotationId);
+                }
+                if (termCode is { } selectedTermCode)
+                {
+                    query = query.Where(x => x.Week.TermCode == selectedTermCode);
+                }
+                if (!string.IsNullOrWhiteSpace(area))
+                {
+                    query = query.Where(x => x.Audit.Area == area);
+                }
+                if (!string.IsNullOrWhiteSpace(modifiedBy))
+                {
+                    query = query.Where(x => x.Audit.ModifiedBy == modifiedBy);
+                }
+                if (fromDate is { } fromTimestamp)
+                {
+                    query = query.Where(x => x.Audit.TimeStamp >= fromTimestamp);
+                }
+                if (toDate is { } toTimestamp)
+                {
+                    // The date picker binds to midnight at the start of the day, so advance the
+                    // bound a day to include changes made anytime on the selected end date
+                    // (matches the Effort audit upper-bound handling).
+                    var endOfDay = toTimestamp.AddDays(1);
+                    query = query.Where(x => x.Audit.TimeStamp < endOfDay);
+                }
+                if (!string.IsNullOrWhiteSpace(person))
+                {
+                    query = query.Where(x => x.Audit.MothraId == person);
+                }
+
+                var entries = await query
+                    .OrderByDescending(x => x.Audit.TimeStamp)
+                    .Take(2500)
+                    .Select(x => new AuditLogEntryDto
+                    {
+                        ScheduleAuditId = x.Audit.ScheduleAuditId,
+                        Area = x.Audit.Area,
+                        MothraId = x.Audit.MothraId,
+                        PersonName = x.Affected != null ? x.Affected.PersonDisplayFullName : (x.Audit.MothraId ?? string.Empty),
+                        Action = x.Audit.Action,
+                        RotationId = x.Audit.RotationId,
+                        RotationName = x.Rotation != null ? x.Rotation.Name : string.Empty,
+                        WeekId = x.Audit.WeekId,
+                        WeekNum = x.Week.WeekNum,
+                        WeekStart = x.Week.DateStart,
+                        TermCode = x.Week.TermCode,
+                        ModifiedBy = x.Audit.ModifiedBy,
+                        ModifiedByName = x.Modifier != null ? x.Modifier.PersonDisplayFullName : x.Audit.ModifiedBy,
+                        TimeStamp = x.Audit.TimeStamp,
+                    })
+                    .ToListAsync(cancellationToken);
+
+                return ApplyTermDescriptions(entries);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit log for grad year {GradYear}", LogSanitizer.SanitizeYear(gradYear));
+                throw new InvalidOperationException("Failed to retrieve the audit log. Please try again or contact support if the problem persists.", ex);
+            }
+        }
+
+        public async Task<List<AuditTermDto>> GetAuditTermsAsync(
+            int gradYear,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Distinct terms the grad year's weeks fall into; codes sort chronologically.
+                var termCodes = await _context.VWeeks.AsNoTracking()
+                    .Where(w => w.GradYear == gradYear)
+                    .Select(w => w.TermCode)
+                    .Distinct()
+                    .OrderBy(t => t)
+                    .ToListAsync(cancellationToken);
+
+                return termCodes
+                    .Select(termCode => new AuditTermDto
+                    {
+                        TermCode = termCode,
+                        Term = TermCodeService.GetTermCodeDescription(termCode),
+                    })
+                    .ToList();
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit terms for grad year {GradYear}", LogSanitizer.SanitizeYear(gradYear));
+                throw new InvalidOperationException("Failed to retrieve the terms for this grad year. Please try again or contact support if the problem persists.", ex);
+            }
+        }
+
+        public async Task<List<AuditModifierDto>> GetAuditModifiersAsync(
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Left join so a modifier whose MothraId no longer resolves in Persons still
+                // appears in the filter, matching the raw-ID fallback in GetAuditLogAsync.
+                return await (
+                    from a in _context.ScheduleAudits.AsNoTracking()
+                    where a.ModifiedBy != ""
+                    join p in _context.Persons on a.ModifiedBy equals p.IdsMothraId into modifierJoin
+                    from p in modifierJoin.DefaultIfEmpty()
+                    select new AuditModifierDto
+                    {
+                        MothraId = a.ModifiedBy,
+                        DisplayName = p != null ? p.PersonDisplayFullName : a.ModifiedBy,
+                    })
+                    .Distinct()
+                    .OrderBy(m => m.DisplayName)
+                    .ToListAsync(cancellationToken);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit log modifiers");
+                throw new InvalidOperationException("Failed to retrieve the list of audit modifiers. Please try again or contact support if the problem persists.", ex);
+            }
+        }
+
+        public async Task<List<AuditModifierDto>> GetAuditPersonsAsync(
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Left join so an affected person whose MothraId no longer resolves in Persons
+                // still appears in the filter, matching the raw-ID fallback in GetAuditLogAsync.
+                return await (
+                    from a in _context.ScheduleAudits.AsNoTracking()
+                    where a.MothraId != null && a.MothraId != ""
+                    join p in _context.Persons on a.MothraId equals p.IdsMothraId into affectedJoin
+                    from p in affectedJoin.DefaultIfEmpty()
+                    select new AuditModifierDto
+                    {
+                        MothraId = a.MothraId!,
+                        DisplayName = p != null ? p.PersonDisplayFullName : a.MothraId!,
+                    })
+                    .Distinct()
+                    .OrderBy(m => m.DisplayName)
+                    .ToListAsync(cancellationToken);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit log persons");
+                throw new InvalidOperationException("Failed to retrieve the list of audited persons. Please try again or contact support if the problem persists.", ex);
+            }
+        }
+
+        public async Task<List<AuditLogEntryDto>> GetRotationWeekAuditAsync(
+            int rotationId,
+            int weekId,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Clinician scheduling context only: the shared ScheduleAudit table also
+                // holds student schedule changes (Area = Students) for the same
+                // rotation/week, which would read as phantom roster entries here.
+                var audits = _context.ScheduleAudits.AsNoTracking()
+                    .Where(a => a.RotationId == rotationId && a.WeekId == weekId && a.Area == ScheduleAuditAreas.Clinicians);
+                var entries = await BuildEnrichedAuditQuery(audits)
+                    .OrderByDescending(x => x.TimeStamp)
+                    .ToListAsync(cancellationToken);
+                return ApplyTermDescriptions(entries);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit history for rotation {RotationId}, week {WeekId}", rotationId, weekId);
+                throw new InvalidOperationException("Failed to retrieve the audit trail for this week. Please try again or contact support if the problem persists.", ex);
+            }
+        }
+
+        public async Task<List<AuditLogEntryDto>> GetClinicianWeekAuditAsync(
+            string mothraId,
+            int weekId,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Clinicians only, same as GetRotationWeekAuditAsync: a clinician who was
+                // previously a UCD student would otherwise see student-era entries here.
+                var audits = _context.ScheduleAudits.AsNoTracking()
+                    .Where(a => a.MothraId == mothraId && a.WeekId == weekId && a.Area == ScheduleAuditAreas.Clinicians);
+                var entries = await BuildEnrichedAuditQuery(audits)
+                    .OrderByDescending(x => x.TimeStamp)
+                    .ToListAsync(cancellationToken);
+                return ApplyTermDescriptions(entries);
+            }
+            catch (Exception ex) when (ex is DbUpdateException or SqlException or InvalidOperationException)
+            {
+                _logger.LogError(ex, "Error retrieving audit history for clinician {MothraId}, week {WeekId}", LogSanitizer.SanitizeString(mothraId), weekId);
+                throw new InvalidOperationException("Failed to retrieve the audit trail for this week. Please try again or contact support if the problem persists.", ex);
+            }
+        }
+
+        /// <summary>
+        /// Build the display-ready (name / rotation / week-enriched) projection for a
+        /// pre-filtered set of audit rows. Left-joins every lookup so a missing match never
+        /// drops a row; shared by the per-rotation-week and per-clinician-week history queries.
+        /// </summary>
+        private IQueryable<AuditLogEntryDto> BuildEnrichedAuditQuery(IQueryable<ScheduleAudit> audits)
+        {
+            // Base Weeks (unique per WeekId), not vWeek (one row per WeekId x grad year),
+            // which would duplicate every audit row for a week that spans two grad years.
+            // WeekNum stays 0 for the same reason: it is a per-grad-year concept, so a
+            // week-scoped query has no single unambiguous week number.
+            return
+                from a in audits
+                join w in _context.Weeks on a.WeekId equals w.WeekId into weekJoin
+                from w in weekJoin.DefaultIfEmpty()
+                join rot in _context.Rotations on a.RotationId equals rot.RotId into rotJoin
+                from rot in rotJoin.DefaultIfEmpty()
+                join ap in _context.Persons on a.MothraId equals ap.IdsMothraId into affectedJoin
+                from ap in affectedJoin.DefaultIfEmpty()
+                join mp in _context.Persons on a.ModifiedBy equals mp.IdsMothraId into modifierJoin
+                from mp in modifierJoin.DefaultIfEmpty()
+                select new AuditLogEntryDto
+                {
+                    ScheduleAuditId = a.ScheduleAuditId,
+                    Area = a.Area,
+                    MothraId = a.MothraId,
+                    PersonName = ap != null ? ap.PersonDisplayFullName : (a.MothraId ?? string.Empty),
+                    Action = a.Action,
+                    RotationId = a.RotationId,
+                    RotationName = rot != null ? rot.Name : string.Empty,
+                    WeekId = a.WeekId,
+                    WeekStart = w != null ? w.DateStart : null,
+                    TermCode = w != null ? w.TermCode : 0,
+                    ModifiedBy = a.ModifiedBy,
+                    ModifiedByName = mp != null ? mp.PersonDisplayFullName : a.ModifiedBy,
+                    TimeStamp = a.TimeStamp,
+                };
+        }
+
+        /// <summary>
+        /// Fill in the term description from the SQL-populated term code.
+        /// GetTermCodeDescription is C#, not SQL-translatable, so this runs after materializing.
+        /// </summary>
+        private static List<AuditLogEntryDto> ApplyTermDescriptions(List<AuditLogEntryDto> entries)
+        {
+            foreach (var entry in entries)
+            {
+                entry.Term = entry.TermCode > 0 ? TermCodeService.GetTermCodeDescription(entry.TermCode) : string.Empty;
+            }
+            return entries;
+        }
+
         /// <summary>
         /// Create a schedule audit entry with common properties
         /// 
diff --git a/web/Areas/ClinicalScheduler/Services/ScheduleEditService.cs b/web/Areas/ClinicalScheduler/Services/ScheduleEditService.cs
index 816e32822..9f9643b3c 100644
--- a/web/Areas/ClinicalScheduler/Services/ScheduleEditService.cs
+++ b/web/Areas/ClinicalScheduler/Services/ScheduleEditService.cs
@@ -184,47 +184,25 @@ public async Task<List<InstructorSchedule>> AddInstructorAsync(
                     // Save all schedule entities at once for better performance
                     await _context.SaveChangesAsync(cancellationToken);
 
+                    // Audit inside the transaction so a schedule change can never commit
+                    // without its trail; an audit failure rolls the change back
+                    // (matching the legacy scheduler's in-transaction auditing).
+                    await WriteAddAuditEntriesAsync(
+                        mothraId!, rotationId, isPrimaryEvaluator, createdSchedules, removedPrimarySchedules, currentUser.MothraId, cancellationToken);
+
                     return (createdSchedules, removedPrimarySchedules);
                 }, IsolationLevel.Serializable, cancellationToken);
 
                 var (createdSchedules, removedPrimarySchedules) = result;
 
-                // Send notifications and log audit entries AFTER successful transaction commit
-                // This ensures we don't send emails for operations that were rolled back
-                // Post-transaction operations are wrapped in try-catch to prevent perceived failures
-                try
+                // Notify AFTER the commit so emails never fire for rolled-back
+                // changes. The sender swallows its own failures.
+                foreach (var (_, removedSchedules) in removedPrimarySchedules)
                 {
-                    // Send notifications for any removed primary evaluators
-                    foreach (var (_, removedSchedules) in removedPrimarySchedules)
+                    foreach (var removedSchedule in removedSchedules)
                     {
-                        foreach (var removedSchedule in removedSchedules)
-                        {
-                            await HandlePrimaryEvaluatorRemovalAsync(removedSchedule, currentUser.MothraId, cancellationToken, mothraId);
-                        }
+                        await SendPrimaryEvaluatorRemovedNotificationAsync(removedSchedule, currentUser.MothraId, cancellationToken, mothraId);
                     }
-
-                    // Log audit entries after successful save (so we have InstructorScheduleId)
-#pragma warning disable S3267 // Loop contains async operations that cannot be simplified to Select
-                    foreach (var schedule in createdSchedules)
-                    {
-                        await _auditService.LogInstructorAddedAsync(
-                            mothraId!, rotationId, schedule.WeekId, currentUser.MothraId, cancellationToken);
-
-                        if (isPrimaryEvaluator)
-                        {
-                            await _auditService.LogPrimaryEvaluatorSetAsync(
-                                mothraId!, rotationId, schedule.WeekId, currentUser.MothraId, cancellationToken);
-                        }
-                    }
-#pragma warning restore S3267
-                }
-#pragma warning disable CA1031 // Intentional broad catch: post-transaction work (email/audit notifications) must not roll back the successful database changes above.
-                catch (Exception postTransactionEx)
-#pragma warning restore CA1031
-                {
-                    // Log warning but don't fail the operation - the database changes were successful
-                    _logger.LogWarning(postTransactionEx, "Post-transaction operations failed for instructor {MothraId} in rotation {RotationId}, but database changes were successful",
-                        LogSanitizer.SanitizeId(mothraId), rotationId);
                 }
 
                 _logger.LogInformation("Successfully added instructor {MothraId} to rotation {RotationId} for {WeekCount} weeks (Primary: {IsPrimary})",
@@ -259,6 +237,43 @@ await _auditService.LogPrimaryEvaluatorSetAsync(
             }
         }
 
+        /// <summary>
+        /// Writes the audit entries for an add operation. Must be called inside the
+        /// same transaction as the schedule changes so the trail commits atomically.
+        /// </summary>
+        private async Task WriteAddAuditEntriesAsync(
+            string mothraId,
+            int rotationId,
+            bool isPrimaryEvaluator,
+            List<InstructorSchedule> createdSchedules,
+            Dictionary<int, List<InstructorSchedule>> removedPrimarySchedules,
+            string modifiedByMothraId,
+            CancellationToken cancellationToken)
+        {
+#pragma warning disable S3267 // Loop contains async operations that cannot be simplified to Select
+            foreach (var (_, removedSchedules) in removedPrimarySchedules)
+            {
+                foreach (var removedSchedule in removedSchedules)
+                {
+                    await _auditService.LogPrimaryEvaluatorUnsetAsync(
+                        removedSchedule.MothraId, removedSchedule.RotationId, removedSchedule.WeekId, modifiedByMothraId, cancellationToken);
+                }
+            }
+
+            foreach (var schedule in createdSchedules)
+            {
+                await _auditService.LogInstructorAddedAsync(
+                    mothraId, rotationId, schedule.WeekId, modifiedByMothraId, cancellationToken);
+
+                if (isPrimaryEvaluator)
+                {
+                    await _auditService.LogPrimaryEvaluatorSetAsync(
+                        mothraId, rotationId, schedule.WeekId, modifiedByMothraId, cancellationToken);
+                }
+            }
+#pragma warning restore S3267
+        }
+
         // SQL Server: 2627 = unique constraint violation, 2601 = duplicate key in a unique index.
         // EF wraps the provider error in DbUpdateException, so walk the inner-exception chain to find
         // the underlying SqlException (robust even if it is wrapped more than once).
@@ -333,29 +348,25 @@ await ExecuteInTransactionAsync(async _ =>
                     // Remove the schedule
                     _context.InstructorSchedules.Remove(schedule);
                     await _context.SaveChangesAsync(cancellationToken);
-                    return true;
-                }, cancellationToken);
 
-                // Send notifications and log audit entries AFTER successful transaction commit
-                // This ensures we don't send emails for operations that were rolled back
-                // Post-transaction operations are wrapped in try-catch to prevent perceived failures
-                try
-                {
+                    // Audit inside the transaction; see AddInstructorAsync for rationale
                     await _auditService.LogInstructorRemovedAsync(
                         schedule.MothraId, schedule.RotationId, schedule.WeekId, currentUser.MothraId, cancellationToken);
 
                     if (wasPrimaryEvaluator)
                     {
-                        await HandlePrimaryEvaluatorRemovalAsync(schedule, currentUser.MothraId, cancellationToken);
+                        await _auditService.LogPrimaryEvaluatorUnsetAsync(
+                            schedule.MothraId, schedule.RotationId, schedule.WeekId, currentUser.MothraId, cancellationToken);
                     }
-                }
-#pragma warning disable CA1031 // Intentional broad catch: post-transaction work (email/audit notifications) must not roll back the successful database changes above.
-                catch (Exception postTransactionEx)
-#pragma warning restore CA1031
+
+                    return true;
+                }, cancellationToken);
+
+                // Notify AFTER the commit so emails never fire for rolled-back
+                // changes. The sender swallows its own failures.
+                if (wasPrimaryEvaluator)
                 {
-                    // Log warning but don't fail the operation - the database changes were successful
-                    _logger.LogWarning(postTransactionEx, "Post-transaction operations failed for instructor removal {ScheduleId}, but database changes were successful",
-                        instructorScheduleId);
+                    await SendPrimaryEvaluatorRemovedNotificationAsync(schedule, currentUser.MothraId, cancellationToken);
                 }
 
                 _logger.LogInformation("Successfully removed instructor {MothraId} from rotation {RotationId}, week {WeekId} (WasPrimary: {WasPrimary})",
@@ -444,39 +455,43 @@ await _auditService.LogInstructorRemovedAsync(
 
                     await _context.SaveChangesAsync(cancellationToken);
 
-                    return (previousPrimaryName, removedPrimarySchedules);
-                }, cancellationToken);
-
-                var (previousPrimaryName, removedPrimarySchedules) = result;
-
-                // Send notifications and log audit entries AFTER successful transaction commit
-                // This ensures we don't send emails for operations that were rolled back
-                // Post-transaction operations are wrapped in try-catch to prevent perceived failures
-                try
-                {
+                    // Audit inside the transaction; see AddInstructorAsync for rationale
                     if (isPrimary)
                     {
-                        // Send notifications for any removed primary evaluators
+#pragma warning disable S3267 // Loop contains async operations that cannot be simplified to Select
                         foreach (var removedSchedule in removedPrimarySchedules)
                         {
-                            await HandlePrimaryEvaluatorRemovalAsync(removedSchedule, currentUser.MothraId, cancellationToken, schedule.MothraId, requiresPrimaryEvaluator);
+                            await _auditService.LogPrimaryEvaluatorUnsetAsync(
+                                removedSchedule.MothraId, removedSchedule.RotationId, removedSchedule.WeekId, currentUser.MothraId, cancellationToken);
                         }
+#pragma warning restore S3267
 
                         await _auditService.LogPrimaryEvaluatorSetAsync(
                             schedule.MothraId, schedule.RotationId, schedule.WeekId, currentUser.MothraId, cancellationToken);
                     }
                     else
                     {
-                        await HandlePrimaryEvaluatorRemovalAsync(schedule, currentUser.MothraId, cancellationToken, null, requiresPrimaryEvaluator);
+                        await _auditService.LogPrimaryEvaluatorUnsetAsync(
+                            schedule.MothraId, schedule.RotationId, schedule.WeekId, currentUser.MothraId, cancellationToken);
+                    }
+
+                    return (previousPrimaryName, removedPrimarySchedules);
+                }, cancellationToken);
+
+                var (previousPrimaryName, removedPrimarySchedules) = result;
+
+                // Notify AFTER the commit so emails never fire for rolled-back
+                // changes. The sender swallows its own failures.
+                if (isPrimary)
+                {
+                    foreach (var removedSchedule in removedPrimarySchedules)
+                    {
+                        await SendPrimaryEvaluatorRemovedNotificationAsync(removedSchedule, currentUser.MothraId, cancellationToken, schedule.MothraId, requiresPrimaryEvaluator);
                     }
                 }
-#pragma warning disable CA1031 // Intentional broad catch: post-transaction work (email/audit notifications) must not roll back the successful database changes above.
-                catch (Exception postTransactionEx)
-#pragma warning restore CA1031
+                else
                 {
-                    // Log warning but don't fail the operation - the database changes were successful
-                    _logger.LogWarning(postTransactionEx, "Post-transaction operations failed for primary evaluator update {ScheduleId}, but database changes were successful",
-                        instructorScheduleId);
+                    await SendPrimaryEvaluatorRemovedNotificationAsync(schedule, currentUser.MothraId, cancellationToken, null, requiresPrimaryEvaluator);
                 }
 
                 _logger.LogInformation("Set primary evaluator for {MothraId} on rotation {RotationId}, week {WeekId} to {IsPrimary}",
@@ -624,25 +639,6 @@ private async Task<List<InstructorSchedule>> ClearPrimaryEvaluatorAsync(int rota
             return existingPrimary;
         }
 
-        /// <summary>
-        /// Handles the complete process of removing a primary evaluator status,
-        /// including audit logging and email notifications
-        /// </summary>
-        private async Task HandlePrimaryEvaluatorRemovalAsync(
-            InstructorSchedule schedule,
-            string currentUserMothraId,
-            CancellationToken cancellationToken,
-            string? newPrimaryMothraId = null,
-            bool requiresPrimaryEvaluator = false)
-        {
-            // Log the primary evaluator removal
-            await _auditService.LogPrimaryEvaluatorUnsetAsync(
-                schedule.MothraId, schedule.RotationId, schedule.WeekId, currentUserMothraId, cancellationToken);
-
-            // Send email notification
-            await SendPrimaryEvaluatorRemovedNotificationAsync(schedule, currentUserMothraId, cancellationToken, newPrimaryMothraId, requiresPrimaryEvaluator);
-        }
-
         /// <summary>
         /// Send email notification when a primary evaluator is removed
         /// Matches the ColdFusion system's notification format and recipients