From 627f2e0b45f6b93fdd944c97ce51bc471132e8a3 Mon Sep 17 00:00:00 2001
From: Shawn Jackson <shawn@resgrid.com>
Date: Wed, 14 Oct 2026 09:16:01 -0700
Subject: [PATCH 1/2] RR-T51 Department Changeable Names, Base Status Types
 fixes

---
 src/api/config/terminology.ts                 |  11 +
 .../(app)/__tests__/init-hub-connect.test.tsx |  18 ++
 src/app/(app)/_layout.tsx                     |  11 +-
 src/app/(app)/calendar.tsx                    |   4 +-
 src/app/(app)/checklists.tsx                  |   4 +-
 src/app/(app)/home/__tests__/_layout.test.tsx |  63 ++++++
 src/app/(app)/home/_layout.tsx                |  10 +-
 src/app/(app)/map.tsx                         |   6 +-
 src/app/(app)/records.tsx                     |   4 +-
 src/app/(app)/shifts.tsx                      |   4 +-
 src/app/(app)/work-orders/[id].tsx            |   6 +-
 src/app/(app)/work-orders/index.tsx           |   6 +-
 src/app/call/[id]/edit.tsx                    |   9 +-
 src/app/records/[id].tsx                      |  14 +-
 src/app/records/__tests__/[id].test.tsx       |  14 ++
 src/app/records/new.tsx                       |   6 +-
 .../calendar/enhanced-calendar-view.tsx       |   4 +-
 .../home/__tests__/status-buttons.test.tsx    |  32 +++
 src/components/home/status-buttons.tsx        |  11 +-
 .../__tests__/record-list-item.test.tsx       | 158 +++++++++++++
 src/components/records/record-list-item.tsx   |  11 +-
 .../sidebar/__tests__/side-menu.test.tsx      |  40 +++-
 src/components/sidebar/side-menu-content.tsx  |  21 +-
 .../units/__tests__/unit-card.test.tsx        | 111 ++++++++++
 src/components/units/unit-card.tsx            |  15 +-
 src/hooks/use-record-definition-name.ts       |  52 +++++
 src/lib/__tests__/base-types.test.ts          |  84 +++++++
 src/lib/__tests__/call-field-policy.test.ts   |  27 +++
 src/lib/base-types.ts                         | 207 ++++++++++++++++++
 src/lib/call-field-policy.ts                  |  18 ++
 .../callPriorities/callPriorityResultData.ts  |   2 +
 src/models/v4/callTypes/callTypeResultData.ts |   2 +
 src/models/v4/calls/callResultData.ts         |   2 +
 src/models/v4/configs/getTerminologyResult.ts |  17 ++
 .../device/nativePushUnRegistrationInput.ts   |   5 +
 .../v4/personnel/personnelInfoResultData.ts   |   6 +
 .../v4/security/departmentRightsResultData.ts |   8 +
 src/models/v4/statuses/statusesResultData.ts  |   4 +-
 src/models/v4/units/unitInfoResultData.ts     |   2 +
 .../push-notification-sign-out.test.ts        | 137 ++++++++++++
 src/services/push-notification.ts             |  40 +++-
 src/stores/home/__tests__/home-store.test.ts  |  80 +++++++
 src/stores/home/home-store.ts                 |   6 +-
 .../terminology/__tests__/store.test.ts       | 116 ++++++++++
 src/stores/terminology/store.ts               | 140 ++++++++++++
 45 files changed, 1495 insertions(+), 53 deletions(-)
 create mode 100644 src/api/config/terminology.ts
 create mode 100644 src/app/(app)/home/__tests__/_layout.test.tsx
 create mode 100644 src/components/records/__tests__/record-list-item.test.tsx
 create mode 100644 src/components/units/__tests__/unit-card.test.tsx
 create mode 100644 src/hooks/use-record-definition-name.ts
 create mode 100644 src/lib/__tests__/base-types.test.ts
 create mode 100644 src/lib/base-types.ts
 create mode 100644 src/models/v4/configs/getTerminologyResult.ts
 create mode 100644 src/models/v4/device/nativePushUnRegistrationInput.ts
 create mode 100644 src/services/__tests__/push-notification-sign-out.test.ts
 create mode 100644 src/stores/home/__tests__/home-store.test.ts
 create mode 100644 src/stores/terminology/__tests__/store.test.ts
 create mode 100644 src/stores/terminology/store.ts

diff --git a/src/api/config/terminology.ts b/src/api/config/terminology.ts
new file mode 100644
index 00000000..48e65948
--- /dev/null
+++ b/src/api/config/terminology.ts
@@ -0,0 +1,11 @@
+import { type GetTerminologyResult } from '@/models/v4/configs/getTerminologyResult';
+
+import { createApiEndpoint } from '../common/client';
+
+const getTerminologyApi = createApiEndpoint('/Config/GetTerminology');
+
+/** The department's own names for modules and built-in record types (setting 118). */
+export const getTerminology = async () => {
+  const response = await getTerminologyApi.get<GetTerminologyResult>();
+  return response.data;
+};
diff --git a/src/app/(app)/__tests__/init-hub-connect.test.tsx b/src/app/(app)/__tests__/init-hub-connect.test.tsx
index d7c765bb..09c0e0f0 100644
--- a/src/app/(app)/__tests__/init-hub-connect.test.tsx
+++ b/src/app/(app)/__tests__/init-hub-connect.test.tsx
@@ -123,6 +123,11 @@ jest.mock('@/stores/feature-flags/store', () => ({
   featureFlagsStore: { getState: () => ({ fetchFlags: jest.fn().mockResolvedValue(undefined), isEnabled: mockIsChatEnabled }) },
 }));
 
+const mockFetchTerminology = jest.fn().mockResolvedValue(undefined);
+jest.mock('@/stores/terminology/store', () => ({
+  terminologyStore: { getState: () => ({ fetchTerminology: mockFetchTerminology }) },
+}));
+
 const mockConnectUpdateHub = jest.fn().mockResolvedValue(undefined);
 const mockConnectGeolocationHub = jest.fn().mockResolvedValue(undefined);
 const mockConnectChatHub = jest.fn().mockResolvedValue(undefined);
@@ -148,6 +153,7 @@ describe('app initialization connects the SignalR update hub', () => {
     mockConnectUpdateHub.mockResolvedValue(undefined);
     mockConnectGeolocationHub.mockResolvedValue(undefined);
     mockConnectChatHub.mockResolvedValue(undefined);
+    mockFetchTerminology.mockResolvedValue(undefined);
     mockUseSignalRLifecycle.mockImplementation(({ hasInitialized }) => {
       lifecycleCalls.push({ hasInitialized, updateConnectsSoFar: mockConnectUpdateHub.mock.calls.length });
       return undefined as unknown as ReturnType<typeof useSignalRLifecycle>;
@@ -162,6 +168,17 @@ describe('app initialization connects the SignalR update hub', () => {
     });
   });
 
+  it('fetches the department terminology after rights and before the hubs connect', async () => {
+    render(<TabLayout />);
+
+    await waitFor(() => {
+      expect(mockConnectUpdateHub).toHaveBeenCalledTimes(1);
+    });
+    expect(mockFetchTerminology).toHaveBeenCalledTimes(1);
+    expect(mockSecurityState.getRights.mock.invocationCallOrder[0]).toBeLessThan(mockFetchTerminology.mock.invocationCallOrder[0]);
+    expect(mockFetchTerminology.mock.invocationCallOrder[0]).toBeLessThan(mockConnectUpdateHub.mock.invocationCallOrder[0]);
+  });
+
   it('connects the update hub before arming useSignalRLifecycle, so the two cannot both connect', async () => {
     render(<TabLayout />);
 
@@ -221,5 +238,6 @@ describe('app initialization connects the SignalR update hub', () => {
     expect(mockConnectUpdateHub).not.toHaveBeenCalled();
     expect(mockConnectGeolocationHub).not.toHaveBeenCalled();
     expect(mockConnectChatHub).not.toHaveBeenCalled();
+    expect(mockFetchTerminology).not.toHaveBeenCalled();
   });
 });
diff --git a/src/app/(app)/_layout.tsx b/src/app/(app)/_layout.tsx
index a7c72ceb..f9e6f5c0 100644
--- a/src/app/(app)/_layout.tsx
+++ b/src/app/(app)/_layout.tsx
@@ -47,6 +47,7 @@ import { usePersonnelStore } from '@/stores/personnel/store';
 import { useRolesStore } from '@/stores/roles/store';
 import { securityStore } from '@/stores/security/store';
 import { useSignalRStore } from '@/stores/signalr/signalr-store';
+import { terminologyStore } from '@/stores/terminology/store';
 import { useWeatherAlertsStore } from '@/stores/weather-alerts/weather-alerts-store';
 
 // Sets the SDK token now (stored server token, else the built-in one) and again whenever it changes.
@@ -141,9 +142,10 @@ export default function TabLayout() {
       //await usePersonnelStore.getState().init();
       if (!isCurrentRun()) return;
 
-      // Feature flags must follow rights: the identity key that decides whether persisted
-      // flags belong to this account reads securityStore.rights.DepartmentId.
-      await Promise.all([featureFlagsStore.getState().fetchFlags(), dataProtectionStore.getState().fetchCapabilities()]);
+      // Feature flags and terminology must follow rights: the identity key that decides whether
+      // persisted flags or names belong to this account reads securityStore.rights.DepartmentId.
+      // Terminology only relabels screens, and its fetch never rejects.
+      await Promise.all([featureFlagsStore.getState().fetchFlags(), dataProtectionStore.getState().fetchCapabilities(), terminologyStore.getState().fetchTerminology()]);
       if (!isCurrentRun()) return;
 
       // Realtime feeds. Every one of them has to follow the Promise.all above: opening a hub reads
@@ -473,6 +475,9 @@ export default function TabLayout() {
   return (
     <NovuProvider
       subscriberId={isNovuConfigured ? `${rights?.DepartmentCode}_User_${userId}` : ''}
+      // Issued by the server for this user's own subscriber; Novu refuses the session without it once
+      // HMAC is enforced. Absent from older servers, which is fine until then.
+      subscriberHash={isNovuConfigured ? (rights?.NovuSubscriberHash ?? undefined) : undefined}
       applicationIdentifier={config?.NovuApplicationId ?? ''}
       backendUrl={config?.NovuBackendApiUrl ?? ''}
       socketUrl={config?.NovuSocketUrl ?? ''}
diff --git a/src/app/(app)/calendar.tsx b/src/app/(app)/calendar.tsx
index 5494a259..93127660 100644
--- a/src/app/(app)/calendar.tsx
+++ b/src/app/(app)/calendar.tsx
@@ -21,11 +21,13 @@ import { useAnalytics } from '@/hooks/use-analytics';
 import { isDateInRange } from '@/lib/utils';
 import { type CalendarItemResultData } from '@/models/v4/calendar/calendarItemResultData';
 import { useCalendarStore } from '@/stores/calendar/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 type TabType = 'today' | 'upcoming' | 'calendar';
 
 export default function CalendarScreen() {
   const { t } = useTranslation();
+  const calendarTitle = useTerm(TermKeys.Calendar, t('calendar.title'));
   const router = useRouter();
   const { trackEvent } = useAnalytics();
   const [activeTab, setActiveTab] = useState<TabType>('today');
@@ -252,7 +254,7 @@ export default function CalendarScreen() {
     <>
       <Stack.Screen
         options={{
-          title: t('calendar.title'),
+          title: calendarTitle,
           headerShown: true,
         }}
       />
diff --git a/src/app/(app)/checklists.tsx b/src/app/(app)/checklists.tsx
index c144d48b..4e7f0304 100644
--- a/src/app/(app)/checklists.tsx
+++ b/src/app/(app)/checklists.tsx
@@ -11,9 +11,11 @@ import { useChecklistLiveUpdates } from '@/hooks/use-checklist-live-updates';
 import { useProtectedReveal } from '@/hooks/use-protected-reveal';
 import { checklistError } from '@/lib/checklists/sync';
 import { useChecklistsStore } from '@/stores/checklists/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 export default function ChecklistsScreen() {
   const { t } = useTranslation();
+  const checklistsTitle = useTerm(TermKeys.Checklists, t('checklists.labels.Checklists'));
   const { occurrenceId } = useLocalSearchParams<{ occurrenceId?: string }>();
   const unitId: string | undefined = undefined;
   const state = useChecklistsStore();
@@ -46,7 +48,7 @@ export default function ChecklistsScreen() {
   const message = error ?? state.error;
   return (
     <View className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: t('checklists.labels.Checklists') }} />
+      <Stack.Screen options={{ title: checklistsTitle }} />
       <ScrollView contentContainerStyle={{ padding: 16, gap: 12 }}>
         <Button variant="outline" onPress={() => setCalendar((v) => !v)}>
           <ButtonText>{t('checklists.ui.calendar')}</ButtonText>
diff --git a/src/app/(app)/home/__tests__/_layout.test.tsx b/src/app/(app)/home/__tests__/_layout.test.tsx
new file mode 100644
index 00000000..46e926c5
--- /dev/null
+++ b/src/app/(app)/home/__tests__/_layout.test.tsx
@@ -0,0 +1,63 @@
+import { act, render, screen } from '@testing-library/react-native';
+import React from 'react';
+
+import { terminologyStore } from '@/stores/terminology/store';
+
+import HomeLayout from '../_layout';
+
+interface MockTabsProps {
+  children?: React.ReactNode;
+}
+
+interface MockScreenProps {
+  name: string;
+  options?: { title?: string };
+}
+
+jest.mock('expo-router', () => {
+  const { Text, View } = require('react-native');
+  const MockTabs = ({ children }: MockTabsProps) => <View>{children}</View>;
+  MockTabs.Screen = ({ name, options }: MockScreenProps) => <Text testID={`home-tab-${name}`}>{options?.title}</Text>;
+  return { Tabs: MockTabs };
+});
+
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+
+describe('HomeLayout tab titles', () => {
+  beforeEach(() => {
+    terminologyStore.setState({ names: {} });
+  });
+
+  afterAll(() => {
+    terminologyStore.setState({ names: {} });
+  });
+
+  it('keeps the app labels when nothing is renamed', () => {
+    render(<HomeLayout />);
+
+    expect(screen.getByTestId('home-tab-personnel').props.children).toBe('tabs.personnel');
+    expect(screen.getByTestId('home-tab-units').props.children).toBe('units.title');
+    expect(screen.getByTestId('home-tab-calls').props.children).toBe('tabs.calls');
+  });
+
+  it("uses the department's names for renamed modules", () => {
+    terminologyStore.setState({ names: { 'module.personnel': 'Members', 'module.units': 'Apparatus', 'module.calls': 'Incidents' } });
+
+    render(<HomeLayout />);
+
+    expect(screen.getByTestId('home-tab-personnel').props.children).toBe('Members');
+    expect(screen.getByTestId('home-tab-units').props.children).toBe('Apparatus');
+    expect(screen.getByTestId('home-tab-calls').props.children).toBe('Incidents');
+    expect(screen.getByTestId('home-tab-index').props.children).toBe('tabs.home');
+  });
+
+  it('relabels the tabs when the names arrive after the first render', () => {
+    render(<HomeLayout />);
+
+    act(() => {
+      terminologyStore.setState({ names: { 'module.calls': 'Incidents' } });
+    });
+
+    expect(screen.getByTestId('home-tab-calls').props.children).toBe('Incidents');
+  });
+});
diff --git a/src/app/(app)/home/_layout.tsx b/src/app/(app)/home/_layout.tsx
index 85a7b85c..c7641e75 100644
--- a/src/app/(app)/home/_layout.tsx
+++ b/src/app/(app)/home/_layout.tsx
@@ -5,11 +5,15 @@ import { useTranslation } from 'react-i18next';
 import { useWindowDimensions } from 'react-native';
 
 import { Icon } from '@/components/ui/icon';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 export default function HomeLayout() {
   const { t } = useTranslation();
   const { width, height } = useWindowDimensions();
   const isLandscape = width > height;
+  const personnelTitle = useTerm(TermKeys.Personnel, t('tabs.personnel'));
+  const unitsTitle = useTerm(TermKeys.Units, t('units.title'));
+  const callsTitle = useTerm(TermKeys.Calls, t('tabs.calls'));
 
   return (
     <Tabs
@@ -43,7 +47,7 @@ export default function HomeLayout() {
       <Tabs.Screen
         name="personnel"
         options={{
-          title: t('tabs.personnel'),
+          title: personnelTitle,
           tabBarIcon: ({ color }) => <Icon as={User} stroke={color as string} className="text-primary-500 dark:text-primary-400" />,
           tabBarButtonTestID: 'home-people-tab',
         }}
@@ -52,7 +56,7 @@ export default function HomeLayout() {
       <Tabs.Screen
         name="units"
         options={{
-          title: t('units.title'),
+          title: unitsTitle,
           tabBarIcon: ({ color }) => <Icon as={Car} stroke={color as string} className="text-primary-500 dark:text-primary-400" />,
           tabBarButtonTestID: 'home-units-tab',
         }}
@@ -61,7 +65,7 @@ export default function HomeLayout() {
       <Tabs.Screen
         name="calls"
         options={{
-          title: t('tabs.calls'),
+          title: callsTitle,
           tabBarIcon: ({ color }) => <Icon as={Phone} stroke={color as string} className="text-primary-500 dark:text-primary-400" />,
           tabBarButtonTestID: 'home-calls-tab',
         }}
diff --git a/src/app/(app)/map.tsx b/src/app/(app)/map.tsx
index b3683bf7..3952161c 100644
--- a/src/app/(app)/map.tsx
+++ b/src/app/(app)/map.tsx
@@ -9,9 +9,11 @@ import { FocusAwareStatusBar } from '@/components/ui/focus-aware-status-bar';
 import { SharedTabs, type TabItem } from '@/components/ui/shared-tabs';
 import { type PoiResultData } from '@/models/v4/mapping/poiResultData';
 import { usePoiStore } from '@/stores/poi/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 export default function HomeMap() {
   const { t } = useTranslation();
+  const mapTitle = useTerm(TermKeys.Mapping, t('map.tabs.map'));
   const router = useRouter();
   const { tab, poiId } = useLocalSearchParams<{ tab?: string | string[]; poiId?: string | string[] }>();
   const { width, height } = useWindowDimensions();
@@ -50,7 +52,7 @@ export default function HomeMap() {
     () => [
       {
         key: 'map',
-        title: t('map.tabs.map'),
+        title: mapTitle,
         content: (
           <View className="flex-1 overflow-hidden rounded-[28px] border border-neutral-200 bg-white shadow-xs dark:border-neutral-800 dark:bg-neutral-900">
             <MapPanel focusedPoi={focusedPoi} />
@@ -67,7 +69,7 @@ export default function HomeMap() {
         ),
       },
     ],
-    [focusedPoi, handlePoiPress, handleViewPoiOnMap, t]
+    [focusedPoi, handlePoiPress, handleViewPoiOnMap, mapTitle, t]
   );
 
   return (
diff --git a/src/app/(app)/records.tsx b/src/app/(app)/records.tsx
index c80a919e..44ade04f 100644
--- a/src/app/(app)/records.tsx
+++ b/src/app/(app)/records.tsx
@@ -22,6 +22,7 @@ import { useRecordsFieldStatus } from '@/stores/feature-flags/store';
 import { useDeploymentsStore, useOpenDeploymentCount, useReconciliationCount } from '@/stores/records/deployments-store';
 import { useRecordsStore } from '@/stores/records/store';
 import { securityStore } from '@/stores/security/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 // Field Records home (RMS plan RMS-1D): New, Assigned, Drafts, Returned and Recent. Everything shown
 // here came from the server's own filtering; this screen never decides what the person may author.
@@ -42,6 +43,7 @@ const Empty = ({ text }: { text: string }) => <Text className="px-4 py-3 text-sm
 
 export default function RecordsScreen() {
   const { t } = useTranslation();
+  const recordsTitle = useTerm(TermKeys.Records, t('records.title'));
   const router = useRouter();
   const flagStatus = useRecordsFieldStatus();
   const context = useRecordsContext();
@@ -97,7 +99,7 @@ export default function RecordsScreen() {
   return (
     <Box className="flex-1 bg-background-0">
       <FocusAwareStatusBar />
-      <Stack.Screen options={{ title: t('records.title') }} />
+      <Stack.Screen options={{ title: recordsTitle }} />
 
       <ScrollView refreshControl={<RefreshControl refreshing={isSyncing} onRefresh={() => void sync()} />}>
         {flagStatus === 'unknown' ? (
diff --git a/src/app/(app)/shifts.tsx b/src/app/(app)/shifts.tsx
index 74f0ceea..ea39800a 100644
--- a/src/app/(app)/shifts.tsx
+++ b/src/app/(app)/shifts.tsx
@@ -33,6 +33,7 @@ import { formatShiftLongDate, getDateKey, getMonthRange, parseWallClock, toDateP
 import { type ShiftDayResultData } from '@/models/v4/shifts/shiftDayResultData';
 import { type ShiftResultData } from '@/models/v4/shifts/shiftResultData';
 import { type ShiftViewMode, useShiftsStore } from '@/stores/shifts/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 const SUPERVISOR_VIEWS: ShiftViewMode[] = ['approvals'];
 const TRADE_MUTATIONS = new Set(['respond-trade', 'finish-trade', 'cancel-trade', 'review-trade']);
@@ -67,6 +68,7 @@ CalendarFilterChip.displayName = 'CalendarFilterChip';
 
 const ShiftsScreen: React.FC = () => {
   const { t } = useTranslation();
+  const shiftsTitle = useTerm(TermKeys.Shifts, t('shifts.title'));
   const { trackEvent } = useAnalytics();
   const { colorScheme } = useColorScheme();
 
@@ -400,7 +402,7 @@ const ShiftsScreen: React.FC = () => {
 
   return (
     <>
-      <Stack.Screen options={{ title: t('shifts.title'), headerShown: true }} />
+      <Stack.Screen options={{ title: shiftsTitle, headerShown: true }} />
       <View className="flex-1 bg-gray-50 dark:bg-gray-900" testID="shifts-screen">
         <FocusAwareStatusBar />
         <ShiftSegmentBar segments={segments} active={activeView} onChange={handleSegmentChange} />
diff --git a/src/app/(app)/work-orders/[id].tsx b/src/app/(app)/work-orders/[id].tsx
index 2e30027f..ece9ac38 100644
--- a/src/app/(app)/work-orders/[id].tsx
+++ b/src/app/(app)/work-orders/[id].tsx
@@ -18,6 +18,7 @@ import { capturePhoto, discardPhoto, PhotoPermissionError } from '@/lib/media/ph
 import { missingField, todayKey, type TransitionFields, transitionNeeds } from '@/lib/workOrders/status';
 import { WorkOrderActivityType } from '@/models/v4/workOrders';
 import { useWorkOrdersStatus } from '@/stores/feature-flags/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 import { useWorkOrdersStore } from '@/stores/workOrders/store';
 
 const blankFields: TransitionFields = { reason: '', resolution: '', cause: '', verification: '', duplicateOf: '', confirmTasks: false };
@@ -31,6 +32,7 @@ const hoursOf = (text: string) => {
 // Transitions and Can* flags drive every button; a stale revision reloads the order and says so.
 export default function WorkOrderScreen() {
   const { t } = useTranslation();
+  const workOrdersTitle = useTerm(TermKeys.WorkOrders, t('workOrders.title'));
   const router = useRouter();
   const { id } = useLocalSearchParams<{ id: string }>();
   const flagStatus = useWorkOrdersStatus();
@@ -110,13 +112,13 @@ export default function WorkOrderScreen() {
 
   return (
     <VStack className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: order?.Number ?? t('workOrders.title') }} />
+      <Stack.Screen options={{ title: order?.Number ?? workOrdersTitle }} />
       <ScrollView contentContainerStyle={{ padding: 16, gap: 12 }} keyboardShouldPersistTaps="handled">
         <HStack space="sm" className="items-center">
           <Pressable onPress={() => router.back()} testID="work-order-back" accessibilityRole="button" accessibilityLabel={t('workOrders.back')}>
             <ArrowLeft size={22} color="#2563eb" />
           </Pressable>
-          <Text className="flex-1 text-xl font-bold">{order?.Title ?? t('workOrders.title')}</Text>
+          <Text className="flex-1 text-xl font-bold">{order?.Title ?? workOrdersTitle}</Text>
         </HStack>
         {busy && !detail ? <Spinner /> : null}
         {error ? (
diff --git a/src/app/(app)/work-orders/index.tsx b/src/app/(app)/work-orders/index.tsx
index 4b5d246a..b0702e74 100644
--- a/src/app/(app)/work-orders/index.tsx
+++ b/src/app/(app)/work-orders/index.tsx
@@ -12,12 +12,14 @@ import { VStack } from '@/components/ui/vstack';
 import { isOpen } from '@/lib/workOrders/status';
 import { WorkOrderPriority } from '@/models/v4/workOrders';
 import { useWorkOrdersStatus } from '@/stores/feature-flags/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 import { useWorkOrdersStore } from '@/stores/workOrders/store';
 
 // Work orders the person reported or that are assigned to them or their roles (Maintenance.WorkOrders).
 // Reporting a problem needs the department's Readiness Pro maintenance; reading never does.
 export default function WorkOrdersScreen() {
   const { t } = useTranslation();
+  const workOrdersTitle = useTerm(TermKeys.WorkOrders, t('workOrders.title'));
   const router = useRouter();
   const flagStatus = useWorkOrdersStatus();
   const { access, assignedToMe, items, hasMore, canWrite, busy, error } = useWorkOrdersStore();
@@ -32,10 +34,10 @@ export default function WorkOrdersScreen() {
 
   return (
     <VStack className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: t('workOrders.title') }} />
+      <Stack.Screen options={{ title: workOrdersTitle }} />
       <ScrollView contentContainerStyle={{ padding: 16, gap: 12 }} refreshControl={<RefreshControl refreshing={busy} onRefresh={() => void useWorkOrdersStore.getState().load()} />}>
         <HStack className="items-center justify-between">
-          <Text className="text-xl font-bold">{t('workOrders.title')}</Text>
+          <Text className="text-xl font-bold">{workOrdersTitle}</Text>
           {canWrite ? (
             <Button size="sm" onPress={() => router.push('/work-orders/new' as Href)} testID="work-orders-report">
               <ButtonText>{t('workOrders.report')}</ButtonText>
diff --git a/src/app/call/[id]/edit.tsx b/src/app/call/[id]/edit.tsx
index 3d7c5aae..802a3268 100644
--- a/src/app/call/[id]/edit.tsx
+++ b/src/app/call/[id]/edit.tsx
@@ -33,6 +33,7 @@ import { useAnalytics } from '@/hooks/use-analytics';
 import { useNewCallFieldPolicy } from '@/hooks/use-new-call-field-policy';
 import {
   CALL_FORM_UNCOLLECTED_FIELD_KEYS,
+  findCallType,
   formatCallFieldLabels,
   formatCallGeolocation,
   getMissingCallFieldsFromError,
@@ -320,7 +321,7 @@ export default function EditCall() {
           timestamp: new Date().toISOString(),
           callId: callId || '',
           priority: callPriorities.find((p) => p.Id === call.Priority)?.Name || 'Unknown',
-          type: callTypes.find((t) => t.Name === call.Type)?.Name || 'Unknown',
+          type: findCallType(callTypes, call)?.Name || 'Unknown',
           priorityCount: callPriorities.length,
           typeCount: callTypes.length,
           hasGoogleMapsKey: !!config?.GoogleMapsKey,
@@ -351,8 +352,8 @@ export default function EditCall() {
       });
 
       const priority = useCallsStore.getState().callPriorities.find((p) => p.Id === call.Priority);
-      // Call.Type is the type's text, not its id -- matching on Id left the picker blank on every edit.
-      const type = useCallsStore.getState().callTypes.find((t) => t.Name === call.Type);
+      // Call.Type is the type's text, not its id -- matching it on Id left the picker blank on every edit; TypeId is the id.
+      const type = findCallType(useCallsStore.getState().callTypes, call);
 
       // Parse dispatched items from callExtraData
       const dispatchedUsers: string[] = [];
@@ -449,7 +450,7 @@ export default function EditCall() {
       setValue('priority', priority.Name);
     }
 
-    const type = callTypes.find((candidate) => candidate.Name === call.Type);
+    const type = findCallType(callTypes, call);
     if (type && !getValues('type')) {
       setValue('type', type.Name);
     }
diff --git a/src/app/records/[id].tsx b/src/app/records/[id].tsx
index 7b0df901..b3b1b892 100644
--- a/src/app/records/[id].tsx
+++ b/src/app/records/[id].tsx
@@ -14,16 +14,19 @@ import { Heading } from '@/components/ui/heading';
 import { Spinner } from '@/components/ui/spinner';
 import { Text } from '@/components/ui/text';
 import { VStack } from '@/components/ui/vstack';
+import { useRecordDefinitionName } from '@/hooks/use-record-definition-name';
 import { logger } from '@/lib/logging';
 import { toValueList, toValueMap, unsupportedFieldKeys, validate, type ValidationIssue, type ValueMap } from '@/lib/records/schema';
 import { type RecordData, type RecordDefinitionSchema, RmsRecordState } from '@/models/v4/records';
 import { useRecordsStore } from '@/stores/records/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 // One Record: edit while it is a draft or returned, then submit or finalize online. Amendment, void
 // and approval stay Web-first (RMS plan RMS-1D), so they are not offered here.
 
 export default function RecordScreen() {
   const { t } = useTranslation();
+  const recordsTitle = useTerm(TermKeys.Records, t('records.title'));
   const router = useRouter();
   const { id } = useLocalSearchParams<{ id: string }>();
 
@@ -83,6 +86,7 @@ export default function RecordScreen() {
   const unsupported = useMemo(() => unsupportedFieldKeys(schema), [schema]);
   const editable = record ? record.State === RmsRecordState.Draft || record.State === RmsRecordState.Returned : false;
   const entry = record?.DefinitionKey ? entryFor(record.DefinitionKey, record.DefinitionVersion) : null;
+  const definitionName = useRecordDefinitionName(record?.DefinitionKey, entry?.Name);
 
   const handleChange = useCallback((next: ValueMap) => {
     setValues(next);
@@ -98,7 +102,7 @@ export default function RecordScreen() {
         recordId: current.RecordId,
         definitionKey: current.DefinitionKey ?? '',
         definitionVersion: current.DefinitionVersion,
-        name: current.RecordNumber ?? current.DraftReference ?? entry?.Name ?? t('records.untitled'),
+        name: current.RecordNumber ?? current.DraftReference ?? definitionName ?? t('records.untitled'),
         values: toValueList(values),
         rowVersion: current.RowVersion,
         updatedOn: new Date().toISOString(),
@@ -114,7 +118,7 @@ export default function RecordScreen() {
       discardDraft(clientRecordId);
       return fetchRecord();
     },
-    [values, entry, stageDraft, pushDraft, discardDraft, fetchRecord, t]
+    [values, definitionName, stageDraft, pushDraft, discardDraft, fetchRecord, t]
   );
 
   const save = useCallback(async () => {
@@ -196,7 +200,7 @@ export default function RecordScreen() {
   if (!record) {
     return (
       <Box className="flex-1 items-center justify-center bg-background-0">
-        <Stack.Screen options={{ title: t('records.title') }} />
+        <Stack.Screen options={{ title: recordsTitle }} />
         {isBusy ? <Spinner /> : <Text className="text-typography-500">{message ?? t('records.not_found')}</Text>}
       </Box>
     );
@@ -204,10 +208,10 @@ export default function RecordScreen() {
 
   return (
     <Box className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: record.RecordNumber ?? record.DraftReference ?? t('records.title') }} />
+      <Stack.Screen options={{ title: record.RecordNumber ?? record.DraftReference ?? recordsTitle }} />
       <ScrollView contentContainerClassName="p-4">
         <VStack space="sm" className="mb-4">
-          <Heading size="sm">{entry?.Name ?? record.DefinitionKey ?? t('records.title')}</Heading>
+          <Heading size="sm">{definitionName ?? recordsTitle}</Heading>
           <Badge action="muted" size="sm" className="self-start">
             <BadgeText>{record.StateName ?? RmsRecordState[record.State] ?? ''}</BadgeText>
           </Badge>
diff --git a/src/app/records/__tests__/[id].test.tsx b/src/app/records/__tests__/[id].test.tsx
index 9eabe138..d4ce2277 100644
--- a/src/app/records/__tests__/[id].test.tsx
+++ b/src/app/records/__tests__/[id].test.tsx
@@ -4,6 +4,7 @@ import React from 'react';
 import { getRecord } from '@/api/records/records';
 import { RmsRecordState } from '@/models/v4/records';
 import { useRecordsStore } from '@/stores/records/store';
+import { terminologyStore } from '@/stores/terminology/store';
 
 import RecordScreen from '../[id]';
 
@@ -194,4 +195,17 @@ describe('RecordScreen', () => {
     expect(store.finalize).not.toHaveBeenCalled();
     unmount();
   });
+
+  it("heads a built-in record with the department's name for its type, never its key", async () => {
+    mockGetRecord.mockReset();
+    mockGetRecord.mockResolvedValue({ Data: { ...record(4), DefinitionKey: 'system.run' } } as never);
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+
+    const { unmount } = render(<RecordScreen />);
+
+    expect(await screen.findByText('Incident')).toBeTruthy();
+    expect(screen.queryByText('system.run')).toBeNull();
+    unmount();
+    terminologyStore.setState({ names: {} });
+  });
 });
diff --git a/src/app/records/new.tsx b/src/app/records/new.tsx
index 32ac9c3b..36434d23 100644
--- a/src/app/records/new.tsx
+++ b/src/app/records/new.tsx
@@ -15,6 +15,7 @@ import { Pressable } from '@/components/ui/pressable';
 import { Spinner } from '@/components/ui/spinner';
 import { Text } from '@/components/ui/text';
 import { VStack } from '@/components/ui/vstack';
+import { useRecordDefinitionNameResolver } from '@/hooks/use-record-definition-name';
 import { useRecordsContext } from '@/hooks/use-records-context';
 import { canAuthorOffline, cellKey, toValueList, unsupportedFieldKeys, validate, type ValidationIssue, type ValueMap } from '@/lib/records/schema';
 import { type FieldRecordCatalogEntry, type RecordDefinitionSchema } from '@/models/v4/records';
@@ -30,6 +31,7 @@ export default function NewRecordScreen() {
   const router = useRouter();
   const params = useLocalSearchParams<{ draft?: string; definitionKey?: string }>();
   const context = useRecordsContext();
+  const definitionName = useRecordDefinitionNameResolver();
 
   const catalog = useRecordsStore((state) => state.catalog);
   const pendingDrafts = useRecordsStore((state) => state.pendingDrafts);
@@ -179,7 +181,7 @@ export default function NewRecordScreen() {
                 <Pressable className="px-4 py-4" onPress={() => void choose(definition)} testID={`records-choose-${definition.DefinitionKey}`}>
                   <HStack className="items-center" space="md">
                     <VStack className="flex-1">
-                      <Text className="font-medium text-typography-900">{definition.Name}</Text>
+                      <Text className="font-medium text-typography-900">{definitionName(definition.DefinitionKey, definition.Name)}</Text>
                       <HStack space="xs" className="mt-1 flex-wrap items-center">
                         {definition.Category ? <Text className="text-xs text-typography-500">{definition.Category}</Text> : null}
                         {definition.RequiresProtectedGrant ? (
@@ -208,7 +210,7 @@ export default function NewRecordScreen() {
 
   return (
     <Box className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: entry.Name }} />
+      <Stack.Screen options={{ title: definitionName(entry.DefinitionKey, entry.Name) ?? entry.Name }} />
       <ScrollView contentContainerClassName="p-4">
         {unsupported.length > 0 ? (
           <Box className="mb-4 rounded-md border border-warning-300 bg-background-warning p-3">
diff --git a/src/components/calendar/enhanced-calendar-view.tsx b/src/components/calendar/enhanced-calendar-view.tsx
index a8d8eec1..a156fa0b 100644
--- a/src/components/calendar/enhanced-calendar-view.tsx
+++ b/src/components/calendar/enhanced-calendar-view.tsx
@@ -12,6 +12,7 @@ import { VStack } from '@/components/ui/vstack';
 import { extractDatePart, formatLocalDateString, getTodayLocalString, isDateInRange, resolveAllDayEndDate } from '@/lib/utils';
 import { type CalendarItemResultData } from '@/models/v4/calendar/calendarItemResultData';
 import { useCalendarStore } from '@/stores/calendar/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 interface EnhancedCalendarViewProps {
   onDayPress?: (date: DateData) => void;
@@ -21,6 +22,7 @@ interface EnhancedCalendarViewProps {
 
 export const EnhancedCalendarView: React.FC<EnhancedCalendarViewProps> = ({ onDayPress, onMonthChange, testID = 'enhanced-calendar-view' }) => {
   const { t } = useTranslation();
+  const calendarTitle = useTerm(TermKeys.Calendar, t('calendar.title'));
   const colorScheme = useColorScheme();
   const isDark = colorScheme === 'dark';
 
@@ -164,7 +166,7 @@ export const EnhancedCalendarView: React.FC<EnhancedCalendarViewProps> = ({ onDa
       {/* Calendar Header with Today Button */}
       <HStack className="items-center justify-between border-b border-gray-200 px-4 py-3 dark:border-gray-700">
         <Heading size="md" className="text-gray-900 dark:text-white">
-          {t('calendar.title')}
+          {calendarTitle}
         </Heading>
         <Button variant="outline" size="sm" onPress={goToToday} className="border-primary-500" testID={`${testID}-today-button`}>
           <ButtonText className="text-primary-600 dark:text-primary-400">{t('calendar.tabs.today')}</ButtonText>
diff --git a/src/components/home/__tests__/status-buttons.test.tsx b/src/components/home/__tests__/status-buttons.test.tsx
index 7c2045da..1a1b76ed 100644
--- a/src/components/home/__tests__/status-buttons.test.tsx
+++ b/src/components/home/__tests__/status-buttons.test.tsx
@@ -93,6 +93,38 @@ describe('StatusButtons', () => {
     expect(screen.queryByText('System Status 5')).toBeNull();
   });
 
+  it("shows a department's own options even when their ids collide with the legacy built-in ids", () => {
+    mockUseCoreStore.mockReturnValue({
+      activeStatuses: [
+        createStatus({ Id: 4, StateId: 1, Text: 'In Quarters', Detail: 0 }),
+        createStatus({ Id: 5, StateId: 1, Text: 'Responding', Detail: 2 }),
+        createStatus({ Id: 6, StateId: 1, Text: 'On Scene', Detail: 0 }),
+        createStatus({ Id: 7, StateId: 1, Text: 'Returning', Detail: 1 }),
+      ],
+    } as ReturnType<typeof useCoreStore>);
+
+    render(<StatusButtons />);
+
+    expect(screen.getByText('In Quarters')).toBeTruthy();
+    expect(screen.getByText('Responding')).toBeTruthy();
+    expect(screen.getByText('On Scene')).toBeTruthy();
+    expect(screen.getByText('Returning')).toBeTruthy();
+  });
+
+  it('still hides the built-in legacy ids when StateId is missing (older payloads)', () => {
+    const missingStateId = createStatus({ Id: 6, Text: 'Responding to Scene', Detail: 0 });
+    delete (missingStateId as Partial<StatusesResultData>).StateId;
+
+    mockUseCoreStore.mockReturnValue({
+      activeStatuses: [createStatus({ Id: 0, Text: 'Available', Detail: 0 }), missingStateId],
+    } as ReturnType<typeof useCoreStore>);
+
+    render(<StatusButtons />);
+
+    expect(screen.getByText('Available')).toBeTruthy();
+    expect(screen.queryByText('Responding to Scene')).toBeNull();
+  });
+
   it('does not hide non-legacy statuses just because they use newer detail values', () => {
     mockUseCoreStore.mockReturnValue({
       activeStatuses: [
diff --git a/src/components/home/status-buttons.tsx b/src/components/home/status-buttons.tsx
index 5c1fcd1b..967f9b5f 100644
--- a/src/components/home/status-buttons.tsx
+++ b/src/components/home/status-buttons.tsx
@@ -18,6 +18,13 @@ import { useToastStore } from '@/stores/toast/store';
 
 const LEGACY_HIDDEN_STATUS_IDS = [4, 5, 6, 7];
 
+/**
+ * Built-in options (StateId 0 / missing) 4-7 are the legacy system-managed statuses (Available Station, Responding
+ * to Station, Responding to Scene, On Unit). A department's own options carry their set's id in StateId and can have
+ * any id, including 4-7 on a fresh install, so they are never hidden.
+ */
+const isLegacyHiddenStatus = (status: StatusesResultData): boolean => !Number(status.StateId) && LEGACY_HIDDEN_STATUS_IDS.includes(status.Id);
+
 /** The red outline that marks the member's current status. */
 const CURRENT_STATUS_BORDER = '#dc2626';
 
@@ -96,10 +103,10 @@ export const StatusButtons: React.FC = () => {
   const isHoldMode = config?.StatusHoldToConfirm === true;
   const currentStatusType = (currentUserStatus ?? coreCurrentStatus)?.StatusType;
 
-  // These IDs are legacy system-managed statuses that Resgrid sets internally.
+  // Built-in options 4-7 are legacy system-managed statuses that Resgrid sets internally.
   // They predate the newer Detail-based destination model and should stay hidden
   // from the Home tab buttons even though they may still be applied under the hood.
-  const visibleStatuses = React.useMemo(() => (activeStatuses ?? []).filter((status) => !LEGACY_HIDDEN_STATUS_IDS.includes(status.Id)), [activeStatuses]);
+  const visibleStatuses = React.useMemo(() => (activeStatuses ?? []).filter((status) => !isLegacyHiddenStatus(status)), [activeStatuses]);
   const currentStatusId = React.useMemo(() => resolveCurrentStatusId(activeStatuses, { StateId: currentStatusType }), [activeStatuses, currentStatusType]);
   const offeredStatuses = React.useMemo(() => getOfferedStatuses(visibleStatuses, currentStatusId, showAllStatuses), [currentStatusId, showAllStatuses, visibleStatuses]);
   const hasNextStatusRestriction = React.useMemo(() => showAllStatuses && getOfferedStatuses(visibleStatuses, currentStatusId, false).isRestricted, [currentStatusId, showAllStatuses, visibleStatuses]);
diff --git a/src/components/records/__tests__/record-list-item.test.tsx b/src/components/records/__tests__/record-list-item.test.tsx
new file mode 100644
index 00000000..e4e8cbc7
--- /dev/null
+++ b/src/components/records/__tests__/record-list-item.test.tsx
@@ -0,0 +1,158 @@
+import { render, screen } from '@testing-library/react-native';
+import React from 'react';
+
+import { type FieldRecordCatalogEntry, type RecordSummaryData, RmsRecordState } from '@/models/v4/records';
+import { type PendingRecordDraft } from '@/stores/records/store';
+import { terminologyStore } from '@/stores/terminology/store';
+
+import { PendingDraftItem, RecordListItem } from '../record-list-item';
+
+interface MockChildrenProps {
+  children?: React.ReactNode;
+  testID?: string;
+}
+
+jest.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('lucide-react-native', () => ({ AlertTriangle: () => null, CloudOff: () => null, FileText: () => null }));
+
+const mockRecordsState: { catalog: { Definitions: Partial<FieldRecordCatalogEntry>[] } | null } = { catalog: null };
+jest.mock('@/stores/records/store', () => ({
+  useRecordsStore: <T,>(selector: (state: typeof mockRecordsState) => T) => selector(mockRecordsState),
+}));
+
+jest.mock('@/components/ui/badge', () => {
+  const { Text, View } = require('react-native');
+  return {
+    Badge: ({ children }: MockChildrenProps) => <View>{children}</View>,
+    BadgeText: ({ children }: MockChildrenProps) => <Text>{children}</Text>,
+  };
+});
+
+jest.mock('@/components/ui/box', () => {
+  const { View } = require('react-native');
+  return { Box: ({ children }: MockChildrenProps) => <View>{children}</View> };
+});
+
+jest.mock('@/components/ui/hstack', () => {
+  const { View } = require('react-native');
+  return { HStack: ({ children }: MockChildrenProps) => <View>{children}</View> };
+});
+
+jest.mock('@/components/ui/vstack', () => {
+  const { View } = require('react-native');
+  return { VStack: ({ children }: MockChildrenProps) => <View>{children}</View> };
+});
+
+jest.mock('@/components/ui/pressable', () => {
+  const { TouchableOpacity } = require('react-native');
+  return { Pressable: ({ children, testID }: MockChildrenProps) => <TouchableOpacity testID={testID}>{children}</TouchableOpacity> };
+});
+
+jest.mock('@/components/ui/text', () => {
+  const { Text } = require('react-native');
+  return { Text };
+});
+
+const summary = (overrides: Partial<RecordSummaryData>): RecordSummaryData => ({
+  RecordId: 'r1',
+  DefinitionKey: 'system.run',
+  DefinitionVersion: 1,
+  State: RmsRecordState.Draft,
+  CreatedOn: '2026-10-01T00:00:00Z',
+  ModifiedOn: '2026-10-01T00:00:00Z',
+  RowVersion: 1,
+  ...overrides,
+});
+
+const draft = (overrides: Partial<PendingRecordDraft>): PendingRecordDraft => ({
+  clientRecordId: 'draft-1',
+  recordId: null,
+  definitionKey: 'system.run',
+  definitionVersion: 1,
+  name: 'Run',
+  values: [],
+  updatedOn: '2026-10-01T00:00:00Z',
+  ...overrides,
+});
+
+describe('RecordListItem record type names', () => {
+  beforeEach(() => {
+    mockRecordsState.catalog = null;
+    terminologyStore.setState({ names: {} });
+  });
+
+  it("shows the department's name for a built-in type instead of its key", () => {
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+
+    render(<RecordListItem record={summary({ DisplaySummary: 'Engine 1' })} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Incident')).toBeTruthy();
+    expect(screen.queryByText('system.run')).toBeNull();
+  });
+
+  it('shows the renamed type under the record number when there is no summary', () => {
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+
+    render(<RecordListItem record={summary({ RecordNumber: 'R-26-1' })} onPress={jest.fn()} />);
+
+    expect(screen.getByText('R-26-1')).toBeTruthy();
+    expect(screen.getByText('Incident')).toBeTruthy();
+  });
+
+  it('names a legacy record by its type number', () => {
+    terminologyStore.setState({ names: { 'record-type.training': 'Drill' } });
+
+    render(<RecordListItem record={summary({ DefinitionKey: null, RecordType: 2 })} onPress={jest.fn()} />);
+
+    expect(screen.getAllByText('Drill').length).toBeGreaterThan(0);
+  });
+
+  it("falls back to the catalog's name when the type is not renamed", () => {
+    mockRecordsState.catalog = { Definitions: [{ DefinitionKey: 'system.run', Name: 'Run' }] };
+
+    render(<RecordListItem record={summary({})} onPress={jest.fn()} />);
+
+    expect(screen.getAllByText('Run').length).toBeGreaterThan(0);
+    expect(screen.queryByText('system.run')).toBeNull();
+  });
+
+  it('never shows a raw built-in key, even with no catalog loaded', () => {
+    render(<RecordListItem record={summary({ DefinitionKey: 'system.unit-activity' })} onPress={jest.fn()} />);
+
+    expect(screen.getAllByText('Unit activity').length).toBeGreaterThan(0);
+    expect(screen.queryByText('system.unit-activity')).toBeNull();
+  });
+
+  it("uses the catalog's name for a department definition", () => {
+    mockRecordsState.catalog = { Definitions: [{ DefinitionKey: 'hydrant-test', Name: 'Hydrant test' }] };
+
+    render(<RecordListItem record={summary({ DefinitionKey: 'hydrant-test' })} onPress={jest.fn()} />);
+
+    expect(screen.getAllByText('Hydrant test').length).toBeGreaterThan(0);
+  });
+});
+
+describe('PendingDraftItem record type names', () => {
+  beforeEach(() => {
+    mockRecordsState.catalog = null;
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+  });
+
+  afterAll(() => {
+    terminologyStore.setState({ names: {} });
+  });
+
+  it('labels a new draft with the renamed type', () => {
+    render(<PendingDraftItem draft={draft({})} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Incident')).toBeTruthy();
+    expect(screen.queryByText('Run')).toBeNull();
+  });
+
+  it("keeps an edit draft's record number", () => {
+    render(<PendingDraftItem draft={draft({ clientRecordId: 'edit-r1-2', recordId: 'r1', name: 'R-26-1' })} onPress={jest.fn()} />);
+
+    expect(screen.getByText('R-26-1')).toBeTruthy();
+    expect(screen.queryByText('Incident')).toBeNull();
+  });
+});
diff --git a/src/components/records/record-list-item.tsx b/src/components/records/record-list-item.tsx
index 01803cd0..e451a27b 100644
--- a/src/components/records/record-list-item.tsx
+++ b/src/components/records/record-list-item.tsx
@@ -8,6 +8,7 @@ import { HStack } from '@/components/ui/hstack';
 import { Pressable } from '@/components/ui/pressable';
 import { Text } from '@/components/ui/text';
 import { VStack } from '@/components/ui/vstack';
+import { useRecordDefinitionName } from '@/hooks/use-record-definition-name';
 import { type FieldRecordAssignmentData, type RecordSummaryData, RmsRecordState } from '@/models/v4/records';
 import { type PendingRecordDraft } from '@/stores/records/store';
 
@@ -29,7 +30,8 @@ const stateAction = (state: number): 'muted' | 'info' | 'warning' | 'success' |
 
 export const RecordListItem: React.FC<{ record: RecordSummaryData; onPress: () => void; testID?: string }> = ({ record, onPress, testID }) => {
   const { t } = useTranslation();
-  const title = record.RecordNumber || record.DraftReference || record.DefinitionKey || t('records.untitled');
+  const definitionName = useRecordDefinitionName(record.DefinitionKey, null, record.RecordType);
+  const title = record.RecordNumber || record.DraftReference || definitionName || t('records.untitled');
 
   return (
     <Pressable onPress={onPress} className="px-4 py-3" testID={testID}>
@@ -42,7 +44,7 @@ export const RecordListItem: React.FC<{ record: RecordSummaryData; onPress: () =
             {title}
           </Text>
           <Text className="text-xs text-typography-500" numberOfLines={1}>
-            {record.DisplaySummary || record.DefinitionKey || ''}
+            {record.DisplaySummary || definitionName || ''}
           </Text>
         </VStack>
         <Badge action={stateAction(record.State)} size="sm">
@@ -55,6 +57,9 @@ export const RecordListItem: React.FC<{ record: RecordSummaryData; onPress: () =
 
 export const PendingDraftItem: React.FC<{ draft: PendingRecordDraft; onPress: () => void; testID?: string }> = ({ draft, onPress, testID }) => {
   const { t } = useTranslation();
+  // A new draft is labelled with its definition's name; an edit keeps the record's own number.
+  const definitionName = useRecordDefinitionName(draft.definitionKey, draft.name);
+  const name = draft.recordId ? draft.name : definitionName;
 
   return (
     <Pressable onPress={onPress} className="px-4 py-3" testID={testID}>
@@ -62,7 +67,7 @@ export const PendingDraftItem: React.FC<{ draft: PendingRecordDraft; onPress: ()
         <Box className="size-10 items-center justify-center rounded-full bg-background-100">{draft.conflict ? <AlertTriangle size={18} color="#d97706" /> : <CloudOff size={18} color="#64748b" />}</Box>
         <VStack className="flex-1">
           <Text className="font-medium text-typography-900" numberOfLines={1}>
-            {draft.name}
+            {name}
           </Text>
           <Text className="text-xs text-typography-500" numberOfLines={1}>
             {draft.conflict ? t(`records.conflict_${draft.conflict.replace('-', '_')}`) : t('records.not_sent_yet')}
diff --git a/src/components/sidebar/__tests__/side-menu.test.tsx b/src/components/sidebar/__tests__/side-menu.test.tsx
index ef9844f3..0eeeb2c2 100644
--- a/src/components/sidebar/__tests__/side-menu.test.tsx
+++ b/src/components/sidebar/__tests__/side-menu.test.tsx
@@ -1,5 +1,5 @@
 import React from 'react';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react-native';
+import { act, render, screen, fireEvent, waitFor } from '@testing-library/react-native';
 import { useRouter } from 'expo-router';
 import { useColorScheme } from 'nativewind';
 
@@ -7,6 +7,7 @@ import { SideMenu } from '../side-menu';
 import { useLiveKitStore } from '@/stores/app/livekit-store';
 import { useAudioStreamStore } from '@/stores/app/audio-stream-store';
 import { securityStore } from '@/stores/security/store';
+import { terminologyStore } from '@/stores/terminology/store';
 
 // Mock dependencies
 jest.mock('expo-router', () => ({
@@ -612,4 +613,41 @@ describe('SideMenu', () => {
       expect(screen.getByTestId('side-menu-audio-button')).toBeTruthy();
     });
   });
+
+  describe('Department terminology', () => {
+    beforeEach(() => {
+      terminologyStore.setState({ names: {} });
+      mockStore(mockUseLiveKitStore, {
+        isConnected: false,
+        setIsBottomSheetVisible: mockSetIsBottomSheetVisible,
+        toggleMicrophone: mockToggleMicrophone,
+      });
+    });
+
+    afterAll(() => {
+      terminologyStore.setState({ names: {} });
+    });
+
+    it('labels a renamed module with the department name and keeps the app label for the rest', () => {
+      terminologyStore.setState({ names: { 'module.contacts': 'Preplans', 'module.mapping': 'GIS' } });
+
+      render(<SideMenu />);
+
+      expect(screen.getByTestId('side-menu-contacts')).toHaveTextContent('Preplans');
+      expect(screen.getByTestId('side-menu-map')).toHaveTextContent('GIS');
+      expect(screen.getByTestId('side-menu-notes')).toHaveTextContent('tabs.notes');
+      expect(screen.getByTestId('side-menu-messages')).toHaveTextContent('tabs.messages');
+    });
+
+    it('relabels the menu when the names arrive after it rendered', () => {
+      render(<SideMenu />);
+      expect(screen.getByTestId('side-menu-calendar')).toHaveTextContent('tabs.calendar');
+
+      act(() => {
+        terminologyStore.setState({ names: { 'module.calendar': 'Schedule' } });
+      });
+
+      expect(screen.getByTestId('side-menu-calendar')).toHaveTextContent('Schedule');
+    });
+  });
 });
diff --git a/src/components/sidebar/side-menu-content.tsx b/src/components/sidebar/side-menu-content.tsx
index c20f0bf8..26fb4b1b 100644
--- a/src/components/sidebar/side-menu-content.tsx
+++ b/src/components/sidebar/side-menu-content.tsx
@@ -43,6 +43,7 @@ import { useAudioStreamStore } from '@/stores/app/audio-stream-store';
 import { useLiveKitStore } from '@/stores/app/livekit-store';
 import { useIsChatEnabled, useIsChecklistsEnabled, useIsDeploymentsEnabled, useIsRecordsFieldEnabled, useIsWorkOrdersEnabled } from '@/stores/feature-flags/store';
 import { securityStore } from '@/stores/security/store';
+import { terminologyStore, TermKeys } from '@/stores/terminology/store';
 
 import { AudioStreamBottomSheet } from '../audio-stream/audio-stream-bottom-sheet';
 
@@ -75,6 +76,8 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
   const isDeploymentsEnabled = useIsDeploymentsEnabled();
   const isRecordsEnabled = useIsRecordsFieldEnabled();
   const isWorkOrdersEnabled = useIsWorkOrdersEnabled();
+  // The department's own names for its modules; an unrenamed module keeps the app's translated label.
+  const termNames = terminologyStore((state) => state.names);
 
   const menuItems: MenuItem[] = useMemo(
     () =>
@@ -95,21 +98,21 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'contacts',
-          title: t('tabs.contacts'),
+          title: termNames[TermKeys.Contacts] || t('tabs.contacts'),
           icon: Contact,
           route: '/(app)/contacts',
           testID: 'side-menu-contacts',
         },
         {
           id: 'map',
-          title: t('tabs.map'),
+          title: termNames[TermKeys.Mapping] || t('tabs.map'),
           icon: MapIcon,
           route: '/(app)/map',
           testID: 'side-menu-map',
         },
         {
           id: 'notes',
-          title: t('tabs.notes'),
+          title: termNames[TermKeys.Notes] || t('tabs.notes'),
           icon: Notebook,
           route: '/(app)/notes',
           testID: 'side-menu-notes',
@@ -123,14 +126,14 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'calendar',
-          title: t('tabs.calendar'),
+          title: termNames[TermKeys.Calendar] || t('tabs.calendar'),
           icon: Calendar,
           route: '/calendar',
           testID: 'side-menu-calendar',
         },
         {
           id: 'shifts',
-          title: t('tabs.shifts'),
+          title: termNames[TermKeys.Shifts] || t('tabs.shifts'),
           icon: CalendarCheck,
           route: '/(app)/shifts',
           testID: 'side-menu-shifts',
@@ -144,14 +147,14 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'checklists',
-          title: t('checklists.labels.Checklists'),
+          title: termNames[TermKeys.Checklists] || t('checklists.labels.Checklists'),
           icon: FileText,
           route: '/(app)/checklists',
           testID: 'side-menu-checklists',
         },
         {
           id: 'records',
-          title: t('tabs.records'),
+          title: termNames[TermKeys.Records] || t('tabs.records'),
           icon: FileText,
           route: '/(app)/records',
           testID: 'side-menu-records',
@@ -165,7 +168,7 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'workOrders',
-          title: t('workOrders.title'),
+          title: termNames[TermKeys.WorkOrders] || t('workOrders.title'),
           icon: Wrench,
           route: '/(app)/work-orders',
           testID: 'side-menu-work-orders',
@@ -212,7 +215,7 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         }
         return true;
       }),
-    [t, isChatEnabled, isRecordsEnabled, isChecklistsEnabled, isDeploymentsEnabled, isWorkOrdersEnabled]
+    [t, termNames, isChatEnabled, isRecordsEnabled, isChecklistsEnabled, isDeploymentsEnabled, isWorkOrdersEnabled]
   );
 
   const handleNavigation = useCallback(
diff --git a/src/components/units/__tests__/unit-card.test.tsx b/src/components/units/__tests__/unit-card.test.tsx
new file mode 100644
index 00000000..5ca4a839
--- /dev/null
+++ b/src/components/units/__tests__/unit-card.test.tsx
@@ -0,0 +1,111 @@
+import { render, screen } from '@testing-library/react-native';
+import React from 'react';
+
+import { type StatusesResultData } from '@/models/v4/statuses/statusesResultData';
+import { type UnitTypeStatusResultData } from '@/models/v4/statuses/unitTypeStatusResultData';
+import { type UnitInfoResultData } from '@/models/v4/units/unitInfoResultData';
+
+import { UnitCard } from '../unit-card';
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+const createStatus = (overrides: Partial<StatusesResultData>): StatusesResultData => ({
+  Id: 0,
+  Type: 0,
+  StateId: 0,
+  Text: '',
+  BColor: '#2563eb',
+  Color: '#ffffff',
+  Gps: false,
+  Note: 0,
+  Detail: 0,
+  ...overrides,
+});
+
+const createUnit = (overrides: Partial<UnitInfoResultData>): UnitInfoResultData => ({
+  UnitId: 'unit-1',
+  DepartmentId: '1',
+  Name: 'Engine 1',
+  Type: 'Engine',
+  TypeId: 1,
+  CustomStatusSetId: '',
+  GroupId: '',
+  GroupName: '',
+  Vin: '',
+  PlateNumber: '',
+  FourWheelDrive: false,
+  SpecialPermit: false,
+  CurrentDestinationId: '',
+  CurrentDestinationName: '',
+  CurrentStatusId: '',
+  CurrentStatus: 'Server Status Text',
+  CurrentStatusColor: '',
+  CurrentStatusTimestampUtc: '',
+  Latitude: '',
+  Longitude: '',
+  Note: '',
+  Roles: [],
+  ...overrides,
+});
+
+// Set 12 is the department's "Engine statuses" set, but the unit type has since been renamed, so its group's
+// UnitType no longer matches the unit's Type. Set 20 is attached to whatever type is now called "Engine".
+const unitTypeStatuses: UnitTypeStatusResultData[] = [
+  {
+    UnitType: 'Engine (old name)',
+    StatusId: '12',
+    Statuses: [createStatus({ Id: 40, StateId: 12, Text: 'In Quarters', BColor: '#00ff00' }), createStatus({ Id: 41, StateId: 12, Text: 'Enroute', BColor: '#ff0000' })],
+  },
+  {
+    UnitType: 'Engine',
+    StatusId: '20',
+    Statuses: [createStatus({ Id: 40, StateId: 20, Text: 'Wrong Set Status', BColor: '#0000ff' })],
+  },
+];
+
+describe('UnitCard status lookup', () => {
+  it("prefers the unit's own custom status set over the unit type name", () => {
+    render(<UnitCard unit={createUnit({ CustomStatusSetId: '12', CurrentStatusId: '41' })} unitTypeStatuses={unitTypeStatuses} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Enroute')).toBeTruthy();
+    expect(screen.queryByText('Wrong Set Status')).toBeNull();
+  });
+
+  it('falls back to the unit type name when no custom status set id is sent', () => {
+    render(<UnitCard unit={createUnit({ CustomStatusSetId: '', CurrentStatusId: '40' })} unitTypeStatuses={unitTypeStatuses} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Wrong Set Status')).toBeTruthy();
+  });
+
+  it('falls back to the unit type name when the set id is 0 or not in the list', () => {
+    const { rerender } = render(<UnitCard unit={createUnit({ CustomStatusSetId: '0', CurrentStatusId: '40' })} unitTypeStatuses={unitTypeStatuses} onPress={jest.fn()} />);
+    expect(screen.getByText('Wrong Set Status')).toBeTruthy();
+
+    rerender(<UnitCard unit={createUnit({ CustomStatusSetId: '99', CurrentStatusId: '40' })} unitTypeStatuses={unitTypeStatuses} onPress={jest.fn()} />);
+    expect(screen.getByText('Wrong Set Status')).toBeTruthy();
+  });
+
+  it('matches the status option by its id before the legacy set-id match', () => {
+    // The unit's status id (12) is also the set's id; option 12 is the real status.
+    const groups: UnitTypeStatusResultData[] = [
+      {
+        UnitType: 'Engine',
+        StatusId: '12',
+        Statuses: [createStatus({ Id: 30, StateId: 12, Text: 'First Option' }), createStatus({ Id: 12, StateId: 12, Text: 'Real Status' })],
+      },
+    ];
+
+    render(<UnitCard unit={createUnit({ CustomStatusSetId: '12', CurrentStatusId: '12' })} unitTypeStatuses={groups} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Real Status')).toBeTruthy();
+    expect(screen.queryByText('First Option')).toBeNull();
+  });
+
+  it("shows the server's status text when the status is in no known set", () => {
+    render(<UnitCard unit={createUnit({ Type: 'Ladder', CustomStatusSetId: '', CurrentStatusId: '7' })} unitTypeStatuses={unitTypeStatuses} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Server Status Text')).toBeTruthy();
+  });
+});
diff --git a/src/components/units/unit-card.tsx b/src/components/units/unit-card.tsx
index d6290540..6780a778 100644
--- a/src/components/units/unit-card.tsx
+++ b/src/components/units/unit-card.tsx
@@ -49,17 +49,18 @@ const getContrastTextColor = (hexColor: string): string => {
   return luminance > 0.5 ? '#000000' : '#FFFFFF';
 };
 
-// Helper function to find status data for a unit based on unit type and status ID
-const findUnitStatus = (unitType: string, statusId: string, unitTypeStatuses: UnitTypeStatusResultData[]): StatusesResultData | null => {
+// Helper function to find status data for a unit: its own custom status set (CustomStatusSetId) first, which survives a
+// renamed unit type, then the set for its unit type name.
+const findUnitStatus = (unitType: string, customStatusSetId: string | null | undefined, statusId: string, unitTypeStatuses: UnitTypeStatusResultData[]): StatusesResultData | null => {
   if (!statusId || !unitTypeStatuses.length) return null;
 
-  // Find the status set for this unit type
-  const unitTypeStatus = unitTypeStatuses.find((uts) => uts.UnitType === unitType);
+  const setId = customStatusSetId == null ? '' : String(customStatusSetId).trim();
+  const unitTypeStatus = (setId !== '' && setId !== '0' ? unitTypeStatuses.find((uts) => uts.StatusId === setId) : undefined) ?? unitTypeStatuses.find((uts) => uts.UnitType === unitType);
 
   if (!unitTypeStatus) return null;
 
-  // Find the specific status by StateId
-  const status = unitTypeStatus.Statuses.find((s) => s.StateId.toString() === statusId || s.Id.toString() === statusId);
+  // The status is the option whose Id is the unit's status id; StateId (the option's set id) is the legacy fallback.
+  const status = unitTypeStatus.Statuses.find((s) => s.Id.toString() === statusId) ?? unitTypeStatus.Statuses.find((s) => s.StateId.toString() === statusId);
 
   return status || null;
 };
@@ -87,7 +88,7 @@ export const UnitCard: React.FC<UnitCardProps> = React.memo(function UnitCard({
   const unitType = unit.Type || '';
 
   // Find the status data from unit type statuses (custom statuses)
-  const customStatusData = statusId ? findUnitStatus(unitType, statusId, unitTypeStatuses) : null;
+  const customStatusData = statusId ? findUnitStatus(unitType, unit.CustomStatusSetId, statusId, unitTypeStatuses) : null;
   const destinationText = 'CurrentDestinationName' in unit ? unit.CurrentDestinationName : '';
 
   // Fall back to default status if custom status not found (used for colors only)
diff --git a/src/hooks/use-record-definition-name.ts b/src/hooks/use-record-definition-name.ts
new file mode 100644
index 00000000..6663bc80
--- /dev/null
+++ b/src/hooks/use-record-definition-name.ts
@@ -0,0 +1,52 @@
+import { useCallback } from 'react';
+
+import { useRecordsStore } from '@/stores/records/store';
+import { definitionTermKey, recordTypeTermKey, terminologyStore } from '@/stores/terminology/store';
+
+const RECORD_TYPE_TERM_PREFIX = 'record-type.';
+
+// "record-type.unit-activity" -> "Unit activity": the last resort for a built-in type nothing else names.
+const nameFromTermKey = (termKey: string): string => {
+  const words = termKey
+    .substring(RECORD_TYPE_TERM_PREFIX.length)
+    .replace(/[-_.]+/g, ' ')
+    .trim();
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : termKey;
+};
+
+export type RecordDefinitionNameResolver = (definitionKey: string | null | undefined, knownName?: string | null, recordType?: number | null) => string | null;
+
+/**
+ * Names a record's definition: the department's own word for a built-in type, else `knownName`, else the
+ * catalog's name for it. A built-in ("system.*") key is never returned raw; null only when there is no key.
+ */
+export const useRecordDefinitionNameResolver = (): RecordDefinitionNameResolver => {
+  const names = terminologyStore((state) => state.names);
+  const definitions = useRecordsStore((state) => state.catalog?.Definitions);
+
+  return useCallback(
+    (definitionKey, knownName, recordType) => {
+      const termKey = definitionTermKey(definitionKey) ?? recordTypeTermKey(recordType);
+      const renamed = termKey ? names[termKey] : undefined;
+      if (renamed) {
+        return renamed;
+      }
+      if (knownName) {
+        return knownName;
+      }
+      const key = definitionKey?.toLowerCase();
+      const catalogName = key ? definitions?.find((entry) => entry.DefinitionKey.toLowerCase() === key)?.Name : undefined;
+      if (catalogName) {
+        return catalogName;
+      }
+      if (termKey) {
+        return nameFromTermKey(termKey);
+      }
+      return definitionKey || null;
+    },
+    [names, definitions]
+  );
+};
+
+export const useRecordDefinitionName = (definitionKey: string | null | undefined, knownName?: string | null, recordType?: number | null): string | null =>
+  useRecordDefinitionNameResolver()(definitionKey, knownName, recordType);
diff --git a/src/lib/__tests__/base-types.test.ts b/src/lib/__tests__/base-types.test.ts
new file mode 100644
index 00000000..ba519355
--- /dev/null
+++ b/src/lib/__tests__/base-types.test.ts
@@ -0,0 +1,84 @@
+import {
+  ActionBaseTypes,
+  CallPriorityBaseTypes,
+  StaffingBaseTypes,
+  comparePriorityUrgency,
+  hasBaseType,
+  isEmergencyPriority,
+  isPersonnelInService,
+  isStaffingOnDuty,
+  isStatusAvailable,
+  isStatusOnScene,
+  isStatusResponding,
+  staffingAvailability,
+  statusAvailability,
+} from '../base-types';
+
+describe('base-types', () => {
+  it('classifies status meanings like the server availability matrix', () => {
+    expect(statusAvailability(ActionBaseTypes.InQuarters)).toBe('available');
+    expect(statusAvailability(ActionBaseTypes.Returning)).toBe('committed');
+    expect(statusAvailability(ActionBaseTypes.Maintenance)).toBe('unavailable');
+    expect(statusAvailability(ActionBaseTypes.OnBreak)).toBe('delayed');
+    expect(statusAvailability(ActionBaseTypes.None)).toBe('unknown');
+    expect(statusAvailability(undefined)).toBe('unknown');
+    expect(statusAvailability('23')).toBe('available');
+  });
+
+  it('treats available and delayed statuses as dispatchable', () => {
+    expect(isStatusAvailable(ActionBaseTypes.Available)).toBe(true);
+    expect(isStatusAvailable(ActionBaseTypes.OnBreak)).toBe(true);
+    expect(isStatusAvailable(ActionBaseTypes.Responding)).toBe(false);
+    expect(isStatusAvailable(null)).toBe(false);
+  });
+
+  it('groups responding and on-scene meanings', () => {
+    expect(isStatusResponding(ActionBaseTypes.Dispatched)).toBe(true);
+    expect(isStatusResponding(ActionBaseTypes.Enroute)).toBe(true);
+    expect(isStatusResponding(ActionBaseTypes.OnScene)).toBe(false);
+    expect(isStatusOnScene(ActionBaseTypes.AtPatient)).toBe(true);
+    expect(isStatusOnScene(ActionBaseTypes.Returning)).toBe(false);
+  });
+
+  it('classifies staffing meanings', () => {
+    expect(staffingAvailability(StaffingBaseTypes.OnCall)).toBe('available');
+    expect(staffingAvailability(StaffingBaseTypes.OffDuty)).toBe('unavailable');
+    expect(isStaffingOnDuty(StaffingBaseTypes.OnShift)).toBe(true);
+    expect(isStaffingOnDuty(StaffingBaseTypes.OffDuty)).toBe(false);
+    expect(isStaffingOnDuty(StaffingBaseTypes.None)).toBe(false);
+  });
+
+  it('counts personnel in service the same way in every app', () => {
+    expect(isPersonnelInService({ Status: 'En Route', StatusBaseType: ActionBaseTypes.Enroute, StaffingBaseType: StaffingBaseTypes.Available })).toBe(true);
+    expect(isPersonnelInService({ Status: 'Returning', StatusBaseType: ActionBaseTypes.Returning })).toBe(true);
+    expect(isPersonnelInService({ Status: 'On Break', StatusBaseType: ActionBaseTypes.OnBreak })).toBe(false);
+    expect(isPersonnelInService({ Status: 'Out of Service', StatusBaseType: ActionBaseTypes.Unavailable })).toBe(false);
+    expect(isPersonnelInService({ Status: 'Available', StatusBaseType: ActionBaseTypes.Available })).toBe(false);
+    expect(isPersonnelInService({ Status: 'Responding', StatusBaseType: ActionBaseTypes.Responding, StaffingBaseType: StaffingBaseTypes.OffDuty })).toBe(false);
+    expect(isPersonnelInService({ Status: 'Responding', StatusBaseType: ActionBaseTypes.Responding, StaffingBaseType: StaffingBaseTypes.OnCall })).toBe(true);
+  });
+
+  it('uses the old text rule for a status without a meaning', () => {
+    expect(isPersonnelInService({ Status: 'Responding' })).toBe(true);
+    expect(isPersonnelInService({ Status: 'Code 7', StatusBaseType: -1 })).toBe(true);
+    expect(isPersonnelInService({ Status: 'Available' })).toBe(false);
+    expect(isPersonnelInService({ Status: 'Off Duty' })).toBe(false);
+    expect(isPersonnelInService({ Status: '' })).toBe(false);
+    expect(isPersonnelInService(null)).toBe(false);
+  });
+
+  it('knows when a meaning was sent', () => {
+    expect(hasBaseType(0)).toBe(true);
+    expect(hasBaseType(-1)).toBe(false);
+    expect(hasBaseType(undefined)).toBe(false);
+  });
+
+  it('orders priorities by meaning, then department sort, then id', () => {
+    const emergency = { Id: 57, BaseType: CallPriorityBaseTypes.Emergency, Sort: 3 };
+    const high = { Id: 2, BaseType: CallPriorityBaseTypes.High, Sort: 0 };
+    const unset = { Id: 99, BaseType: CallPriorityBaseTypes.None, Sort: 0 };
+    const sorted = [unset, high, emergency].sort(comparePriorityUrgency);
+    expect(sorted.map((p) => p.Id)).toEqual([57, 2, 99]);
+    expect(isEmergencyPriority(3)).toBe(true);
+  });
+});
diff --git a/src/lib/__tests__/call-field-policy.test.ts b/src/lib/__tests__/call-field-policy.test.ts
index 44fd3bec..a03f95ab 100644
--- a/src/lib/__tests__/call-field-policy.test.ts
+++ b/src/lib/__tests__/call-field-policy.test.ts
@@ -6,6 +6,7 @@ import { NewCallFieldKeys } from '@/models/v4/calls/newCallFieldPolicyResultData
 import {
   CALL_FIELD_LABEL_KEYS,
   CALL_FORM_UNCOLLECTED_FIELD_KEYS,
+  findCallType,
   formatCallFieldLabels,
   formatCallGeolocation,
   getMissingCallFieldsFromError,
@@ -129,6 +130,32 @@ describe('call field policy helpers', () => {
     });
   });
 
+  describe('findCallType', () => {
+    const callTypes = [
+      { Id: '3', Name: 'Structure Fire' },
+      { Id: '7', Name: 'Medical' },
+    ];
+
+    it('should find the type by TypeId, so a renamed type still matches', () => {
+      expect(findCallType(callTypes, { Type: 'Fire (old name)', TypeId: '3' })?.Name).toBe('Structure Fire');
+    });
+
+    it('should fall back to the type text when no TypeId is sent (older servers)', () => {
+      expect(findCallType(callTypes, { Type: 'Medical' })?.Name).toBe('Medical');
+      expect(findCallType(callTypes, { Type: 'Medical', TypeId: null })?.Name).toBe('Medical');
+    });
+
+    it('should fall back to the type text when the TypeId matches none of the types', () => {
+      expect(findCallType(callTypes, { Type: 'Medical', TypeId: '99' })?.Name).toBe('Medical');
+    });
+
+    it('should return undefined when nothing matches', () => {
+      expect(findCallType(callTypes, { Type: 'Unknown Type' })).toBeUndefined();
+      expect(findCallType(null, { Type: 'Medical' })).toBeUndefined();
+      expect(findCallType(callTypes, null)).toBeUndefined();
+    });
+  });
+
   describe('getMissingCallFieldsFromError', () => {
     it('should read the keys from a plain-text rejection', () => {
       expect(getMissingCallFieldsFromError(badRequest('Required call fields are missing: contactName, externalId'))).toEqual([NewCallFieldKeys.ContactName, NewCallFieldKeys.ExternalId]);
diff --git a/src/lib/base-types.ts b/src/lib/base-types.ts
new file mode 100644
index 00000000..b6d5bc5a
--- /dev/null
+++ b/src/lib/base-types.ts
@@ -0,0 +1,207 @@
+/**
+ * Canonical meanings ("base types") of statuses, staffing levels, call priorities and call types.
+ *
+ * Departments name their statuses, staffing levels, priorities and call types however they like ("IN QUARTERS",
+ * "Pager Only", "Code 3", "Structure Fire"), so an app must never decide what something means from its name or a
+ * hard-coded id. The Resgrid API sends the meaning alongside every value, for built-in and department values alike:
+ *  - status options (Statuses/GetAllStatusesForPersonnel, GetAllUnitStatuses): `BaseType` (ActionBaseTypes);
+ *    staffing options (Statuses/GetAllStaffingsForPersonnel): `BaseType` (StaffingBaseTypes);
+ *    `StateId` on a status option is its custom set id: 0 for a built-in option.
+ *  - personnel infos: `StatusBaseType` (ActionBaseTypes), `StaffingBaseType` (StaffingBaseTypes);
+ *  - unit infos: `CurrentStatusBaseType` (ActionBaseTypes);
+ *  - call priorities: `BaseType` (CallPriorityBaseTypes) and `Sort`;
+ *  - call types: `BaseType` (CallTypeClasses); calls: `TypeId`.
+ * -1 means the department has not given the value a meaning; older servers send nothing (undefined).
+ *
+ * Mirrors Resgrid.Model.ActionBaseTypes / StaffingBaseTypes / CallPriority / CallTypeClasses and the availability
+ * rules of Resgrid.Model.Reporting.AvailabilityMatrix. Keep this file byte-identical across the Resgrid apps.
+ */
+
+export enum ActionBaseTypes {
+  None = -1,
+  Available = 0,
+  NotResponding = 1,
+  Responding = 2,
+  OnScene = 3,
+  MadeContact = 4,
+  Investigating = 5,
+  Dispatched = 6,
+  Cleared = 7,
+  Returning = 8,
+  Staging = 9,
+  Unavailable = 10,
+  Enroute = 11,
+  Transporting = 12,
+  Delivering = 13,
+  AtPatient = 14,
+  AtHospital = 15,
+  Searching = 16,
+  Loading = 17,
+  Standby = 18,
+  OnPatrol = 19,
+  Maintenance = 20,
+  OnBreak = 21,
+  Completed = 22,
+  InQuarters = 23,
+}
+
+export enum StaffingBaseTypes {
+  None = -1,
+  Available = 0,
+  Delayed = 1,
+  Unavailable = 2,
+  Committed = 3,
+  OnShift = 4,
+  OffDuty = 5,
+  OnCall = 6,
+}
+
+export enum CallPriorityBaseTypes {
+  None = -1,
+  Low = 0,
+  Medium = 1,
+  High = 2,
+  Emergency = 3,
+}
+
+export enum CallTypeClasses {
+  None = -1,
+  Fire = 1,
+  Medical = 2,
+  Rescue = 3,
+  TrafficCollision = 4,
+  HazardousMaterials = 5,
+  Alarm = 6,
+  ServiceCall = 7,
+  LawEnforcement = 8,
+  DisasterWeather = 9,
+  MutualAid = 10,
+  NonEmergencyActivity = 11,
+  Other = 12,
+}
+
+export type AvailabilityClass = 'available' | 'delayed' | 'committed' | 'unavailable' | 'unknown';
+
+const STATUS_AVAILABILITY: Record<number, AvailabilityClass> = {
+  [ActionBaseTypes.Available]: 'available',
+  [ActionBaseTypes.NotResponding]: 'unavailable',
+  [ActionBaseTypes.Responding]: 'committed',
+  [ActionBaseTypes.OnScene]: 'committed',
+  [ActionBaseTypes.MadeContact]: 'committed',
+  [ActionBaseTypes.Investigating]: 'committed',
+  [ActionBaseTypes.Dispatched]: 'committed',
+  [ActionBaseTypes.Cleared]: 'available',
+  [ActionBaseTypes.Returning]: 'committed',
+  [ActionBaseTypes.Staging]: 'committed',
+  [ActionBaseTypes.Unavailable]: 'unavailable',
+  [ActionBaseTypes.Enroute]: 'committed',
+  [ActionBaseTypes.Transporting]: 'committed',
+  [ActionBaseTypes.Delivering]: 'committed',
+  [ActionBaseTypes.AtPatient]: 'committed',
+  [ActionBaseTypes.AtHospital]: 'committed',
+  [ActionBaseTypes.Searching]: 'committed',
+  [ActionBaseTypes.Loading]: 'committed',
+  [ActionBaseTypes.Standby]: 'committed',
+  [ActionBaseTypes.OnPatrol]: 'available',
+  [ActionBaseTypes.Maintenance]: 'unavailable',
+  [ActionBaseTypes.OnBreak]: 'delayed',
+  [ActionBaseTypes.Completed]: 'available',
+  [ActionBaseTypes.InQuarters]: 'available',
+};
+
+const STAFFING_AVAILABILITY: Record<number, AvailabilityClass> = {
+  [StaffingBaseTypes.Available]: 'available',
+  [StaffingBaseTypes.Delayed]: 'delayed',
+  [StaffingBaseTypes.Unavailable]: 'unavailable',
+  [StaffingBaseTypes.Committed]: 'committed',
+  [StaffingBaseTypes.OnShift]: 'available',
+  [StaffingBaseTypes.OffDuty]: 'unavailable',
+  [StaffingBaseTypes.OnCall]: 'available',
+};
+
+const toNumber = (value: unknown): number | null => {
+  if (value === null || value === undefined || value === '') return null;
+  const n = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(n) ? n : null;
+};
+
+/** The availability a status base type means; 'unknown' when it is missing or None. */
+export const statusAvailability = (baseType: unknown): AvailabilityClass => {
+  const n = toNumber(baseType);
+  return n === null ? 'unknown' : (STATUS_AVAILABILITY[n] ?? 'unknown');
+};
+
+/** The availability a staffing base type means; 'unknown' when it is missing or None. */
+export const staffingAvailability = (baseType: unknown): AvailabilityClass => {
+  const n = toNumber(baseType);
+  return n === null ? 'unknown' : (STAFFING_AVAILABILITY[n] ?? 'unknown');
+};
+
+/** True when the base type was sent and means something (not None). */
+export const hasBaseType = (baseType: unknown): boolean => {
+  const n = toNumber(baseType);
+  return n !== null && n >= 0;
+};
+
+/** Available or delayed: the resource can take another assignment (dispatch's rule). */
+export const isStatusAvailable = (baseType: unknown): boolean => {
+  const availability = statusAvailability(baseType);
+  return availability === 'available' || availability === 'delayed';
+};
+
+/** Responding to an assignment (dispatched, responding, en route). */
+export const isStatusResponding = (baseType: unknown): boolean => {
+  const n = toNumber(baseType);
+  return n === ActionBaseTypes.Dispatched || n === ActionBaseTypes.Responding || n === ActionBaseTypes.Enroute;
+};
+
+/** Working at the scene or with the patient/subject. */
+export const isStatusOnScene = (baseType: unknown): boolean => {
+  const n = toNumber(baseType);
+  return n === ActionBaseTypes.OnScene || n === ActionBaseTypes.MadeContact || n === ActionBaseTypes.Investigating || n === ActionBaseTypes.AtPatient || n === ActionBaseTypes.Searching || n === ActionBaseTypes.Staging;
+};
+
+/** On duty for staffing purposes: available, on shift, on call or delayed (not off duty or unavailable). */
+export const isStaffingOnDuty = (baseType: unknown): boolean => {
+  const availability = staffingAvailability(baseType);
+  return availability === 'available' || availability === 'delayed' || availability === 'committed';
+};
+
+/** The fields the personnel in service count reads (PersonnelInfoResultData). */
+export interface PersonnelInServiceFields {
+  Status?: string | null;
+  StatusBaseType?: number | null;
+  StaffingBaseType?: number | null;
+}
+
+/**
+ * Personnel in service, the one definition every app counts: working an assignment right now -- a committed status
+ * (dispatched, responding, en route, on scene, returning ...) -- and not off duty or unavailable by staffing. Available,
+ * delayed, unavailable and unknown statuses do not count. A status without a meaning (older servers, or an option the
+ * department has not given one) falls back to the rule the apps used before: a status other than Available or Off Duty.
+ */
+export const isPersonnelInService = (person: PersonnelInServiceFields | null | undefined): boolean => {
+  if (!person || staffingAvailability(person.StaffingBaseType) === 'unavailable') return false;
+  if (hasBaseType(person.StatusBaseType)) return statusAvailability(person.StatusBaseType) === 'committed';
+  return !!person.Status && person.Status !== 'Available' && person.Status !== 'Off Duty';
+};
+
+/**
+ * Orders call priorities from most to least urgent: by meaning (Emergency first), then the department's own sort order,
+ * then id. Use it instead of sorting on the raw priority id, which mixes built-in values (0-3) with department ids.
+ */
+export const comparePriorityUrgency = (
+  a: { BaseType?: number | null; Sort?: number | null; Id?: number | string | null } | null | undefined,
+  b: { BaseType?: number | null; Sort?: number | null; Id?: number | string | null } | null | undefined
+): number => {
+  const baseA = toNumber(a?.BaseType) ?? -1;
+  const baseB = toNumber(b?.BaseType) ?? -1;
+  if (baseA !== baseB) return baseB - baseA;
+  const sortA = toNumber(a?.Sort) ?? 0;
+  const sortB = toNumber(b?.Sort) ?? 0;
+  if (sortA !== sortB) return sortA - sortB;
+  return (toNumber(a?.Id) ?? 0) - (toNumber(b?.Id) ?? 0);
+};
+
+/** True when the priority means Emergency. */
+export const isEmergencyPriority = (baseType: unknown): boolean => toNumber(baseType) === CallPriorityBaseTypes.Emergency;
diff --git a/src/lib/call-field-policy.ts b/src/lib/call-field-policy.ts
index d01ed237..0c5d2f42 100644
--- a/src/lib/call-field-policy.ts
+++ b/src/lib/call-field-policy.ts
@@ -138,6 +138,24 @@ export const isPendingCallState = (state: number | string | null | undefined): b
   return normalized === String(CALL_STATE_PENDING) || normalized === 'pending';
 };
 
+/**
+ * The department call type a call was logged with: by `TypeId`, which survives a rename of the type, then by the
+ * type text (`Type` is the type's name, not its id; older servers send no `TypeId`).
+ */
+export const findCallType = <T extends { Id: number | string; Name: string }>(
+  callTypes: readonly T[] | null | undefined,
+  call: { Type?: string | null; TypeId?: number | string | null } | null | undefined
+): T | undefined => {
+  if (!callTypes || !call) {
+    return undefined;
+  }
+
+  const typeId = call.TypeId == null ? '' : String(call.TypeId).trim();
+  const byId = typeId !== '' ? callTypes.find((candidate) => String(candidate.Id) === typeId) : undefined;
+
+  return byId ?? callTypes.find((candidate) => candidate.Name === call.Type);
+};
+
 const REQUIRED_FIELDS_MESSAGE = /required call fields are missing:\s*(.+)$/i;
 
 const readErrorText = (error: unknown): string | null => {
diff --git a/src/models/v4/callPriorities/callPriorityResultData.ts b/src/models/v4/callPriorities/callPriorityResultData.ts
index a0a1d00a..2d74cc33 100644
--- a/src/models/v4/callPriorities/callPriorityResultData.ts
+++ b/src/models/v4/callPriorities/callPriorityResultData.ts
@@ -7,4 +7,6 @@ export class CallPriorityResultData {
   public IsDeleted: boolean = false;
   public IsDefault: boolean = false;
   public Tone: number = 0;
+  /** The standard priority this one means (CallPriorityBaseTypes: 0 Low .. 3 Emergency); -1 none, undefined from older servers. */
+  public BaseType?: number;
 }
diff --git a/src/models/v4/callTypes/callTypeResultData.ts b/src/models/v4/callTypes/callTypeResultData.ts
index 38f200c8..47395119 100644
--- a/src/models/v4/callTypes/callTypeResultData.ts
+++ b/src/models/v4/callTypes/callTypeResultData.ts
@@ -1,4 +1,6 @@
 export class CallTypeResultData {
   public Id: string = '';
   public Name: string = '';
+  /** What kind of call the type is (CallTypeClasses); -1 none, undefined from older servers. */
+  public BaseType?: number;
 }
diff --git a/src/models/v4/calls/callResultData.ts b/src/models/v4/calls/callResultData.ts
index 5e51d51f..a779dab9 100644
--- a/src/models/v4/calls/callResultData.ts
+++ b/src/models/v4/calls/callResultData.ts
@@ -30,6 +30,8 @@ export class CallResultData {
   public IncidentId: string = '';
   public AudioFileId: string = '';
   public Type: string = 'No Type';
+  /** Id of the department call type the call was logged with (survives a rename); null/undefined when none or older servers. */
+  public TypeId?: string | null;
   public LoggedOnUtc: string = '';
   public DispatchedOn: string = '';
   public DispatchedOnUtc: string = '';
diff --git a/src/models/v4/configs/getTerminologyResult.ts b/src/models/v4/configs/getTerminologyResult.ts
new file mode 100644
index 00000000..64fa363a
--- /dev/null
+++ b/src/models/v4/configs/getTerminologyResult.ts
@@ -0,0 +1,17 @@
+import { BaseV4Request } from '../baseV4Request';
+
+/** One term a department can rename (Department -> Terminology on the website). */
+export interface DepartmentTermData {
+  /** Stable key, e.g. "module.records" or "record-type.run". Never changes. */
+  Key: string;
+  /** "Module" or "RecordType". */
+  Category: string;
+  /** Resgrid's English name for the term. */
+  DefaultName: string;
+  /** The department's own name; null when it uses Resgrid's. */
+  Name: string | null;
+}
+
+export class GetTerminologyResult extends BaseV4Request {
+  public Data: DepartmentTermData[] = [];
+}
diff --git a/src/models/v4/device/nativePushUnRegistrationInput.ts b/src/models/v4/device/nativePushUnRegistrationInput.ts
new file mode 100644
index 00000000..2b2759b7
--- /dev/null
+++ b/src/models/v4/device/nativePushUnRegistrationInput.ts
@@ -0,0 +1,5 @@
+/** Takes a native (iOS or Android) push token off the channels it was registered on (Core v4 Devices/UnRegisterNativePush). */
+export class NativePushUnRegistrationInput {
+  public Token: string = '';
+  public Prefix: string = '';
+}
diff --git a/src/models/v4/personnel/personnelInfoResultData.ts b/src/models/v4/personnel/personnelInfoResultData.ts
index 5d6f0a00..636172f8 100644
--- a/src/models/v4/personnel/personnelInfoResultData.ts
+++ b/src/models/v4/personnel/personnelInfoResultData.ts
@@ -12,11 +12,17 @@ export class PersonnelInfoResultData {
   public Status: string = '';
   public StatusColor: string = '';
   public StatusTimestamp: string = '';
+  /** What the current status means (ActionBaseTypes); -1 none, undefined from older servers. See lib/base-types. */
+  public StatusBaseType?: number;
   public StatusDestinationId: string = '';
   public StatusDestinationName: string = '';
+  /** What StatusDestinationId names (DestinationEntityTypes: 1 station, 2 call, 3 POI), when the status recorded it. */
+  public StatusDestinationType?: number | null;
   public StaffingId: string = '';
   public Staffing: string = '';
   public StaffingColor: string = '';
   public StaffingTimestamp: string = '';
+  /** What the current staffing level means (StaffingBaseTypes); -1 none, undefined from older servers. */
+  public StaffingBaseType?: number;
   public Roles: string[] = [];
 }
diff --git a/src/models/v4/security/departmentRightsResultData.ts b/src/models/v4/security/departmentRightsResultData.ts
index 00fdc89f..2a603eba 100644
--- a/src/models/v4/security/departmentRightsResultData.ts
+++ b/src/models/v4/security/departmentRightsResultData.ts
@@ -1,6 +1,14 @@
 export class DepartmentRightsResultData {
   public DepartmentName: string = '';
   public DepartmentCode: string = '';
+  /**
+   * Novu subscriberHash for this user's own inbox ({DepartmentCode}_User_{userId}, Responder and Dispatch).
+   * Passed to NovuProvider with the subscriber id; required once the Novu environment enforces HMAC.
+   * Null when the server has no Novu configured or predates the field.
+   */
+  public NovuSubscriberHash?: string | null = null;
+  /** Novu subscriberHash for this user's IC app inbox ({DepartmentCode}_IC_User_{userId}). */
+  public NovuICSubscriberHash?: string | null = null;
   public FullName: string = '';
   public EmailAddress: string = '';
   public DepartmentId: string = '';
diff --git a/src/models/v4/statuses/statusesResultData.ts b/src/models/v4/statuses/statusesResultData.ts
index dbc78237..8fd3b570 100644
--- a/src/models/v4/statuses/statusesResultData.ts
+++ b/src/models/v4/statuses/statusesResultData.ts
@@ -1,9 +1,11 @@
 export class StatusesResultData {
   public Id: number = 0; // Id of the Set
   public Type: number = 0; // Type of the Set
-  public StateId: number = 0; // State Id
+  public StateId: number = 0; // Custom state (set) id: 0 for a built-in option, > 0 for a department's own option
   public Text: string = ''; // Button Text
   public BColor: string = ''; // Button Color
+  /** What the option means: ActionBaseTypes for statuses, StaffingBaseTypes for staffing; -1 none, undefined from older servers. */
+  public BaseType?: number;
   public Color: string = ''; // Text Color
   public Gps: boolean = false; // Require GPS
   public Note: number = 0; // Note Type
diff --git a/src/models/v4/units/unitInfoResultData.ts b/src/models/v4/units/unitInfoResultData.ts
index 57fc6fe0..3f405615 100644
--- a/src/models/v4/units/unitInfoResultData.ts
+++ b/src/models/v4/units/unitInfoResultData.ts
@@ -18,6 +18,8 @@ export class UnitInfoResultData {
   public CurrentStatusId: string = '';
   public CurrentStatus: string = '';
   public CurrentStatusColor: string = '';
+  /** What the unit's current status means (ActionBaseTypes); null/-1 none, undefined from older servers. */
+  public CurrentStatusBaseType?: number | null;
   public CurrentStatusTimestampUtc: string = '';
   public Latitude: string = '';
   public Longitude: string = '';
diff --git a/src/services/__tests__/push-notification-sign-out.test.ts b/src/services/__tests__/push-notification-sign-out.test.ts
new file mode 100644
index 00000000..e1694daa
--- /dev/null
+++ b/src/services/__tests__/push-notification-sign-out.test.ts
@@ -0,0 +1,137 @@
+import * as Notifications from 'expo-notifications';
+
+import { registerDevice } from '@/api/devices/push';
+import { runSignOutHooks } from '@/lib/auth/sign-out-hooks';
+import { logger } from '@/lib/logging';
+
+jest.mock('expo-device', () => ({ isDevice: true }));
+
+jest.mock('expo-notifications', () => ({
+  addNotificationReceivedListener: jest.fn(() => ({ remove: jest.fn() })),
+  addNotificationResponseReceivedListener: jest.fn(() => ({ remove: jest.fn() })),
+  setNotificationHandler: jest.fn(),
+  setNotificationChannelAsync: jest.fn(),
+  deleteNotificationChannelAsync: jest.fn(),
+  getPermissionsAsync: jest.fn(() => Promise.resolve({ status: 'granted' })),
+  requestPermissionsAsync: jest.fn(() => Promise.resolve({ status: 'granted' })),
+  getDevicePushTokenAsync: jest.fn(() => Promise.resolve({ data: 'native-token' })),
+  getLastNotificationResponseAsync: jest.fn(() => Promise.resolve(null)),
+}));
+
+jest.mock('@/lib/auth', () => {
+  const state = { status: 'signedIn', userId: 'user-1' };
+  const store: any = jest.fn((selector: any) => (selector ? selector(state) : state));
+  store.getState = () => state;
+  return { useAuthStore: store };
+});
+
+jest.mock('@/stores/push-notification/store', () => ({
+  ...jest.requireActual('@/stores/push-notification/store'),
+  usePushNotificationModalStore: { getState: jest.fn(() => ({ showNotificationModal: jest.fn() })) },
+}));
+
+jest.mock('@/components/weather-alerts/weather-alert-navigation', () => ({ openWeatherAlertDetail: jest.fn() }));
+
+jest.mock('@/lib/navigation', () => ({
+  routerPushWithRetry: jest.fn(() => Promise.resolve()),
+  registerNavigationReadyCheck: jest.fn(),
+  isNavigationReady: jest.fn(() => true),
+}));
+
+jest.mock('@/lib/logging', () => ({ logger: { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() } }));
+
+jest.mock('@/lib/mfa/client-app', () => ({ CLIENT_HEADER: 'X-Resgrid-Client', RESGRID_CLIENT: 'responder' }));
+
+jest.mock('@/lib/storage/app', () => ({
+  getDeviceUuid: jest.fn(() => 'device-uuid'),
+  getBaseApiUrl: jest.fn(() => 'https://api.example/api/v4'),
+}));
+
+jest.mock('@/api/devices/push', () => ({
+  registerDevice: jest.fn(() => Promise.resolve({ Status: 'queued' })),
+  registerUnitDevice: jest.fn(),
+}));
+
+jest.mock('@/stores/security/store', () => ({ securityStore: { getState: jest.fn(() => ({})) } }));
+
+describe('push notification sign-out', () => {
+  const originalFetch = global.fetch;
+  let fetchMock: jest.Mock;
+  let pushNotificationService: { registerForPushNotifications: (userId: string, code: string) => Promise<string | null> };
+
+  beforeAll(() => {
+    ({ pushNotificationService } = require('../push-notification'));
+  });
+
+  beforeEach(async () => {
+    fetchMock = jest.fn(() => Promise.resolve({ ok: true, status: 200 }));
+    global.fetch = fetchMock as unknown as typeof fetch;
+    // Start every test from a clean slate: nothing registered.
+    await runSignOutHooks(null);
+    fetchMock.mockClear();
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    global.fetch = originalFetch;
+  });
+
+  it('takes the registered token off the server as the signing-out session', async () => {
+    await pushNotificationService.registerForPushNotifications('user-1', 'DEPT');
+    expect(registerDevice).toHaveBeenCalledWith(expect.objectContaining({ Token: 'native-token', Prefix: 'DEPT' }));
+
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('https://api.example/api/v4/Devices/UnRegisterNativePush');
+    expect(init.method).toBe('POST');
+    expect(init.headers).toEqual(expect.objectContaining({ Authorization: 'Bearer access-token', 'X-Resgrid-Client': 'responder' }));
+    expect(JSON.parse(init.body)).toEqual({ Token: 'native-token', Prefix: 'DEPT' });
+  });
+
+  it('does not call the server when the phone never registered', async () => {
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('unregisters only once per registration', async () => {
+    await pushNotificationService.registerForPushNotifications('user-1', 'DEPT');
+
+    await runSignOutHooks('access-token');
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not call the server without an access token', async () => {
+    await pushNotificationService.registerForPushNotifications('user-1', 'DEPT');
+
+    await runSignOutHooks(null);
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('lets sign-out carry on when the server refuses or is unreachable', async () => {
+    await pushNotificationService.registerForPushNotifications('user-1', 'DEPT');
+    fetchMock.mockImplementationOnce(() => Promise.resolve({ ok: false, status: 400 }));
+    await expect(runSignOutHooks('access-token')).resolves.toBeUndefined();
+
+    await pushNotificationService.registerForPushNotifications('user-1', 'DEPT');
+    fetchMock.mockImplementationOnce(() => Promise.reject(new Error('offline')));
+    await expect(runSignOutHooks('access-token')).resolves.toBeUndefined();
+
+    expect(logger.warn).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not register a token when permission is refused, so there is nothing to unregister', async () => {
+    (Notifications.getPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'denied' });
+    (Notifications.requestPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'denied' });
+
+    await pushNotificationService.registerForPushNotifications('user-1', 'DEPT');
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/services/push-notification.ts b/src/services/push-notification.ts
index d4a0b518..3a220042 100644
--- a/src/services/push-notification.ts
+++ b/src/services/push-notification.ts
@@ -7,9 +7,12 @@ import { Platform } from 'react-native';
 import { registerDevice, registerUnitDevice } from '@/api/devices/push';
 import { openWeatherAlertDetail } from '@/components/weather-alerts/weather-alert-navigation';
 import { useAuthStore } from '@/lib/auth';
+import { registerSignOutHook } from '@/lib/auth/sign-out-hooks';
 import { logger } from '@/lib/logging';
+import { CLIENT_HEADER, RESGRID_CLIENT } from '@/lib/mfa/client-app';
 import { type RouterPushRetryOptions, routerPushWithRetry } from '@/lib/navigation';
-import { getDeviceUuid } from '@/lib/storage/app';
+import { getBaseApiUrl, getDeviceUuid } from '@/lib/storage/app';
+import { type NativePushUnRegistrationInput } from '@/models/v4/device/nativePushUnRegistrationInput';
 import { isSafeRouteId, parseNotificationData, usePushNotificationModalStore } from '@/stores/push-notification/store';
 import { securityStore } from '@/stores/security/store';
 
@@ -135,6 +138,8 @@ const NOTIFICATION_CHANNELS: NotificationChannelConfig[] = [
 class PushNotificationService {
   private static instance: PushNotificationService;
   private pushToken: string | null = null;
+  // What this phone last registered on the server, so sign-out can take exactly that token off again.
+  private registration: NativePushUnRegistrationInput | null = null;
   private notificationListener: { remove: () => void } | null = null;
   private responseListener: { remove: () => void } | null = null;
   // Identifier of the last notification response we surfaced, used to avoid presenting the launch
@@ -446,6 +451,8 @@ class PushNotificationService {
         Prefix: departmentCode,
       });
 
+      this.registration = { Token: this.pushToken, Prefix: departmentCode };
+
       return this.pushToken;
     } catch (error) {
       logger.error({
@@ -460,6 +467,33 @@ class PushNotificationService {
     return this.pushToken;
   }
 
+  /**
+   * Takes this phone's token off the server at sign-out, as the session that is signing out (the hook below runs
+   * before logout clears its access token). Straight to the server, not through the api client: its 401 handling
+   * would re-enter logout. Quiet: sign-out goes ahead whatever the server says.
+   */
+  public async unregisterAtSignOut(accessToken: string | null): Promise<void> {
+    const registration = this.registration;
+    this.registration = null;
+
+    if (!registration || !accessToken) {
+      return;
+    }
+
+    try {
+      const response = await fetch(`${getBaseApiUrl()}/Devices/UnRegisterNativePush`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}`, [CLIENT_HEADER]: RESGRID_CLIENT },
+        body: JSON.stringify(registration),
+      });
+      if (!response.ok) {
+        logger.warn({ message: 'Push: the server refused to unregister the device token at sign-out', context: { status: response.status } });
+      }
+    } catch (error) {
+      logger.warn({ message: 'Push: the device token could not be unregistered at sign-out', context: { ...PushNotificationService.toErrorContext(error) } });
+    }
+  }
+
   public async sendTestNotification(): Promise<void> {
     if (!this.pushToken) {
       logger.warn({
@@ -505,6 +539,10 @@ class PushNotificationService {
 
 export const pushNotificationService = PushNotificationService.getInstance();
 
+// Sign-out takes this phone's token off the server while the session can still authenticate, so the next person to
+// use the device never gets the previous one's calls.
+registerSignOutHook((accessToken) => pushNotificationService.unregisterAtSignOut(accessToken));
+
 // React hook for component usage
 export const usePushNotifications = () => {
   const userId = useAuthStore((state) => state.userId);
diff --git a/src/stores/home/__tests__/home-store.test.ts b/src/stores/home/__tests__/home-store.test.ts
new file mode 100644
index 00000000..2bf33396
--- /dev/null
+++ b/src/stores/home/__tests__/home-store.test.ts
@@ -0,0 +1,80 @@
+import { ActionBaseTypes, StaffingBaseTypes } from '@/lib/base-types';
+import { PersonnelInfoResultData } from '@/models/v4/personnel/personnelInfoResultData';
+
+import { useCallsStore } from '../../calls/store';
+import { useRolesStore } from '../../roles/store';
+import { useUnitsStore } from '../../units/store';
+import { isPersonnelInService, useHomeStore } from '../home-store';
+
+jest.mock('@/api/personnel/personnel');
+jest.mock('@/api/personnel/personnelStaffing');
+jest.mock('@/api/personnel/personnelStatuses');
+jest.mock('@/api/satuses');
+jest.mock('../../auth/store', () => ({ __esModule: true, default: { getState: () => ({ userId: 'user-1' }) } }));
+jest.mock('../../calls/store', () => ({ useCallsStore: { getState: jest.fn() } }));
+jest.mock('../../roles/store', () => ({ useRolesStore: { getState: jest.fn() } }));
+jest.mock('../../units/store', () => ({ useUnitsStore: { getState: jest.fn() } }));
+
+const person = (overrides: Partial<PersonnelInfoResultData>): PersonnelInfoResultData => Object.assign(new PersonnelInfoResultData(), overrides);
+
+describe('isPersonnelInService', () => {
+  describe('with base types (current servers)', () => {
+    it('counts a member whose status means committed, whatever the department calls it', () => {
+      expect(isPersonnelInService(person({ Status: 'Code 3', StatusBaseType: ActionBaseTypes.Responding, StaffingBaseType: StaffingBaseTypes.OnShift }))).toBe(true);
+      expect(isPersonnelInService(person({ Status: 'At Pt', StatusBaseType: ActionBaseTypes.AtPatient }))).toBe(true);
+    });
+
+    it('does not count a member whose status means available, even when it is not named "Available"', () => {
+      expect(isPersonnelInService(person({ Status: 'IN QUARTERS', StatusBaseType: ActionBaseTypes.InQuarters }))).toBe(false);
+      expect(isPersonnelInService(person({ Status: 'Standing By', StatusBaseType: ActionBaseTypes.Available }))).toBe(false);
+    });
+
+    it('does not count a member whose status means out of service', () => {
+      expect(isPersonnelInService(person({ Status: 'Not Coming', StatusBaseType: ActionBaseTypes.NotResponding }))).toBe(false);
+    });
+
+    it('decides by the status meaning, not the text, when a department names a status "Available"', () => {
+      expect(isPersonnelInService(person({ Status: 'Available', StatusBaseType: ActionBaseTypes.Staging }))).toBe(true);
+    });
+
+    it('does not count a member whose staffing level means off duty or unavailable', () => {
+      expect(isPersonnelInService(person({ Status: 'Responding', StatusBaseType: ActionBaseTypes.Responding, Staffing: 'Home', StaffingBaseType: StaffingBaseTypes.OffDuty }))).toBe(false);
+      expect(isPersonnelInService(person({ Status: 'Responding', StatusBaseType: ActionBaseTypes.Responding, StaffingBaseType: StaffingBaseTypes.Unavailable }))).toBe(false);
+    });
+  });
+
+  describe('without base types (older servers, statuses with no meaning)', () => {
+    it('keeps the legacy name match', () => {
+      expect(isPersonnelInService(person({ Status: 'Responding' }))).toBe(true);
+      expect(isPersonnelInService(person({ Status: 'Available' }))).toBe(false);
+      expect(isPersonnelInService(person({ Status: 'Off Duty' }))).toBe(false);
+      expect(isPersonnelInService(person({ Status: '' }))).toBe(false);
+    });
+
+    it('treats -1 (no meaning) like a missing base type', () => {
+      expect(isPersonnelInService(person({ Status: 'Available', StatusBaseType: ActionBaseTypes.None, StaffingBaseType: StaffingBaseTypes.None }))).toBe(false);
+      expect(isPersonnelInService(person({ Status: 'Custom Thing', StatusBaseType: ActionBaseTypes.None, StaffingBaseType: StaffingBaseTypes.None }))).toBe(true);
+    });
+  });
+});
+
+describe('useHomeStore.fetchDepartmentStats', () => {
+  beforeEach(() => {
+    (useCallsStore.getState as unknown as jest.Mock).mockReturnValue({ calls: [{ State: 'Active' }, { State: 'Closed' }] });
+    (useUnitsStore.getState as unknown as jest.Mock).mockReturnValue({ units: [{ Name: 'Engine 1' }] });
+    (useRolesStore.getState as unknown as jest.Mock).mockReturnValue({
+      users: [
+        person({ Status: 'Enroute', StatusBaseType: ActionBaseTypes.Enroute, StaffingBaseType: StaffingBaseTypes.OnCall }),
+        person({ Status: 'IN QUARTERS', StatusBaseType: ActionBaseTypes.InQuarters, StaffingBaseType: StaffingBaseTypes.OnShift }),
+        person({ Status: 'On Scene' }),
+        person({ Status: 'Available' }),
+      ],
+    });
+  });
+
+  it('counts personnel in service from status and staffing meanings, with the legacy fallback', async () => {
+    await useHomeStore.getState().fetchDepartmentStats();
+
+    expect(useHomeStore.getState().departmentStats).toEqual({ openCalls: 1, personnelInService: 2, unitsInService: 1 });
+  });
+});
diff --git a/src/stores/home/home-store.ts b/src/stores/home/home-store.ts
index 7e6a6232..dbb6724f 100644
--- a/src/stores/home/home-store.ts
+++ b/src/stores/home/home-store.ts
@@ -4,6 +4,7 @@ import { getPersonnelInfo } from '@/api/personnel/personnel';
 import { getCurrentPersonnelStaffing } from '@/api/personnel/personnelStaffing';
 import { getCurrentPersonnelStatus } from '@/api/personnel/personnelStatuses';
 import { getAllPersonnelStatuses } from '@/api/satuses';
+import { isPersonnelInService } from '@/lib/base-types';
 import { type PersonnelInfoResultData } from '@/models/v4/personnel/personnelInfoResultData';
 import { type GetCurrentStaffingResultData } from '@/models/v4/personnelStaffing/getCurrentStaffingResultData';
 import { type GetCurrentStatusResultData } from '@/models/v4/personnelStatuses/getCurrentStatusResultData';
@@ -15,6 +16,9 @@ import { useCallsStore } from '../calls/store';
 import { useRolesStore } from '../roles/store';
 import { useUnitsStore } from '../units/store';
 
+/** "Personnel in service" on the Home stats: the one definition every app shares (lib/base-types). */
+export { isPersonnelInService };
+
 export interface DepartmentStats {
   openCalls: number;
   personnelInService: number;
@@ -73,7 +77,7 @@ export const useHomeStore = create<HomeState>((set, get) => ({
 
       // Get personnel in service count
       const users = useRolesStore.getState().users;
-      const personnelInService = users.filter((user) => user.Status && user.Status !== 'Available' && user.Status !== 'Off Duty').length;
+      const personnelInService = users.filter(isPersonnelInService).length;
 
       // Get units in service count
       const units = useUnitsStore.getState().units;
diff --git a/src/stores/terminology/__tests__/store.test.ts b/src/stores/terminology/__tests__/store.test.ts
new file mode 100644
index 00000000..b4488f3e
--- /dev/null
+++ b/src/stores/terminology/__tests__/store.test.ts
@@ -0,0 +1,116 @@
+import { renderHook } from '@testing-library/react-native';
+
+import { definitionTermKey, getTerm, recordTypeTermKey, terminologyStore, TermKeys, useDefinitionTerm, useRecordTypeTerm, useTerm } from '../store';
+
+jest.mock('@/api/config/terminology', () => ({
+  getTerminology: jest.fn(),
+}));
+
+jest.mock('@/lib/logging', () => ({
+  logger: {
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+jest.mock('../../../lib/storage', () => ({
+  zustandStorage: {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+  },
+}));
+
+jest.mock('../../auth/store', () => ({
+  __esModule: true,
+  default: {
+    getState: jest.fn(),
+  },
+}));
+
+jest.mock('../../security/store', () => ({
+  securityStore: {
+    getState: jest.fn(),
+  },
+}));
+
+const { getTerminology } = require('@/api/config/terminology');
+const useAuthStore = require('../../auth/store').default;
+const { securityStore } = require('../../security/store');
+
+const setIdentity = (userId: string | null, departmentId: string | null) => {
+  useAuthStore.getState.mockReturnValue({ userId });
+  securityStore.getState.mockReturnValue({
+    rights: departmentId ? { DepartmentId: departmentId } : null,
+  });
+};
+
+describe('Terminology store', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    terminologyStore.setState({ names: {}, isLoaded: false, error: null, identityKey: null });
+    setIdentity('user-1', 'dept-1');
+  });
+
+  it('keeps only the terms the department renamed', async () => {
+    getTerminology.mockResolvedValue({
+      Data: [
+        { Key: 'record-type.run', Category: 'RecordType', DefaultName: 'Run', Name: 'Incident' },
+        { Key: TermKeys.Units, Category: 'Module', DefaultName: 'Units', Name: ' Apparatus ' },
+        { Key: TermKeys.Calls, Category: 'Module', DefaultName: 'Calls', Name: null },
+        { Key: TermKeys.Notes, Category: 'Module', DefaultName: 'Notes', Name: '   ' },
+      ],
+    });
+
+    await terminologyStore.getState().fetchTerminology();
+
+    const state = terminologyStore.getState();
+    expect(state.names).toEqual({ 'record-type.run': 'Incident', [TermKeys.Units]: 'Apparatus' });
+    expect(state.isLoaded).toBe(true);
+    expect(state.identityKey).toBe('user-1:dept-1');
+  });
+
+  it('keeps the persisted names when the server cannot be reached', async () => {
+    terminologyStore.setState({ names: { [TermKeys.Records]: 'Reports' }, identityKey: 'user-1:dept-1' });
+    getTerminology.mockRejectedValue(new Error('offline'));
+
+    await terminologyStore.getState().fetchTerminology();
+
+    expect(terminologyStore.getState().names).toEqual({ [TermKeys.Records]: 'Reports' });
+    expect(terminologyStore.getState().error).toBe('offline');
+  });
+
+  it("drops another department's names before fetching", async () => {
+    terminologyStore.setState({ names: { [TermKeys.Records]: 'Reports' }, identityKey: 'user-1:dept-9' });
+    getTerminology.mockRejectedValue(new Error('offline'));
+
+    await terminologyStore.getState().fetchTerminology();
+
+    expect(terminologyStore.getState().names).toEqual({});
+  });
+
+  it('maps record type numbers and built-in definition keys to term keys', () => {
+    expect(recordTypeTermKey(1)).toBe('record-type.run');
+    expect(recordTypeTermKey(8)).toBe('record-type.unit-activity');
+    expect(recordTypeTermKey(3)).toBeNull();
+    expect(recordTypeTermKey(null)).toBeNull();
+    expect(definitionTermKey('system.work')).toBe('record-type.work');
+    expect(definitionTermKey('system.neris-incident')).toBe('record-type.neris-incident');
+    expect(definitionTermKey('dept.public-education')).toBeNull();
+    expect(definitionTermKey(undefined)).toBeNull();
+  });
+
+  it('falls back to the app name for anything not renamed', () => {
+    terminologyStore.setState({ names: { 'record-type.work': 'Shift On Duty', [TermKeys.Contacts]: 'Preplans' } });
+
+    expect(renderHook(() => useTerm(TermKeys.Contacts, 'Contacts')).result.current).toBe('Preplans');
+    expect(renderHook(() => useTerm(TermKeys.Calls, 'Calls')).result.current).toBe('Calls');
+    expect(renderHook(() => useRecordTypeTerm(4, 'Work')).result.current).toBe('Shift On Duty');
+    expect(renderHook(() => useDefinitionTerm('system.work', 'Work')).result.current).toBe('Shift On Duty');
+    expect(renderHook(() => useDefinitionTerm('dept.public-education', 'Public Education')).result.current).toBe('Public Education');
+    expect(getTerm(TermKeys.Contacts, 'Contacts')).toBe('Preplans');
+    expect(getTerm(null, 'Contacts')).toBe('Contacts');
+  });
+});
diff --git a/src/stores/terminology/store.ts b/src/stores/terminology/store.ts
new file mode 100644
index 00000000..298fbd91
--- /dev/null
+++ b/src/stores/terminology/store.ts
@@ -0,0 +1,140 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+import { getTerminology } from '@/api/config/terminology';
+import { logger } from '@/lib/logging';
+
+import { zustandStorage } from '../../lib/storage';
+import useAuthStore from '../auth/store';
+import { securityStore } from '../security/store';
+
+// Term keys the department can rename (Department -> Terminology). Keep in sync with Resgrid.Model.DepartmentTerms.
+export const TermKeys = {
+  Calls: 'module.calls',
+  Personnel: 'module.personnel',
+  Units: 'module.units',
+  Contacts: 'module.contacts',
+  Mapping: 'module.mapping',
+  Shifts: 'module.shifts',
+  Records: 'module.records',
+  Logs: 'module.logs',
+  Reports: 'module.reports',
+  Documents: 'module.documents',
+  Calendar: 'module.calendar',
+  Notes: 'module.notes',
+  Trainings: 'module.trainings',
+  Inventory: 'module.inventory',
+  Readiness: 'module.readiness',
+  WorkOrders: 'module.work-orders',
+  Checklists: 'module.checklists',
+  WorkforceBusiness: 'module.workforce-business',
+} as const;
+
+const RECORD_TYPE_PREFIX = 'record-type.';
+const SYSTEM_DEFINITION_PREFIX = 'system.';
+
+// RmsOperationalRecordType / LogTypes numbers -> the locked definition key they belong to.
+const RECORD_TYPE_DEFINITIONS: Record<number, string> = {
+  1: 'system.run',
+  2: 'system.training',
+  4: 'system.work',
+  5: 'system.meeting',
+  6: 'system.coroner',
+  7: 'system.callback',
+  8: 'system.unit-activity',
+};
+
+/** The term key for a built-in definition ("system.run" -> "record-type.run"); null for a department definition. */
+export const definitionTermKey = (definitionKey?: string | null): string | null =>
+  definitionKey && definitionKey.startsWith(SYSTEM_DEFINITION_PREFIX) ? RECORD_TYPE_PREFIX + definitionKey.substring(SYSTEM_DEFINITION_PREFIX.length) : null;
+
+/** The term key for a record (or legacy log) type number; null when the number is not a built-in type. */
+export const recordTypeTermKey = (recordType?: number | null): string | null => (recordType != null && RECORD_TYPE_DEFINITIONS[recordType] ? definitionTermKey(RECORD_TYPE_DEFINITIONS[recordType]) : null);
+
+// Immutable ids only (user id + department id): names belong to one department.
+const getCurrentIdentityKey = (): string | null => {
+  const userId = useAuthStore.getState().userId;
+  const departmentId = securityStore.getState().rights?.DepartmentId;
+  if (!userId || !departmentId) {
+    return null;
+  }
+  return `${userId}:${departmentId}`;
+};
+
+// True only when the persisted names provably belong to a different account/department.
+const isPersistedIdentityStale = (persistedKey: string | null): boolean => {
+  if (!persistedKey) {
+    return false;
+  }
+  const userId = useAuthStore.getState().userId;
+  const departmentId = securityStore.getState().rights?.DepartmentId;
+  if (userId && departmentId) {
+    return persistedKey !== `${userId}:${departmentId}`;
+  }
+  if (userId) {
+    return !persistedKey.startsWith(`${userId}:`);
+  }
+  return false;
+};
+
+export interface TerminologyState {
+  /** Term key -> the department's own name. Only renamed terms are present. */
+  names: Record<string, string>;
+  isLoaded: boolean;
+  error: string | null;
+  identityKey: string | null;
+  fetchTerminology: () => Promise<void>;
+}
+
+export const terminologyStore = create<TerminologyState>()(
+  persist(
+    (set, get) => ({
+      names: {},
+      isLoaded: false,
+      error: null,
+      identityKey: null,
+      fetchTerminology: async () => {
+        const identityKey = getCurrentIdentityKey();
+        if (isPersistedIdentityStale(get().identityKey)) {
+          // Another account's or department's words must never label this one's screens.
+          set({ names: {}, isLoaded: false, identityKey: null });
+        }
+        try {
+          const response = await getTerminology();
+          const names: Record<string, string> = {};
+          for (const term of response?.Data ?? []) {
+            const name = term?.Name?.trim();
+            if (term?.Key && name) {
+              names[term.Key] = name;
+            }
+          }
+          set({ names, isLoaded: true, error: null, identityKey });
+        } catch (error) {
+          // Labels only: keep the persisted names (or the app's own) when offline or on an older server.
+          logger.error({
+            message: 'Failed to fetch department terminology',
+            context: { error },
+          });
+          set({ error: error instanceof Error ? error.message : 'Failed to fetch department terminology', isLoaded: true });
+        }
+      },
+    }),
+    {
+      name: 'terminology-storage',
+      storage: createJSONStorage(() => zustandStorage),
+      partialize: (state) => ({ names: state.names, identityKey: state.identityKey }),
+    }
+  )
+);
+
+/** Non-reactive lookup: the department's name for a term, else `fallback` (the app's own, translated name). */
+export const getTerm = (key: string | null | undefined, fallback: string): string => (key ? terminologyStore.getState().names[key] : undefined) || fallback;
+
+/** Reactive: the department's name for a term, else `fallback` (the app's own, translated name). */
+export const useTerm = (key: string | null | undefined, fallback: string): string => terminologyStore((state) => (key ? state.names[key] : undefined)) || fallback;
+
+/** Reactive: a record type's name by its number, else `fallback`. */
+export const useRecordTypeTerm = (recordType: number | null | undefined, fallback: string): string => useTerm(recordTypeTermKey(recordType), fallback);
+
+/** Reactive: a definition's name by its key; department definitions (and unrenamed types) show `fallback`. */
+export const useDefinitionTerm = (definitionKey: string | null | undefined, fallback: string): string => useTerm(definitionTermKey(definitionKey), fallback);

From da57666e399fb8ab6b3adac965f7978ed6a290a1 Mon Sep 17 00:00:00 2001
From: Shawn Jackson <shawn@resgrid.com>
Date: Wed, 14 Oct 2026 10:38:58 -0700
Subject: [PATCH 2/2] RR-T51 PR #159 Fixes

---
 src/components/home/status-buttons.tsx        | 10 +++----
 src/components/sidebar/side-menu-content.tsx  | 19 ++++++-------
 src/lib/base-types.ts                         |  2 +-
 .../terminology/__tests__/store.test.ts       | 27 +++++++++++++++++++
 src/stores/terminology/store.ts               |  4 +++
 5 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/src/components/home/status-buttons.tsx b/src/components/home/status-buttons.tsx
index 0b18f726..efb26031 100644
--- a/src/components/home/status-buttons.tsx
+++ b/src/components/home/status-buttons.tsx
@@ -19,8 +19,10 @@ const LEGACY_HIDDEN_STATUS_IDS = [4, 5, 6, 7];
 
 /**
  * Built-in options (StateId 0 / missing) 4-7 are the legacy system-managed statuses (Available Station, Responding
- * to Station, Responding to Scene, On Unit). A department's own options carry their set's id in StateId and can have
- * any id, including 4-7 on a fresh install, so they are never hidden.
+ * to Station, Responding to Scene, On Unit). Resgrid sets them internally and they predate the Detail-based destination
+ * model, so they stay off the Home tab buttons even though they may still be applied under the hood. A department's
+ * own options carry their set's id in StateId and can have any id, including 4-7 on a fresh install, so they are never
+ * hidden.
  */
 const isLegacyHiddenStatus = (status: StatusesResultData): boolean => !Number(status.StateId) && LEGACY_HIDDEN_STATUS_IDS.includes(status.Id);
 
@@ -109,9 +111,7 @@ export const StatusButtons: React.FC = () => {
   const isHoldMode = config?.StatusHoldToConfirm === true;
   const currentStatusType = (currentUserStatus ?? coreCurrentStatus)?.StatusType;
 
-  // Built-in options 4-7 are legacy system-managed statuses that Resgrid sets internally.
-  // They predate the newer Detail-based destination model and should stay hidden
-  // from the Home tab buttons even though they may still be applied under the hood.
+  // Legacy system-managed statuses stay off the Home tab buttons; see isLegacyHiddenStatus for which ones.
   const visibleStatuses = React.useMemo(() => (activeStatuses ?? []).filter((status) => !isLegacyHiddenStatus(status)), [activeStatuses]);
   const currentStatusId = React.useMemo(() => resolveCurrentStatusId(activeStatuses, { StateId: currentStatusType }), [activeStatuses, currentStatusType]);
   const offeredStatuses = React.useMemo(() => getOfferedStatuses(visibleStatuses, currentStatusId, showAllStatuses), [currentStatusId, showAllStatuses, visibleStatuses]);
diff --git a/src/components/sidebar/side-menu-content.tsx b/src/components/sidebar/side-menu-content.tsx
index 1644fcf3..4e07712b 100644
--- a/src/components/sidebar/side-menu-content.tsx
+++ b/src/components/sidebar/side-menu-content.tsx
@@ -78,6 +78,7 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
   const isWorkOrdersEnabled = useIsWorkOrdersEnabled();
   // The department's own names for its modules; an unrenamed module keeps the app's translated label.
   const termNames = terminologyStore((state) => state.names);
+  const term = useCallback((key: string, fallback: string): string => termNames[key] || fallback, [termNames]);
 
   const menuItems: MenuItem[] = useMemo(
     () =>
@@ -98,21 +99,21 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'contacts',
-          title: termNames[TermKeys.Contacts] || t('tabs.contacts'),
+          title: term(TermKeys.Contacts, t('tabs.contacts')),
           icon: Contact,
           route: '/(app)/contacts',
           testID: 'side-menu-contacts',
         },
         {
           id: 'map',
-          title: termNames[TermKeys.Mapping] || t('tabs.map'),
+          title: term(TermKeys.Mapping, t('tabs.map')),
           icon: MapIcon,
           route: '/(app)/map',
           testID: 'side-menu-map',
         },
         {
           id: 'notes',
-          title: termNames[TermKeys.Notes] || t('tabs.notes'),
+          title: term(TermKeys.Notes, t('tabs.notes')),
           icon: Notebook,
           route: '/(app)/notes',
           testID: 'side-menu-notes',
@@ -126,14 +127,14 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'calendar',
-          title: termNames[TermKeys.Calendar] || t('tabs.calendar'),
+          title: term(TermKeys.Calendar, t('tabs.calendar')),
           icon: Calendar,
           route: '/calendar',
           testID: 'side-menu-calendar',
         },
         {
           id: 'shifts',
-          title: termNames[TermKeys.Shifts] || t('tabs.shifts'),
+          title: term(TermKeys.Shifts, t('tabs.shifts')),
           icon: CalendarCheck,
           route: '/(app)/shifts',
           testID: 'side-menu-shifts',
@@ -147,14 +148,14 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'checklists',
-          title: termNames[TermKeys.Checklists] || t('checklists.labels.Checklists'),
+          title: term(TermKeys.Checklists, t('checklists.labels.Checklists')),
           icon: FileText,
           route: '/(app)/checklists',
           testID: 'side-menu-checklists',
         },
         {
           id: 'records',
-          title: termNames[TermKeys.Records] || t('tabs.records'),
+          title: term(TermKeys.Records, t('tabs.records')),
           icon: FileText,
           route: '/(app)/records',
           testID: 'side-menu-records',
@@ -168,7 +169,7 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         },
         {
           id: 'workOrders',
-          title: termNames[TermKeys.WorkOrders] || t('workOrders.title'),
+          title: term(TermKeys.WorkOrders, t('workOrders.title')),
           icon: Wrench,
           route: '/(app)/work-orders',
           testID: 'side-menu-work-orders',
@@ -215,7 +216,7 @@ export const SideMenu: React.FC<SideMenuProps> = React.memo(({ onNavigate }) =>
         }
         return true;
       }),
-    [t, termNames, isChatEnabled, isRecordsEnabled, isChecklistsEnabled, isDeploymentsEnabled, isWorkOrdersEnabled]
+    [t, term, isChatEnabled, isRecordsEnabled, isChecklistsEnabled, isDeploymentsEnabled, isWorkOrdersEnabled]
   );
 
   const handleNavigation = useCallback(
diff --git a/src/lib/base-types.ts b/src/lib/base-types.ts
index b6d5bc5a..efa5cd20 100644
--- a/src/lib/base-types.ts
+++ b/src/lib/base-types.ts
@@ -161,7 +161,7 @@ export const isStatusOnScene = (baseType: unknown): boolean => {
   return n === ActionBaseTypes.OnScene || n === ActionBaseTypes.MadeContact || n === ActionBaseTypes.Investigating || n === ActionBaseTypes.AtPatient || n === ActionBaseTypes.Searching || n === ActionBaseTypes.Staging;
 };
 
-/** On duty for staffing purposes: available, on shift, on call or delayed (not off duty or unavailable). */
+/** On duty for staffing purposes: available, on shift, on call, delayed or committed (not off duty or unavailable). */
 export const isStaffingOnDuty = (baseType: unknown): boolean => {
   const availability = staffingAvailability(baseType);
   return availability === 'available' || availability === 'delayed' || availability === 'committed';
diff --git a/src/stores/terminology/__tests__/store.test.ts b/src/stores/terminology/__tests__/store.test.ts
index b4488f3e..f94bdb9a 100644
--- a/src/stores/terminology/__tests__/store.test.ts
+++ b/src/stores/terminology/__tests__/store.test.ts
@@ -91,6 +91,33 @@ describe('Terminology store', () => {
     expect(terminologyStore.getState().names).toEqual({});
   });
 
+  it('discards a response that lands after the identity changed', async () => {
+    getTerminology.mockImplementation(async () => {
+      // The department switches while the request is out.
+      setIdentity('user-1', 'dept-2');
+      return { Data: [{ Key: TermKeys.Units, Category: 'Module', DefaultName: 'Units', Name: 'Apparatus' }] };
+    });
+
+    await terminologyStore.getState().fetchTerminology();
+
+    const state = terminologyStore.getState();
+    expect(state.names).toEqual({});
+    expect(state.identityKey).toBeNull();
+    expect(state.isLoaded).toBe(false);
+  });
+
+  it('discards a response that lands after sign-out', async () => {
+    getTerminology.mockImplementation(async () => {
+      setIdentity(null, null);
+      return { Data: [{ Key: TermKeys.Units, Category: 'Module', DefaultName: 'Units', Name: 'Apparatus' }] };
+    });
+
+    await terminologyStore.getState().fetchTerminology();
+
+    expect(terminologyStore.getState().names).toEqual({});
+    expect(terminologyStore.getState().identityKey).toBeNull();
+  });
+
   it('maps record type numbers and built-in definition keys to term keys', () => {
     expect(recordTypeTermKey(1)).toBe('record-type.run');
     expect(recordTypeTermKey(8)).toBe('record-type.unit-activity');
diff --git a/src/stores/terminology/store.ts b/src/stores/terminology/store.ts
index 298fbd91..b8e9e263 100644
--- a/src/stores/terminology/store.ts
+++ b/src/stores/terminology/store.ts
@@ -101,6 +101,10 @@ export const terminologyStore = create<TerminologyState>()(
         }
         try {
           const response = await getTerminology();
+          if (getCurrentIdentityKey() !== identityKey) {
+            // Signed out or switched department while the request was out: these names belong to the old identity.
+            return;
+          }
           const names: Record<string, string> = {};
           for (const term of response?.Data ?? []) {
             const name = term?.Name?.trim();