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/api/devices/__tests__/push.test.ts b/src/api/devices/__tests__/push.test.ts
index 1b20874e..3855eddb 100644
--- a/src/api/devices/__tests__/push.test.ts
+++ b/src/api/devices/__tests__/push.test.ts
@@ -1,9 +1,10 @@
 jest.mock('@/api/common/client', () => ({ createApiEndpoint: jest.fn(() => ({ post: jest.fn() })) }));
 
 import { createApiEndpoint } from '@/api/common/client';
-import { registerUnitDevice, unRegisterWebPush } from '@/api/devices/push';
+import { registerUnitDevice, unRegisterNativePush, unRegisterWebPush } from '@/api/devices/push';
 
-const [registerEndpoint, unregisterEndpoint] = (createApiEndpoint as jest.Mock).mock.results.map((result) => result.value as { post: jest.Mock });
+const [registerEndpoint, unregisterEndpoint, unregisterNativeEndpoint] = (createApiEndpoint as jest.Mock).mock.results.map((result) => result.value as { post: jest.Mock });
+const endpointPaths = (createApiEndpoint as jest.Mock).mock.calls.map(([path]) => path as string);
 
 describe('web push requests', () => {
   beforeEach(() => {
@@ -31,4 +32,15 @@ describe('web push requests', () => {
 
     expect(unregisterEndpoint.post).toHaveBeenCalledWith(input, controller.signal);
   });
+
+  it('sends a native token to the native push unregistration endpoint', async () => {
+    const input = { UnitId: '12', Token: 'native-token', Prefix: 'DEPT' };
+    const response = { Status: 'success' };
+    unregisterNativeEndpoint.post.mockResolvedValueOnce({ data: response });
+
+    await expect(unRegisterNativePush(input)).resolves.toBe(response);
+
+    expect(endpointPaths[2]).toBe('/Devices/UnRegisterNativePush');
+    expect(unregisterNativeEndpoint.post).toHaveBeenCalledWith(input, undefined);
+  });
 });
diff --git a/src/api/devices/push.ts b/src/api/devices/push.ts
index d466e878..946be3b8 100644
--- a/src/api/devices/push.ts
+++ b/src/api/devices/push.ts
@@ -1,10 +1,12 @@
 import { createApiEndpoint } from '@/api/common/client';
+import { type NativePushUnRegistrationInput } from '@/models/v4/device/nativePushUnRegistrationInput';
 import { type PushRegistrationResult } from '@/models/v4/device/pushRegistrationResult';
 import { type PushRegistrationUnitInput } from '@/models/v4/device/pushRegistrationUnitInput';
 import { type WebPushUnRegistrationInput } from '@/models/v4/device/webPushUnRegistrationInput';
 
 const registerUnitDeviceApi = createApiEndpoint('/Devices/RegisterUnitDevice');
 const unRegisterWebPushApi = createApiEndpoint('/Devices/UnRegisterWebPush');
+const unRegisterNativePushApi = createApiEndpoint('/Devices/UnRegisterNativePush');
 
 export const registerUnitDevice = async (data: PushRegistrationUnitInput, signal?: AbortSignal) => {
   const response = await registerUnitDeviceApi.post<PushRegistrationResult>({ ...data }, signal);
@@ -15,3 +17,8 @@ export const unRegisterWebPush = async (data: WebPushUnRegistrationInput, signal
   const response = await unRegisterWebPushApi.post<PushRegistrationResult>({ ...data }, signal);
   return response.data;
 };
+
+export const unRegisterNativePush = async (data: NativePushUnRegistrationInput, signal?: AbortSignal) => {
+  const response = await unRegisterNativePushApi.post<PushRegistrationResult>({ ...data }, signal);
+  return response.data;
+};
diff --git a/src/api/novu/__tests__/inbox.test.ts b/src/api/novu/__tests__/inbox.test.ts
new file mode 100644
index 00000000..4cea056f
--- /dev/null
+++ b/src/api/novu/__tests__/inbox.test.ts
@@ -0,0 +1,49 @@
+import { deleteMessage, getUnitSubscriberHash } from '../inbox';
+
+jest.mock('../../common/client', () => {
+  const del = jest.fn();
+  const get = jest.fn();
+  return {
+    createApiEndpoint: jest.fn(() => ({ get, post: jest.fn(), put: jest.fn(), delete: del })),
+    __mockDelete: del,
+    __mockGet: get,
+  };
+});
+
+const { __mockDelete: mockDelete, __mockGet: mockGet } = jest.requireMock('../../common/client') as { __mockDelete: jest.Mock; __mockGet: jest.Mock };
+
+describe('inbox deleteMessage api', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockDelete.mockResolvedValue({ data: undefined });
+  });
+
+  // The server only deletes from an inbox the caller owns; the Unit app's inbox is the active unit's, so
+  // without the unit it looks in the user's own inbox and answers 404.
+  it('sends the active unit so the server deletes from the unit inbox', async () => {
+    await deleteMessage('66f1c2a9e4b0a1b2c3d4e5f6', '15298');
+
+    expect(mockDelete).toHaveBeenCalledWith({ messageId: '66f1c2a9e4b0a1b2c3d4e5f6', unitId: '15298' });
+  });
+
+  it('leaves unitId out when there is no active unit', async () => {
+    await deleteMessage('66f1c2a9e4b0a1b2c3d4e5f6', null);
+
+    expect(mockDelete).toHaveBeenCalledWith({ messageId: '66f1c2a9e4b0a1b2c3d4e5f6' });
+  });
+});
+
+describe('inbox getUnitSubscriberHash api', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('asks for the unit inbox hash and returns the response body', async () => {
+    mockGet.mockResolvedValue({ data: { Data: { UnitId: '15298', SubscriberHash: 'abc123' } } });
+
+    const result = await getUnitSubscriberHash('15298');
+
+    expect(mockGet).toHaveBeenCalledWith({ unitId: '15298' });
+    expect(result.Data.SubscriberHash).toBe('abc123');
+  });
+});
diff --git a/src/api/novu/inbox.ts b/src/api/novu/inbox.ts
index 86f1bc4b..c3b2c3b9 100644
--- a/src/api/novu/inbox.ts
+++ b/src/api/novu/inbox.ts
@@ -1,10 +1,30 @@
 import { createApiEndpoint } from '../common/client';
 
 const getGroupsApi = createApiEndpoint('/Inbox/DeleteMessage');
+const getUnitSubscriberHashApi = createApiEndpoint('/Inbox/GetUnitSubscriberHash');
 
-export const deleteMessage = async (messageId: string) => {
+export interface UnitSubscriberHashResult {
+  Data: {
+    UnitId: string;
+    SubscriberHash?: string | null;
+  };
+}
+
+// The inbox belongs to the active unit's Novu subscriber, so the server needs the unit to find the message.
+// Without one it only looks in the signed-in user's own inbox and answers 404.
+export const deleteMessage = async (messageId: string, unitId?: string | null) => {
   const response = await getGroupsApi.delete({
     messageId: encodeURIComponent(messageId),
+    ...(unitId ? { unitId } : {}),
+  });
+  return response.data;
+};
+
+// The Novu subscriberHash for the unit's inbox ({DepartmentCode}_Unit_{unitId}). Novu refuses an inbox session
+// without it once HMAC is enforced on the environment.
+export const getUnitSubscriberHash = async (unitId: string) => {
+  const response = await getUnitSubscriberHashApi.get<UnitSubscriberHashResult>({
+    unitId,
   });
   return response.data;
 };
diff --git a/src/app/(app)/__tests__/index.test.tsx b/src/app/(app)/__tests__/index.test.tsx
index 6326abf0..0ca7b7b2 100644
--- a/src/app/(app)/__tests__/index.test.tsx
+++ b/src/app/(app)/__tests__/index.test.tsx
@@ -41,6 +41,9 @@ jest.mock('@/api/mapping/mapping', () => ({
     Data: { MapMakerInfos: [] },
   }),
 }));
+jest.mock('@/api/config/terminology', () => ({
+  getTerminology: jest.fn(),
+}));
 // Camera commands issued by the screen. The MapView mock reports the map ready
 // on mount and the Camera mock exposes a real imperative handle, so the
 // follow-camera effects actually run in tests.
diff --git a/src/app/(app)/_layout.tsx b/src/app/(app)/_layout.tsx
index 02345683..011e7a8b 100644
--- a/src/app/(app)/_layout.tsx
+++ b/src/app/(app)/_layout.tsx
@@ -27,6 +27,7 @@ import { useAnalytics } from '@/hooks/use-analytics';
 import { useAppLifecycle } from '@/hooks/use-app-lifecycle';
 import { useSharedSessionLifecycle } from '@/hooks/use-shared-session-lifecycle';
 import { useSignalRLifecycle } from '@/hooks/use-signalr-lifecycle';
+import { useUnitSubscriberHash } from '@/hooks/use-unit-subscriber-hash';
 import { getAppTabBarHeight } from '@/lib/app-shell-layout';
 import { useAuthStore } from '@/lib/auth';
 import { cacheManager } from '@/lib/cache/cache-manager';
@@ -43,6 +44,7 @@ import { FeatureFlagKeys, featureFlagsStore } from '@/stores/feature-flags/store
 import { useRolesStore } from '@/stores/roles/store';
 import { securityStore } from '@/stores/security/store';
 import { useSignalRStore } from '@/stores/signalr/signalr-store';
+import { terminologyStore, TermKeys } from '@/stores/terminology/store';
 import { useToastStore } from '@/stores/toast/store';
 import { useWeatherAlertsStore } from '@/stores/weather-alerts/store';
 import { isNetworkError } from '@/utils/network';
@@ -194,6 +196,9 @@ export default function TabLayout() {
 
       if (!isCurrentRun()) return;
 
+      // After rights (its identity key needs the department); labels only, so it never holds up init.
+      void terminologyStore.getState().fetchTerminology();
+
       // SignalR needs config (EventingUrl) and rights (DepartmentId) — both
       // available now. The two hub connects are independent.
       await Promise.all([useSignalRStore.getState().connectUpdateHub(), useSignalRStore.getState().connectGeolocationHub()]);
@@ -404,13 +409,17 @@ export default function TabLayout() {
   const config = useCoreStore((state) => state.config);
   const activeUnitId = useCoreStore((state) => state.activeUnitId);
   const rights = securityStore((state) => state.rights);
+  const termNames = terminologyStore((state) => state.names);
+  const unitSubscriberHash = useUnitSubscriberHash(activeUnitId);
 
-  // Compute Novu readiness once for consistent gating across the render
-  const novuReady = !!(activeUnitId && config?.NovuApplicationId && config?.NovuBackendApiUrl && config?.NovuSocketUrl && rights?.DepartmentCode);
+  // Compute Novu readiness once for consistent gating across the render. It also waits for the unit's
+  // subscriberHash fetch to settle, so a unit switch keeps the previous inbox up until the new one can open.
+  const novuReady = !!(activeUnitId && config?.NovuApplicationId && config?.NovuBackendApiUrl && config?.NovuSocketUrl && rights?.DepartmentCode && unitSubscriberHash.settled);
   // Cache the last known-good Novu config so NovuProvider stays mounted stably
   // even if a transient state update briefly nullifies one of the values.
   const lastNovuConfig = useRef<{
     subscriberId: string;
+    subscriberHash?: string;
     applicationIdentifier: string;
     backendUrl: string;
     socketUrl: string;
@@ -418,6 +427,7 @@ export default function TabLayout() {
   if (novuReady) {
     lastNovuConfig.current = {
       subscriberId: `${rights?.DepartmentCode}_Unit_${activeUnitId}`,
+      subscriberHash: unitSubscriberHash.subscriberHash,
       applicationIdentifier: config!.NovuApplicationId,
       backendUrl: config!.NovuBackendApiUrl,
       socketUrl: config!.NovuSocketUrl,
@@ -474,15 +484,17 @@ export default function TabLayout() {
 
   // Memoize header left/right renders
   const headerLeftMap = useCallback(() => <CreateDrawerMenuButton setIsOpen={setIsOpen} isLandscape={isLandscape} />, [isLandscape]);
+  // Gated on novuReady like the inbox: before the unit's subscriberHash settles there is no NovuProvider yet, and
+  // the button's useCounts throws outside one.
   const headerRightNotification = useCallback(
-    () => <CreateNotificationButton config={config} setIsNotificationsOpen={handleOpenNotifications} activeUnitId={activeUnitId} departmentCode={rights?.DepartmentCode} />,
-    [config, handleOpenNotifications, activeUnitId, rights?.DepartmentCode]
+    () => (novuReady ? <CreateNotificationButton config={config} setIsNotificationsOpen={handleOpenNotifications} activeUnitId={activeUnitId} departmentCode={rights?.DepartmentCode} /> : null),
+    [novuReady, config, handleOpenNotifications, activeUnitId, rights?.DepartmentCode]
   );
 
   // Memoize per-screen options to prevent new objects every render
   const indexOptions = useMemo(
     () => ({
-      title: t('tabs.map'),
+      title: termNames[TermKeys.Mapping] || t('tabs.map'),
       tabBarIcon: mapIcon,
       headerLeft: headerLeftMap,
       tabBarButtonTestID: 'map-tab' as const,
@@ -494,29 +506,29 @@ export default function TabLayout() {
       // a use-after-free). Freezing preserves the native MapView, shrinking that race.
       freezeOnBlur: true,
     }),
-    [t, mapIcon, headerLeftMap, headerRightNotification]
+    [t, termNames, mapIcon, headerLeftMap, headerRightNotification]
   );
 
   const callsOptions = useMemo(
     () => ({
-      title: t('tabs.calls'),
+      title: termNames[TermKeys.Calls] || t('tabs.calls'),
       headerShown: true as const,
       tabBarIcon: callsIcon,
       tabBarButtonTestID: 'calls-tab' as const,
       headerRight: headerRightNotification,
     }),
-    [t, callsIcon, headerRightNotification]
+    [t, termNames, callsIcon, headerRightNotification]
   );
 
   const contactsOptions = useMemo(
     () => ({
-      title: t('tabs.contacts'),
+      title: termNames[TermKeys.Contacts] || t('tabs.contacts'),
       headerShown: true as const,
       tabBarIcon: contactsIcon,
       tabBarButtonTestID: 'contacts-tab' as const,
       headerRight: headerRightNotification,
     }),
-    [t, contactsIcon, headerRightNotification]
+    [t, termNames, contactsIcon, headerRightNotification]
   );
 
   const routesOptions = useMemo(
@@ -532,13 +544,13 @@ export default function TabLayout() {
 
   const notesOptions = useMemo(
     () => ({
-      title: t('tabs.notes'),
+      title: termNames[TermKeys.Notes] || t('tabs.notes'),
       headerShown: true as const,
       tabBarIcon: notesIcon,
       tabBarButtonTestID: 'notes-tab' as const,
       headerRight: headerRightNotification,
     }),
-    [t, notesIcon, headerRightNotification]
+    [t, termNames, notesIcon, headerRightNotification]
   );
 
   const weatherAlertsOptions = useMemo(
@@ -638,9 +650,9 @@ export default function TabLayout() {
             <Tabs.Screen name="routes" options={routesOptions} />
 
             <Tabs.Screen name="contacts" options={contactsOptions} />
-            <Tabs.Screen name="checklists" options={{ href: null, title: t('checklists.labels.Checklists') }} />
+            <Tabs.Screen name="checklists" options={{ href: null, title: termNames[TermKeys.Checklists] || t('checklists.labels.Checklists') }} />
             <Tabs.Screen name="operations" options={{ href: null, headerShown: false }} />
-            <Tabs.Screen name="records" options={{ href: null, title: t('tabs.records') }} />
+            <Tabs.Screen name="records" options={{ href: null, title: termNames[TermKeys.Records] || t('tabs.records') }} />
             <Tabs.Screen name="inventory" options={{ href: null, headerShown: false }} />
 
             <Tabs.Screen name="notes" options={notesOptions} />
@@ -673,6 +685,7 @@ export default function TabLayout() {
     return (
       <NovuProvider
         subscriberId={lastNovuConfig.current.subscriberId}
+        subscriberHash={lastNovuConfig.current.subscriberHash}
         applicationIdentifier={lastNovuConfig.current.applicationIdentifier}
         backendUrl={lastNovuConfig.current.backendUrl}
         socketUrl={lastNovuConfig.current.socketUrl}
diff --git a/src/app/(app)/checklists.tsx b/src/app/(app)/checklists.tsx
index bdc9ceb9..92d089a7 100644
--- a/src/app/(app)/checklists.tsx
+++ b/src/app/(app)/checklists.tsx
@@ -12,9 +12,11 @@ import { useProtectedReveal } from '@/hooks/use-protected-reveal';
 import { checklistError } from '@/lib/checklists/sync';
 import { useCoreStore } from '@/stores/app/core-store';
 import { useChecklistsStore } from '@/stores/checklists/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 export default function ChecklistsScreen() {
   const { t } = useTranslation();
+  const title = useTerm(TermKeys.Checklists, t('checklists.labels.Checklists'));
   const { occurrenceId } = useLocalSearchParams<{ occurrenceId?: string }>();
   const activeUnit = useCoreStore((s) => s.activeUnitId);
   const unitId = activeUnit || undefined;
@@ -48,7 +50,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 }} />
       <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)/index.tsx b/src/app/(app)/index.tsx
index 1ffced7f..ddd4cb31 100644
--- a/src/app/(app)/index.tsx
+++ b/src/app/(app)/index.tsx
@@ -32,6 +32,7 @@ import { useCoreStore } from '@/stores/app/core-store';
 import { useLocationStore } from '@/stores/app/location-store';
 import { useMapsStore } from '@/stores/maps/store';
 import { useRoutesStore } from '@/stores/routes/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 import { useToastStore } from '@/stores/toast/store';
 import { useWeatherAlertsStore } from '@/stores/weather-alerts/store';
 
@@ -56,6 +57,7 @@ export default function Map() {
 
 function MapContent() {
   const { t } = useTranslation();
+  const mapTitle = useTerm(TermKeys.Mapping, t('tabs.map'));
   const { trackEvent } = useAnalytics();
   const { colorScheme } = useColorScheme();
   const insets = useSafeAreaInsets();
@@ -567,7 +569,7 @@ function MapContent() {
     <>
       <Stack.Screen
         options={{
-          title: t('tabs.map'),
+          title: mapTitle,
           headerTitle: t('app.title'),
           headerShown: true,
           headerBackTitle: '',
diff --git a/src/app/(app)/inventory/index.tsx b/src/app/(app)/inventory/index.tsx
index 58f08f0d..9f68944f 100644
--- a/src/app/(app)/inventory/index.tsx
+++ b/src/app/(app)/inventory/index.tsx
@@ -14,6 +14,7 @@ import { contentOf, groupEquipment, locationNames, orderLocations } from '@/lib/
 import { InventoryAssetStatus, InventoryCountStatus } from '@/models/v4/inventory';
 import { useCoreStore } from '@/stores/app/core-store';
 import { useInventoryStore } from '@/stores/inventory/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 
 const todayKey = () => {
   const now = new Date();
@@ -30,6 +31,13 @@ export default function UnitInventoryScreen() {
   const { access, equipment, counts, busy, error } = useInventoryStore();
   const [countLocation, setCountLocation] = useState('');
   const unitId = activeUnitId ? Number(activeUnitId) : null;
+  const renamed = useTerm(TermKeys.Inventory, '');
+  const title = renamed || t('inventory.title');
+  let heading = title;
+  if (activeUnit?.Name) {
+    // Every locale's titleFor reads "<title> · <unit>"; the department's own word keeps that shape.
+    heading = renamed ? `${renamed} · ${activeUnit.Name}` : t('inventory.titleFor', { name: activeUnit.Name });
+  }
 
   useFocusEffect(
     useCallback(() => {
@@ -53,9 +61,9 @@ export default function UnitInventoryScreen() {
 
   return (
     <VStack className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: t('inventory.title') }} />
+      <Stack.Screen options={{ title }} />
       <ScrollView contentContainerStyle={{ padding: 16, gap: 12 }} refreshControl={<RefreshControl refreshing={busy} onRefresh={() => unitId && void useInventoryStore.getState().load(unitId)} />}>
-        <Text className="text-xl font-bold">{activeUnit?.Name ? t('inventory.titleFor', { name: activeUnit.Name }) : t('inventory.title')}</Text>
+        <Text className="text-xl font-bold">{heading}</Text>
         {!unitId ? <Text className="text-typography-500">{t('inventory.selectUnit')}</Text> : null}
         {busy && !access ? <Spinner /> : null}
         {error ? (
diff --git a/src/app/(app)/records.tsx b/src/app/(app)/records.tsx
index c80a919e..e0c21b5f 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.
@@ -45,6 +46,7 @@ export default function RecordsScreen() {
   const router = useRouter();
   const flagStatus = useRecordsFieldStatus();
   const context = useRecordsContext();
+  const recordsTitle = useTerm(TermKeys.Records, t('records.title'));
 
   const { preflight, catalog, assignments, recent, drafts, pendingDrafts, isSyncing, error } = useRecordsStore();
   const setContext = useRecordsStore((state) => state.setContext);
@@ -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/call/[id]/edit.tsx b/src/app/call/[id]/edit.tsx
index 2af917c8..f2f94892 100644
--- a/src/app/call/[id]/edit.tsx
+++ b/src/app/call/[id]/edit.tsx
@@ -32,6 +32,7 @@ import {
   CALL_FIELD_LABEL_KEYS,
   CALL_IDENTIFIER_FIELDS,
   DISPATCH_ON_MIN_LEAD_MINUTES,
+  findCallType,
   formatCallFieldLabels,
   getEditCallFieldValues,
   getEnforcedMissingCallFields,
@@ -160,8 +161,8 @@ export default function EditCall() {
   useEffect(() => {
     if (call) {
       const priority = 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 = 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(callTypes, call);
 
       // Seed the picker with who the call already went to. Without this the edit posted an empty
       // dispatch list, which the API reads as "dispatch the whole department".
diff --git a/src/app/call/__tests__/edit.test.tsx b/src/app/call/__tests__/edit.test.tsx
index bfd060a3..aa2a98aa 100644
--- a/src/app/call/__tests__/edit.test.tsx
+++ b/src/app/call/__tests__/edit.test.tsx
@@ -457,4 +457,24 @@ describe('EditCall field policy', () => {
 
     await waitFor(() => expect(mockToast.error).toHaveBeenCalledWith('call_detail.update_call_error'));
   });
+
+  describe('call type', () => {
+    it('finds the call type by TypeId, so a type renamed since the call was logged is still selected', async () => {
+      mockDetailState.call = { ...BASE_CALL, Type: 'Fire (old name)', TypeId: '1' };
+      await renderWithPolicy([]);
+
+      save();
+
+      await waitFor(() => expect(mockUpdateCall).toHaveBeenCalledWith(expect.objectContaining({ type: 'Fire' })));
+    });
+
+    it('finds the call type by name when the server sends no TypeId (older servers)', async () => {
+      mockDetailState.call = { ...BASE_CALL, Type: 'Fire' };
+      await renderWithPolicy([]);
+
+      save();
+
+      await waitFor(() => expect(mockUpdateCall).toHaveBeenCalledWith(expect.objectContaining({ type: 'Fire' })));
+    });
+  });
 });
diff --git a/src/app/maps/_layout.tsx b/src/app/maps/_layout.tsx
index 55afee32..2cf02acb 100644
--- a/src/app/maps/_layout.tsx
+++ b/src/app/maps/_layout.tsx
@@ -2,8 +2,11 @@ import { Stack } from 'expo-router';
 import React from 'react';
 import { useTranslation } from 'react-i18next';
 
+import { TermKeys, useTerm } from '@/stores/terminology/store';
+
 export default function MapsLayout() {
   const { t } = useTranslation();
+  const mapsTitle = useTerm(TermKeys.Mapping, t('maps.title'));
 
   return (
     <Stack
@@ -12,7 +15,7 @@ export default function MapsLayout() {
         headerBackTitle: t('common.back'),
       }}
     >
-      <Stack.Screen name="index" options={{ title: t('maps.title') }} />
+      <Stack.Screen name="index" options={{ title: mapsTitle }} />
       <Stack.Screen name="search" options={{ title: t('maps.search_maps'), presentation: 'modal' }} />
       <Stack.Screen name="custom/[id]" options={{ title: t('maps.custom_maps') }} />
       <Stack.Screen name="indoor/[id]" options={{ title: t('maps.indoor_maps') }} />
diff --git a/src/app/records/[id].tsx b/src/app/records/[id].tsx
index db063c4e..38b173b3 100644
--- a/src/app/records/[id].tsx
+++ b/src/app/records/[id].tsx
@@ -14,10 +14,12 @@ 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 { useRecordTypeName } from '@/hooks/use-record-type-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.
@@ -83,6 +85,8 @@ 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 typeName = useRecordTypeName(record?.DefinitionKey, typeof record?.RecordType === 'number' ? record.RecordType : null);
+  const recordsTitle = useTerm(TermKeys.Records, t('records.title'));
 
   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 ?? typeName ?? t('records.untitled'),
         values: toValueList(values),
         rowVersion: current.RowVersion,
         updatedOn: new Date().toISOString(),
@@ -122,7 +126,7 @@ export default function RecordScreen() {
       setDirty(false);
       return result.record;
     },
-    [values, entry, stageDraft, pushDraft, discardDraft, fetchRecord, t]
+    [values, typeName, stageDraft, pushDraft, discardDraft, fetchRecord, t]
   );
 
   const save = useCallback(async () => {
@@ -204,7 +208,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>
     );
@@ -212,10 +216,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">{typeName ?? record.DefinitionKey ?? 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 4fdd8c33..cd400e78 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]';
 
@@ -41,6 +42,10 @@ jest.mock('@/api/records/records', () => ({
   getRecord: jest.fn(),
 }));
 
+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() },
 }));
@@ -208,4 +213,17 @@ describe('RecordScreen', () => {
     expect(store.finalize).not.toHaveBeenCalled();
     unmount();
   });
+
+  it("heads a built-in record with the department's name for its type", async () => {
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+    mockGetRecord.mockReset();
+    mockGetRecord.mockResolvedValue({ Data: { ...record(4), DefinitionKey: 'system.run' } } as never);
+
+    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 dcac08f8..da742b76 100644
--- a/src/app/records/new.tsx
+++ b/src/app/records/new.tsx
@@ -15,9 +15,11 @@ 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 { recordTypeName } from '@/hooks/use-record-type-name';
 import { canAuthorOffline, cellKey, toValueList, unsupportedFieldKeys, validate, type ValidationIssue, type ValueMap } from '@/lib/records/schema';
 import { type FieldRecordCatalogEntry, type RecordDefinitionSchema } from '@/models/v4/records';
 import { useRecordsStore } from '@/stores/records/store';
+import { terminologyStore } from '@/stores/terminology/store';
 
 // Contextual create: pick a definition the server offered for this context, then author it. The
 // catalog is the only source of what may be started here — nothing is inferred locally.
@@ -41,9 +43,11 @@ export default function NewRecordScreen() {
   const discardDraft = useRecordsStore((state) => state.discardDraft);
   const pushDraft = useRecordsStore((state) => state.pushDraft);
   const report = useRecordsStore((state) => state.report);
+  const termNames = terminologyStore((state) => state.names);
 
   const resumed = params.draft ? pendingDrafts[params.draft] : undefined;
   const [entry, setEntry] = useState<FieldRecordCatalogEntry | null>(null);
+  const entryName = entry ? recordTypeName(termNames, entry.DefinitionKey, entry.RecordType, entry.Name) : '';
   const [schema, setSchema] = useState<RecordDefinitionSchema | null>(null);
   const [values, setValues] = useState<ValueMap>({});
   const [issues, setIssues] = useState<ValidationIssue[]>([]);
@@ -131,7 +135,7 @@ export default function NewRecordScreen() {
         recordId: resumed?.recordId ?? null,
         definitionKey: entry.DefinitionKey,
         definitionVersion: entry.Version,
-        name: entry.Name,
+        name: entryName,
         values: toValueList(values),
         // A resumed draft stays on the Call it was started against, whatever is active now.
         callId: resumed ? (resumed.callId ?? null) : (context.CallId ?? null),
@@ -164,7 +168,7 @@ export default function NewRecordScreen() {
         setIsBusy(false);
       }
     },
-    [entry, schema, values, resumed, context, stageDraft, offlineCapable, pushDraft, discardDraft, router, t]
+    [entry, entryName, schema, values, resumed, context, stageDraft, offlineCapable, pushDraft, discardDraft, router, t]
   );
 
   if (!entry) {
@@ -181,7 +185,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">{recordTypeName(termNames, definition.DefinitionKey, definition.RecordType, 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 ? (
@@ -210,7 +214,7 @@ export default function NewRecordScreen() {
 
   return (
     <Box className="flex-1 bg-background-0">
-      <Stack.Screen options={{ title: entry.Name }} />
+      <Stack.Screen options={{ title: entryName }} />
       <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/notifications/NotificationInbox.tsx b/src/components/notifications/NotificationInbox.tsx
index 4991fbc8..7ab5a8f7 100644
--- a/src/components/notifications/NotificationInbox.tsx
+++ b/src/components/notifications/NotificationInbox.tsx
@@ -298,7 +298,7 @@ export const NotificationInbox = ({ isOpen, onClose }: NotificationInboxProps) =
     setShowDeleteConfirmModal(false);
 
     try {
-      const deletePromises = Array.from(selectedNotificationIds).map((id) => deleteMessage(id));
+      const deletePromises = Array.from(selectedNotificationIds).map((id) => deleteMessage(id, activeUnitId));
       await Promise.all(deletePromises);
 
       showToast('success', selectedNotificationIds.size > 1 ? t('notifications.removed_count', { count: selectedNotificationIds.size }) : t('notifications.removed_one'));
@@ -309,19 +309,19 @@ export const NotificationInbox = ({ isOpen, onClose }: NotificationInboxProps) =
     } finally {
       setIsDeletingSelected(false);
     }
-  }, [selectedNotificationIds, showToast, exitSelectionMode, refetch, t]);
+  }, [selectedNotificationIds, activeUnitId, showToast, exitSelectionMode, refetch, t]);
 
   const handleDeleteNotification = React.useCallback(
     async (_id: string) => {
       try {
-        await deleteMessage(_id);
+        await deleteMessage(_id, activeUnitId);
         showToast('success', t('notifications.removed_one'));
         refetch();
       } catch (error) {
         showToast('error', t('notifications.remove_failed_one'));
       }
     },
-    [showToast, refetch, t]
+    [activeUnitId, showToast, refetch, t]
   );
 
   const handleNavigateToReference = React.useCallback(
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..3d8d23af
--- /dev/null
+++ b/src/components/records/__tests__/record-list-item.test.tsx
@@ -0,0 +1,115 @@
+import { render, screen } from '@testing-library/react-native';
+import React from 'react';
+
+import { type RecordSummaryData, RmsRecordState } from '@/models/v4/records';
+import { terminologyStore } from '@/stores/terminology/store';
+
+import { RecordListItem } from '../record-list-item';
+
+let mockCatalogNames: Record<string, string> = {};
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+jest.mock('lucide-react-native', () => ({ AlertTriangle: 'AlertTriangle', CloudOff: 'CloudOff', FileText: 'FileText' }));
+
+jest.mock('@/api/config/terminology', () => ({
+  getTerminology: jest.fn(),
+}));
+
+jest.mock('@/stores/records/store', () => ({
+  useRecordsStore: (selector: (state: unknown) => unknown) =>
+    selector({ entryFor: (definitionKey: string) => (mockCatalogNames[definitionKey] ? { DefinitionKey: definitionKey, Name: mockCatalogNames[definitionKey] } : null) }),
+}));
+
+jest.mock('@/components/ui/badge', () => {
+  const { Text, View } = require('react-native');
+  return {
+    Badge: ({ children }: { children: React.ReactNode }) => <View>{children}</View>,
+    BadgeText: ({ children }: { children: React.ReactNode }) => <Text>{children}</Text>,
+  };
+});
+
+jest.mock('@/components/ui/box', () => {
+  const { View } = require('react-native');
+  return { Box: ({ children }: { children: React.ReactNode }) => <View>{children}</View> };
+});
+
+jest.mock('@/components/ui/hstack', () => {
+  const { View } = require('react-native');
+  return { HStack: ({ children }: { children: React.ReactNode }) => <View>{children}</View> };
+});
+
+jest.mock('@/components/ui/vstack', () => {
+  const { View } = require('react-native');
+  return { VStack: ({ children }: { children: React.ReactNode }) => <View>{children}</View> };
+});
+
+jest.mock('@/components/ui/pressable', () => {
+  const { Pressable } = require('react-native');
+  return { Pressable };
+});
+
+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-13T00:00:00Z',
+  ModifiedOn: '2026-10-13T00:00:00Z',
+  RowVersion: 1,
+  ...overrides,
+});
+
+describe('RecordListItem record type', () => {
+  beforeEach(() => {
+    mockCatalogNames = {};
+    terminologyStore.setState({ names: {}, isLoaded: true, error: null, identityKey: null });
+  });
+
+  it('shows the department name for a built-in type instead of its raw key', () => {
+    mockCatalogNames = { 'system.run': 'Run' };
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+
+    const { unmount } = render(<RecordListItem record={summary({})} onPress={jest.fn()} />);
+
+    expect(screen.getAllByText('Incident').length).toBeGreaterThan(0);
+    expect(screen.queryByText('system.run')).toBeNull();
+    unmount();
+  });
+
+  it('shows the department name on a record number row as its subtitle', () => {
+    terminologyStore.setState({ names: { 'record-type.run': 'Incident' } });
+
+    const { unmount } = render(<RecordListItem record={summary({ RecordNumber: 'R-12' })} onPress={jest.fn()} />);
+
+    expect(screen.getByText('R-12')).toBeTruthy();
+    expect(screen.getByText('Incident')).toBeTruthy();
+    unmount();
+  });
+
+  it('falls back to the catalog name when the type is not renamed', () => {
+    mockCatalogNames = { 'system.run': 'Run' };
+
+    const { unmount } = render(<RecordListItem record={summary({})} onPress={jest.fn()} />);
+
+    expect(screen.getAllByText('Run').length).toBeGreaterThan(0);
+    expect(screen.queryByText('system.run')).toBeNull();
+    unmount();
+  });
+
+  it('names a legacy record by its record type number', () => {
+    terminologyStore.setState({ names: { 'record-type.training': 'Drill' } });
+
+    const { unmount } = render(<RecordListItem record={summary({ DefinitionKey: null, RecordType: 2, RecordNumber: 'T-3' })} onPress={jest.fn()} />);
+
+    expect(screen.getByText('Drill')).toBeTruthy();
+    unmount();
+  });
+});
diff --git a/src/components/records/record-list-item.tsx b/src/components/records/record-list-item.tsx
index 01803cd0..c47950cd 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 { useRecordTypeName } from '@/hooks/use-record-type-name';
 import { type FieldRecordAssignmentData, type RecordSummaryData, RmsRecordState } from '@/models/v4/records';
 import { type PendingRecordDraft } from '@/stores/records/store';
 
@@ -29,7 +30,9 @@ 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');
+  // The raw key ("system.run") only when neither the department nor the catalog has a name for it.
+  const typeName = useRecordTypeName(record.DefinitionKey, record.RecordType) || record.DefinitionKey;
+  const title = record.RecordNumber || record.DraftReference || typeName || t('records.untitled');
 
   return (
     <Pressable onPress={onPress} className="px-4 py-3" testID={testID}>
@@ -42,7 +45,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 || typeName || ''}
           </Text>
         </VStack>
         <Badge action={stateAction(record.State)} size="sm">
diff --git a/src/components/sidebar/__tests__/sidebar-content.test.tsx b/src/components/sidebar/__tests__/sidebar-content.test.tsx
index a073d710..137c1961 100644
--- a/src/components/sidebar/__tests__/sidebar-content.test.tsx
+++ b/src/components/sidebar/__tests__/sidebar-content.test.tsx
@@ -2,6 +2,7 @@ import { fireEvent, render, screen } from '@testing-library/react-native';
 import React from 'react';
 
 import { useCoreStore } from '@/stores/app/core-store';
+import { terminologyStore } from '@/stores/terminology/store';
 
 import Sidebar from '../sidebar-content';
 
@@ -31,11 +32,16 @@ jest.mock('@/stores/toast/store', () => ({
   useToastStore: (selector: (state: { showToast: jest.Mock }) => unknown) => selector({ showToast: mockShowToast }),
 }));
 
+const mockFlags = { checklists: false, records: false };
 jest.mock('@/stores/feature-flags/store', () => ({
   useIsChatEnabled: () => false,
-  useIsChecklistsEnabled: () => false,
+  useIsChecklistsEnabled: () => mockFlags.checklists,
   useIsDeploymentsEnabled: () => false,
-  useIsRecordsFieldEnabled: () => false,
+  useIsRecordsFieldEnabled: () => mockFlags.records,
+}));
+
+jest.mock('@/api/config/terminology', () => ({
+  getTerminology: jest.fn(),
 }));
 
 jest.mock('../call-sidebar', () => ({ SidebarCallCard: () => null }));
@@ -175,3 +181,42 @@ describe('Sidebar status buttons', () => {
     unmount();
   });
 });
+
+describe('Sidebar module labels', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFlags.checklists = true;
+    mockFlags.records = true;
+    terminologyStore.setState({ names: {}, isLoaded: true, error: null, identityKey: null });
+  });
+
+  afterAll(() => {
+    mockFlags.checklists = false;
+    mockFlags.records = false;
+  });
+
+  it("shows the department's own module names", () => {
+    terminologyStore.setState({ names: { 'module.inventory': 'Gear', 'module.records': 'Reports', 'module.checklists': 'Rig Checks' } });
+    setCoreState({ holdMode: false });
+
+    const { unmount } = render(<Sidebar />);
+
+    expect(screen.getByText('Gear')).toBeTruthy();
+    expect(screen.getByText('Reports')).toBeTruthy();
+    expect(screen.getByText('Rig Checks')).toBeTruthy();
+    expect(screen.queryByText('inventory.title')).toBeNull();
+    expect(screen.queryByText('tabs.records')).toBeNull();
+    unmount();
+  });
+
+  it("keeps the app's own labels for modules that are not renamed", () => {
+    setCoreState({ holdMode: false });
+
+    const { unmount } = render(<Sidebar />);
+
+    expect(screen.getByText('inventory.title')).toBeTruthy();
+    expect(screen.getByText('tabs.records')).toBeTruthy();
+    expect(screen.getByText('checklists.labels.Checklists')).toBeTruthy();
+    unmount();
+  });
+});
diff --git a/src/components/sidebar/sidebar-content.tsx b/src/components/sidebar/sidebar-content.tsx
index a3088ed9..f4662cc2 100644
--- a/src/components/sidebar/sidebar-content.tsx
+++ b/src/components/sidebar/sidebar-content.tsx
@@ -15,6 +15,7 @@ import { readableColors } from '@/lib/utils';
 import { useCoreStore } from '@/stores/app/core-store';
 import { useIsChatEnabled, useIsChecklistsEnabled, useIsDeploymentsEnabled, useIsRecordsFieldEnabled } from '@/stores/feature-flags/store';
 import { useStatusBottomSheetStore } from '@/stores/status/store';
+import { TermKeys, useTerm } from '@/stores/terminology/store';
 import { useToastStore } from '@/stores/toast/store';
 
 import ZeroState from '../common/zero-state';
@@ -47,6 +48,9 @@ const Sidebar = ({ onClose }: SidebarProps) => {
   const isRecordsEnabled = useIsRecordsFieldEnabled();
   const { t } = useTranslation();
   const router = useRouter();
+  const checklistsLabel = useTerm(TermKeys.Checklists, t('checklists.labels.Checklists'));
+  const inventoryLabel = useTerm(TermKeys.Inventory, t('inventory.title'));
+  const recordsLabel = useTerm(TermKeys.Records, t('tabs.records'));
 
   const isActiveStatusesEmpty = !activeStatuses?.Statuses || activeStatuses.Statuses.length === 0;
 
@@ -128,7 +132,7 @@ const Sidebar = ({ onClose }: SidebarProps) => {
             }}
             testID="sidebar-checklists"
           >
-            <ButtonText>{t('checklists.labels.Checklists')}</ButtonText>
+            <ButtonText>{checklistsLabel}</ButtonText>
           </Button>
         ) : null}
 
@@ -162,7 +166,7 @@ const Sidebar = ({ onClose }: SidebarProps) => {
             testID="sidebar-inventory"
           >
             <Package size={18} color="#2563eb" />
-            <ButtonText className="ml-2">{t('inventory.title')}</ButtonText>
+            <ButtonText className="ml-2">{inventoryLabel}</ButtonText>
           </Button>
         ) : null}
 
@@ -170,7 +174,7 @@ const Sidebar = ({ onClose }: SidebarProps) => {
         {isRecordsEnabled ? (
           <Button variant="outline" action="secondary" size="md" onPress={handleNavigateToRecords} testID="sidebar-records">
             <FileText size={18} color="#2563eb" />
-            <ButtonText className="ml-2">{t('tabs.records')}</ButtonText>
+            <ButtonText className="ml-2">{recordsLabel}</ButtonText>
           </Button>
         ) : null}
 
diff --git a/src/hooks/__tests__/use-record-type-name.test.ts b/src/hooks/__tests__/use-record-type-name.test.ts
new file mode 100644
index 00000000..9750d032
--- /dev/null
+++ b/src/hooks/__tests__/use-record-type-name.test.ts
@@ -0,0 +1,73 @@
+import { renderHook } from '@testing-library/react-native';
+
+import { terminologyStore } from '@/stores/terminology/store';
+
+import { recordTypeName, useRecordTypeName } from '../use-record-type-name';
+
+let mockCatalogNames: Record<string, string> = {};
+
+jest.mock('@/api/config/terminology', () => ({
+  getTerminology: jest.fn(),
+}));
+
+jest.mock('@/stores/records/store', () => ({
+  useRecordsStore: (selector: (state: unknown) => unknown) =>
+    selector({ entryFor: (definitionKey: string) => (mockCatalogNames[definitionKey] ? { DefinitionKey: definitionKey, Name: mockCatalogNames[definitionKey] } : null) }),
+}));
+
+const names = { 'record-type.run': 'Incident', 'record-type.work': 'Shift On Duty' };
+
+describe('recordTypeName', () => {
+  it("uses the department's name for a built-in definition", () => {
+    expect(recordTypeName(names, 'system.run', 1, 'Run')).toBe('Incident');
+  });
+
+  it('falls back to the record type number when a legacy record carries no definition key', () => {
+    expect(recordTypeName(names, null, 4, 'Work')).toBe('Shift On Duty');
+    expect(recordTypeName(names, undefined, 1, 'Run')).toBe('Incident');
+  });
+
+  it("never gives a department definition a built-in type's name, even when it carries a type number", () => {
+    expect(recordTypeName(names, 'dept.public-education', 1, 'Public Education')).toBe('Public Education');
+  });
+
+  it("falls back to the catalog's name when nothing was renamed", () => {
+    expect(recordTypeName({}, 'system.run', 1, 'Run')).toBe('Run');
+    expect(recordTypeName(names, null, null, 'Unknown')).toBe('Unknown');
+  });
+});
+
+describe('useRecordTypeName', () => {
+  beforeEach(() => {
+    mockCatalogNames = { 'dept.public-education': 'Public Education', 'system.run': 'Run' };
+    terminologyStore.setState({ names });
+  });
+
+  afterEach(() => {
+    terminologyStore.setState({ names: {} });
+  });
+
+  it("uses the department's name for a built-in definition", () => {
+    const { result, unmount } = renderHook(() => useRecordTypeName('system.run', 1));
+    expect(result.current).toBe('Incident');
+    unmount();
+  });
+
+  it("keeps a department definition's catalog name when it carries a type number", () => {
+    const { result, unmount } = renderHook(() => useRecordTypeName('dept.public-education', 1));
+    expect(result.current).toBe('Public Education');
+    unmount();
+  });
+
+  it('uses the record type number for a legacy record', () => {
+    const { result, unmount } = renderHook(() => useRecordTypeName(null, 4));
+    expect(result.current).toBe('Shift On Duty');
+    unmount();
+  });
+
+  it('is null when neither name is known', () => {
+    const { result, unmount } = renderHook(() => useRecordTypeName('dept.unknown', null));
+    expect(result.current).toBeNull();
+    unmount();
+  });
+});
diff --git a/src/hooks/__tests__/use-unit-subscriber-hash.test.ts b/src/hooks/__tests__/use-unit-subscriber-hash.test.ts
new file mode 100644
index 00000000..c8527942
--- /dev/null
+++ b/src/hooks/__tests__/use-unit-subscriber-hash.test.ts
@@ -0,0 +1,200 @@
+import { act, renderHook, waitFor } from '@testing-library/react-native';
+import { AxiosError, type AxiosResponse } from 'axios';
+
+import { getUnitSubscriberHash } from '@/api/novu/inbox';
+
+import { SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING, SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS, SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS, useUnitSubscriberHash } from '../use-unit-subscriber-hash';
+
+jest.mock('@/api/novu/inbox', () => ({
+  getUnitSubscriberHash: jest.fn(),
+}));
+
+jest.mock('@/lib/logging', () => ({
+  logger: { warn: jest.fn(), error: jest.fn(), info: jest.fn(), debug: jest.fn() },
+}));
+
+const mockGetUnitSubscriberHash = getUnitSubscriberHash as jest.MockedFunction<typeof getUnitSubscriberHash>;
+
+const httpError = (status: number): AxiosError => {
+  const response = { status, statusText: '', data: {}, headers: {}, config: {} as never } as AxiosResponse;
+  return new AxiosError('Request failed', 'ERR_BAD_RESPONSE', undefined, undefined, response);
+};
+
+const networkError = (): AxiosError => new AxiosError('Network Error', 'ERR_NETWORK');
+
+const hashFor = (unitId: string) => ({ Data: { UnitId: unitId, SubscriberHash: `unit-${unitId}-hash` } });
+
+describe('useUnitSubscriberHash', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('settles with the server-issued hash for the active unit', async () => {
+    mockGetUnitSubscriberHash.mockResolvedValue(hashFor('15'));
+
+    const { result, unmount } = renderHook(() => useUnitSubscriberHash('15'));
+
+    expect(result.current.settled).toBe(false);
+    await waitFor(() => expect(result.current.settled).toBe(true));
+    expect(result.current.subscriberHash).toBe('unit-15-hash');
+    expect(mockGetUnitSubscriberHash).toHaveBeenCalledWith('15');
+    unmount();
+  });
+
+  // An older server has no such endpoint, and until Novu enforces HMAC the inbox still opens without a hash.
+  it('settles without a hash, and does not retry, when the server has no such endpoint', async () => {
+    mockGetUnitSubscriberHash.mockRejectedValue(httpError(404));
+
+    const { result, unmount } = renderHook(() => useUnitSubscriberHash('15'));
+
+    await waitFor(() => expect(result.current.settled).toBe(true));
+    expect(result.current.subscriberHash).toBeUndefined();
+    expect(mockGetUnitSubscriberHash).toHaveBeenCalledTimes(1);
+    unmount();
+  });
+
+  it('does not report the previous unit as settled after a unit switch', async () => {
+    let resolveSecond: (value: { Data: { UnitId: string; SubscriberHash: string } }) => void = () => {};
+    mockGetUnitSubscriberHash.mockResolvedValueOnce(hashFor('15')).mockImplementationOnce(() => new Promise((resolve) => (resolveSecond = resolve)));
+
+    const { result, rerender, unmount } = renderHook(({ unitId }) => useUnitSubscriberHash(unitId), { initialProps: { unitId: '15' } });
+    await waitFor(() => expect(result.current.settled).toBe(true));
+
+    rerender({ unitId: '16' });
+
+    expect(result.current.settled).toBe(false);
+    expect(result.current.subscriberHash).toBeUndefined();
+
+    resolveSecond(hashFor('16'));
+    await waitFor(() => expect(result.current.subscriberHash).toBe('unit-16-hash'));
+    unmount();
+  });
+
+  it('does nothing without an active unit', () => {
+    const { result, unmount } = renderHook(() => useUnitSubscriberHash(null));
+
+    expect(result.current.settled).toBe(false);
+    expect(mockGetUnitSubscriberHash).not.toHaveBeenCalled();
+    unmount();
+  });
+
+  describe('a lookup that fails without an answer', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    const flush = async () => {
+      await act(async () => {
+        await Promise.resolve();
+      });
+    };
+
+    const advance = async (ms: number) => {
+      await act(async () => {
+        jest.advanceTimersByTime(ms);
+      });
+      await flush();
+    };
+
+    it('retries before settling, so a passing outage still opens the inbox with its hash', async () => {
+      mockGetUnitSubscriberHash.mockRejectedValueOnce(networkError()).mockResolvedValueOnce(hashFor('15'));
+
+      const { result, unmount } = renderHook(() => useUnitSubscriberHash('15'));
+      await flush();
+
+      expect(result.current.settled).toBe(false);
+      expect(mockGetUnitSubscriberHash).toHaveBeenCalledTimes(1);
+
+      await advance(SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS);
+
+      expect(mockGetUnitSubscriberHash).toHaveBeenCalledTimes(2);
+      expect(result.current.settled).toBe(true);
+      expect(result.current.subscriberHash).toBe('unit-15-hash');
+      unmount();
+    });
+
+    it('retries a server error the same way', async () => {
+      mockGetUnitSubscriberHash.mockRejectedValueOnce(httpError(503)).mockResolvedValueOnce(hashFor('15'));
+
+      const { result, unmount } = renderHook(() => useUnitSubscriberHash('15'));
+      await flush();
+      expect(result.current.settled).toBe(false);
+
+      await advance(SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS);
+
+      expect(result.current.subscriberHash).toBe('unit-15-hash');
+      unmount();
+    });
+
+    it('settles without a hash after a few attempts, then hands over a hash that arrives later', async () => {
+      mockGetUnitSubscriberHash.mockRejectedValue(networkError());
+
+      const { result, unmount } = renderHook(() => useUnitSubscriberHash('15'));
+      await flush();
+
+      // Backoff doubles: 2s, 4s, ...
+      for (let failures = 1; failures < SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING; failures++) {
+        expect(result.current.settled).toBe(false);
+        await advance(SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS * 2 ** (failures - 1));
+      }
+
+      expect(mockGetUnitSubscriberHash).toHaveBeenCalledTimes(SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING);
+      expect(result.current.settled).toBe(true);
+      expect(result.current.subscriberHash).toBeUndefined();
+
+      mockGetUnitSubscriberHash.mockResolvedValueOnce(hashFor('15'));
+      await advance(SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS * 2 ** (SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING - 1));
+
+      expect(mockGetUnitSubscriberHash).toHaveBeenCalledTimes(SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING + 1);
+      expect(result.current.settled).toBe(true);
+      expect(result.current.subscriberHash).toBe('unit-15-hash');
+      unmount();
+    });
+
+    it('caps the backoff', async () => {
+      mockGetUnitSubscriberHash.mockRejectedValue(networkError());
+
+      const { unmount } = renderHook(() => useUnitSubscriberHash('15'));
+      await flush();
+
+      // Run until the doubling delay passes the cap.
+      let delay = SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS;
+      while (delay < SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS) {
+        await advance(delay);
+        delay *= 2;
+      }
+      const calls = mockGetUnitSubscriberHash.mock.calls.length;
+
+      await advance(SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS);
+
+      expect(mockGetUnitSubscriberHash).toHaveBeenCalledTimes(calls + 1);
+      unmount();
+    });
+
+    it('stops retrying when the unit changes or the hook unmounts', async () => {
+      mockGetUnitSubscriberHash.mockRejectedValue(networkError());
+
+      const { rerender, unmount } = renderHook(({ unitId }) => useUnitSubscriberHash(unitId), { initialProps: { unitId: '15' } });
+      await flush();
+
+      mockGetUnitSubscriberHash.mockResolvedValue(hashFor('16'));
+      rerender({ unitId: '16' });
+      await flush();
+      await advance(SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS);
+
+      expect(mockGetUnitSubscriberHash.mock.calls.map(([unitId]) => unitId)).toEqual(['15', '16']);
+
+      mockGetUnitSubscriberHash.mockRejectedValue(networkError());
+      rerender({ unitId: '17' });
+      await flush();
+      unmount();
+      await advance(SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS);
+
+      expect(mockGetUnitSubscriberHash.mock.calls.map(([unitId]) => unitId)).toEqual(['15', '16', '17']);
+    });
+  });
+});
diff --git a/src/hooks/use-record-type-name.ts b/src/hooks/use-record-type-name.ts
new file mode 100644
index 00000000..0eb4fb12
--- /dev/null
+++ b/src/hooks/use-record-type-name.ts
@@ -0,0 +1,18 @@
+import { useRecordsStore } from '@/stores/records/store';
+import { definitionTermKey, recordTypeTermKey, useTerm } from '@/stores/terminology/store';
+
+// A built-in definition's key, else its legacy record type number (a legacy record may carry only the number). A
+// department definition never falls back to the number: its own name is the catalog's, not a built-in type's.
+const termKeyFor = (definitionKey?: string | null, recordType?: number | null) => (definitionKey ? definitionTermKey(definitionKey) : recordTypeTermKey(recordType));
+
+/** Non-reactive: a record type's name as the department calls it, else `fallback` (the catalog's own name). */
+export const recordTypeName = (names: Record<string, string>, definitionKey: string | null | undefined, recordType: number | null | undefined, fallback: string): string => {
+  const key = termKeyFor(definitionKey, recordType);
+  return (key ? names[key] : undefined) || fallback;
+};
+
+/** Reactive: the department's name for a record's type, else the catalog's; null when neither is known. */
+export const useRecordTypeName = (definitionKey?: string | null, recordType?: number | null): string | null => {
+  const catalogName = useRecordsStore((state) => (definitionKey ? state.entryFor(definitionKey)?.Name : undefined));
+  return useTerm(termKeyFor(definitionKey, recordType), catalogName ?? '') || null;
+};
diff --git a/src/hooks/use-unit-subscriber-hash.ts b/src/hooks/use-unit-subscriber-hash.ts
new file mode 100644
index 00000000..94047e94
--- /dev/null
+++ b/src/hooks/use-unit-subscriber-hash.ts
@@ -0,0 +1,80 @@
+import { isAxiosError } from 'axios';
+import { useEffect, useState } from 'react';
+
+import { getUnitSubscriberHash } from '@/api/novu/inbox';
+import { logger } from '@/lib/logging';
+
+/** First retry delay for a lookup that failed without an answer; each later one doubles, up to the max. */
+export const SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS = 2000;
+export const SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS = 5 * 60 * 1000;
+/** Failed lookups before the inbox opens without a hash anyway; the retries carry on behind it. */
+export const SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING = 3;
+
+/**
+ * The server answered, and asking again cannot change that: an older server has no such endpoint (404), or it
+ * refuses this unit. A failure with no answer (offline, a timeout, a 5xx, rate limiting) is worth retrying.
+ */
+const isDefinitiveFailure = (error: unknown): boolean => {
+  const status = isAxiosError(error) ? error.response?.status : undefined;
+  return status !== undefined && status >= 400 && status < 500 && status !== 408 && status !== 429;
+};
+
+/**
+ * The Novu subscriberHash for the active unit's inbox. Novu refuses an inbox session without it once HMAC is
+ * enforced on the environment, and only the server can make it.
+ *
+ * `settled` turns true for a unit once its fetch has an outcome, so the inbox is opened once with the hash instead
+ * of first without it and again with it. A definitive failure (an older server has no such endpoint) settles without
+ * a hash straight away: the inbox still opens while Novu does not enforce HMAC. A failure with no answer is retried
+ * with backoff and only settles without a hash after a few attempts, so the inbox is not held back forever. The
+ * retries carry on after that, and a hash that arrives later replaces the missing one in the open inbox.
+ */
+export const useUnitSubscriberHash = (unitId: string | null | undefined) => {
+  const [fetched, setFetched] = useState<{ unitId: string; hash?: string } | null>(null);
+
+  useEffect(() => {
+    if (!unitId) {
+      return;
+    }
+
+    let cancelled = false;
+    let retryTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const attempt = (failures: number) => {
+      getUnitSubscriberHash(unitId)
+        .then((result) => {
+          if (!cancelled) {
+            setFetched({ unitId, hash: result?.Data?.SubscriberHash ?? undefined });
+          }
+        })
+        .catch((error) => {
+          if (cancelled) {
+            return;
+          }
+
+          const failed = failures + 1;
+          const definitive = isDefinitiveFailure(error);
+          logger.warn({ message: 'Could not fetch the unit inbox subscriber hash', context: { unitId, attempt: failed, willRetry: !definitive, error } });
+
+          if (definitive || failed === SUBSCRIBER_HASH_ATTEMPTS_BEFORE_SETTLING) {
+            setFetched({ unitId });
+          }
+
+          if (!definitive) {
+            retryTimer = setTimeout(() => attempt(failed), Math.min(SUBSCRIBER_HASH_RETRY_BASE_DELAY_MS * 2 ** failures, SUBSCRIBER_HASH_RETRY_MAX_DELAY_MS));
+          }
+        });
+    };
+
+    attempt(0);
+
+    return () => {
+      cancelled = true;
+      clearTimeout(retryTimer);
+    };
+  }, [unitId]);
+
+  const settled = !!unitId && fetched?.unitId === unitId;
+
+  return { settled, subscriberHash: settled ? fetched?.hash : undefined };
+};
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 0c9aa342..f054d682 100644
--- a/src/lib/__tests__/call-field-policy.test.ts
+++ b/src/lib/__tests__/call-field-policy.test.ts
@@ -2,6 +2,7 @@ import { AxiosError, AxiosHeaders } from 'axios';
 
 import {
   CALL_FIELD_LABEL_KEYS,
+  findCallType,
   formatCallFieldLabels,
   formatCallGeolocation,
   getEditCallFieldValues,
@@ -87,6 +88,32 @@ describe('call field policy helpers', () => {
     expect(isPendingCallState(undefined)).toBe(false);
   });
 
+  describe('findCallType', () => {
+    const callTypes = [
+      { Id: '3', Name: 'Structure Fire' },
+      { Id: '7', Name: 'Medical' },
+    ];
+
+    it('finds the type by TypeId, so a renamed type still matches', () => {
+      expect(findCallType(callTypes, { Type: 'Fire (old name)', TypeId: '3' })?.Name).toBe('Structure Fire');
+    });
+
+    it('falls 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('falls back to the type text when the TypeId matches none of the types', () => {
+      expect(findCallType(callTypes, { Type: 'Medical', TypeId: '99' })?.Name).toBe('Medical');
+    });
+
+    it('returns undefined when nothing matches', () => {
+      expect(findCallType(callTypes, { Type: 'Unknown Type' })).toBeUndefined();
+      expect(findCallType(null, { Type: 'Medical' })).toBeUndefined();
+      expect(findCallType(callTypes, null)).toBeUndefined();
+    });
+  });
+
   it('treats an empty dispatch selection as no recipients', () => {
     expect(hasDispatchRecipients(NO_DISPATCH)).toBe(false);
     expect(hasDispatchRecipients(null)).toBe(false);
diff --git a/src/lib/__tests__/unit-status-set.test.ts b/src/lib/__tests__/unit-status-set.test.ts
new file mode 100644
index 00000000..c04ec434
--- /dev/null
+++ b/src/lib/__tests__/unit-status-set.test.ts
@@ -0,0 +1,64 @@
+import { findCurrentUnitStatusOption, findUnitStatusSet } from '@/lib/unit-status-set';
+
+describe('unit status set', () => {
+  const builtIn = { UnitType: '0', StatusId: '', Statuses: [] };
+  const engineSet = { UnitType: 'Engine', StatusId: '12', Statuses: [] };
+  const ladderSet = { UnitType: 'Ladder', StatusId: '15', Statuses: [] };
+  const unitStatuses = [builtIn, engineSet, ladderSet];
+
+  describe('findUnitStatusSet', () => {
+    it('finds the set by the unit custom status set id, so a renamed unit type still resolves', () => {
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Engine (renamed)', CustomStatusSetId: '12' })).toBe(engineSet);
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Engine', CustomStatusSetId: 15 })).toBe(ladderSet);
+    });
+
+    it('falls back to the unit type name when no set id is sent (older servers) or it is the built-in 0', () => {
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Engine' })).toBe(engineSet);
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Engine', CustomStatusSetId: '' })).toBe(engineSet);
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Engine', CustomStatusSetId: '0' })).toBe(engineSet);
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Engine', CustomStatusSetId: null })).toBe(engineSet);
+    });
+
+    it('falls back to the unit type name when the set id matches no listed set', () => {
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Ladder', CustomStatusSetId: '99' })).toBe(ladderSet);
+    });
+
+    it('returns null when the unit has no custom set, leaving the built-in statuses to the caller', () => {
+      expect(findUnitStatusSet(unitStatuses, { Type: 'Tanker', CustomStatusSetId: '0' })).toBeNull();
+      expect(findUnitStatusSet(unitStatuses, { Type: '', CustomStatusSetId: '' })).toBeNull();
+      expect(findUnitStatusSet(unitStatuses, { Type: null })).toBeNull();
+      expect(findUnitStatusSet(null, { Type: 'Engine' })).toBeNull();
+      expect(findUnitStatusSet(unitStatuses, null)).toBeNull();
+    });
+  });
+
+  describe('findCurrentUnitStatusOption', () => {
+    const statuses = [
+      { Id: 0, Text: 'Available' },
+      { Id: 3, Text: 'Committed' },
+      { Id: 7, Text: 'Responding' },
+    ];
+
+    it('matches the option by the status option id, even when its text has changed', () => {
+      expect(findCurrentUnitStatusOption(statuses, { StateId: 7, State: 'En Route' })).toBe(statuses[2]);
+      expect(findCurrentUnitStatusOption(statuses, { StateId: '3', State: 'Committed' })).toBe(statuses[1]);
+    });
+
+    it('matches on the status text when no option id is sent (older servers)', () => {
+      expect(findCurrentUnitStatusOption(statuses, { State: 'Responding' })).toBe(statuses[2]);
+      expect(findCurrentUnitStatusOption(statuses, { StateId: null, State: 'Committed' })).toBe(statuses[1]);
+    });
+
+    it('only trusts a 0 id through the text, since a unit with no status reports 0 too', () => {
+      expect(findCurrentUnitStatusOption(statuses, { StateId: 0, State: 'Available' })).toBe(statuses[0]);
+      expect(findCurrentUnitStatusOption(statuses, { StateId: 0, State: 'Unknown' })).toBeNull();
+    });
+
+    it('falls back to the text when the id is not in the set, and returns null when nothing matches', () => {
+      expect(findCurrentUnitStatusOption(statuses, { StateId: 42, State: 'Committed' })).toBe(statuses[1]);
+      expect(findCurrentUnitStatusOption(statuses, { StateId: 42, State: 'Out of Service' })).toBeNull();
+      expect(findCurrentUnitStatusOption(null, { State: 'Available' })).toBeNull();
+      expect(findCurrentUnitStatusOption(statuses, null)).toBeNull();
+    });
+  });
+});
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 6ab1de42..8e9addaa 100644
--- a/src/lib/call-field-policy.ts
+++ b/src/lib/call-field-policy.ts
@@ -145,6 +145,24 @@ const PENDING_CALL_STATE = 8;
 
 export const isPendingCallState = (state: unknown): boolean => (typeof state === 'number' || typeof state === 'string') && Number(state) === PENDING_CALL_STATE;
 
+/**
+ * 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);
+};
+
 /** "Anyone selected?" — an empty selection is a blank dispatch list. */
 export const hasDispatchRecipients = (selection?: DispatchSelection | null): boolean =>
   !!selection && (selection.everyone || selection.users.length > 0 || selection.groups.length > 0 || selection.roles.length > 0 || selection.units.length > 0);
diff --git a/src/lib/unit-status-set.ts b/src/lib/unit-status-set.ts
new file mode 100644
index 00000000..abc08a7a
--- /dev/null
+++ b/src/lib/unit-status-set.ts
@@ -0,0 +1,72 @@
+/**
+ * Which status set (a GetAllUnitStatuses entry) a unit uses, and which of its options is the unit's current status.
+ *
+ * GetAllUnitStatuses lists the built-in statuses under UnitType '0' and then one entry per unit type that has a custom
+ * status set, keyed by the unit type's NAME (`UnitType`) and the set's id (`StatusId`). A unit carries its unit type's
+ * set id as `CustomStatusSetId` ('0' / empty when it uses the built-in statuses), which still finds the set after the
+ * unit type is renamed, so it is matched first and the name second.
+ */
+
+interface UnitStatusSetLike {
+  UnitType: string;
+  StatusId?: string | number | null;
+}
+
+interface UnitStatusSetOwner {
+  Type?: string | null;
+  CustomStatusSetId?: string | number | null;
+}
+
+interface StatusOptionLike {
+  Id: number | string;
+  Text: string;
+}
+
+interface CurrentUnitStatusLike {
+  /** Id of the current status option (StatusesResultData.Id); 0 / missing on older servers. */
+  StateId?: number | string | null;
+  /** The current status's text. */
+  State?: string | null;
+}
+
+const toId = (value: number | string | null | undefined): string => (value == null ? '' : String(value).trim());
+
+/**
+ * The custom status set the unit uses: by its `CustomStatusSetId`, then by its unit type name. Null when it has none,
+ * in which case the unit uses the built-in statuses (the UnitType '0' entry).
+ */
+export const findUnitStatusSet = <T extends UnitStatusSetLike>(unitStatuses: readonly T[] | null | undefined, unit: UnitStatusSetOwner | null | undefined): T | null => {
+  if (!unitStatuses || !unit) {
+    return null;
+  }
+
+  const setId = toId(unit.CustomStatusSetId);
+  if (setId !== '' && setId !== '0') {
+    const bySetId = unitStatuses.find((set) => toId(set.StatusId) === setId);
+    if (bySetId) {
+      return bySetId;
+    }
+  }
+
+  if (!unit.Type) {
+    return null;
+  }
+
+  return unitStatuses.find((set) => set.UnitType === unit.Type) ?? null;
+};
+
+/**
+ * The option in a status set that is the unit's current status: the option whose `Id` is the status's `StateId`, then
+ * (older servers, which send no StateId) the option with the status's text. A StateId of 0 is only trusted through the
+ * text: 0 is a real built-in option id, but a unit with no status yet reports 0 as well.
+ */
+export const findCurrentUnitStatusOption = <T extends StatusOptionLike>(statuses: readonly T[] | null | undefined, current: CurrentUnitStatusLike | null | undefined): T | null => {
+  if (!statuses || !current) {
+    return null;
+  }
+
+  const stateId = toId(current.StateId);
+  const byId = stateId !== '' && stateId !== '0' ? statuses.find((status) => toId(status.Id) === stateId) : undefined;
+
+  return byId ?? statuses.find((status) => status.Text === current.State) ?? 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 3c7b1eab..0824c329 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..f6095b16
--- /dev/null
+++ b/src/models/v4/device/nativePushUnRegistrationInput.ts
@@ -0,0 +1,6 @@
+/** Takes a native (iOS or Android) push token off the unit it was registered on (Core v4 Devices/UnRegisterNativePush). */
+export class NativePushUnRegistrationInput {
+  public Token: string = '';
+  public Prefix: string = '';
+  public UnitId: 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__/app-reset.service.test.ts b/src/services/__tests__/app-reset.service.test.ts
index 9f785258..049d5cdc 100644
--- a/src/services/__tests__/app-reset.service.test.ts
+++ b/src/services/__tests__/app-reset.service.test.ts
@@ -176,6 +176,13 @@ jest.mock('@/stores/feature-flags/store', () => ({
   },
 }));
 
+jest.mock('@/stores/terminology/store', () => ({
+  terminologyStore: {
+    setState: jest.fn(),
+    getState: jest.fn(() => ({})),
+  },
+}));
+
 jest.mock('@/stores/status/store', () => ({
   useStatusBottomSheetStore: {
     setState: jest.fn(),
@@ -312,6 +319,7 @@ const mockRecordsReset = jest.fn();
 const mockDeploymentsReset = jest.fn();
 const mockPreplanReset = jest.fn();
 const mockSiteInfoReset = jest.fn();
+const mockTerminologyReset = jest.fn();
 
 describe('app-reset.service', () => {
   beforeEach(() => {
@@ -366,6 +374,7 @@ describe('app-reset.service', () => {
     jest.requireMock('@/stores/records/deployments-store').useDeploymentsStore.getState.mockReturnValue({ reset: mockDeploymentsReset });
     jest.requireMock('@/stores/contacts/preplan-store').useContactPreplanStore.getState.mockReturnValue({ reset: mockPreplanReset });
     jest.requireMock('@/stores/calls/site-info-store').useSiteInfoStore.getState.mockReturnValue({ reset: mockSiteInfoReset });
+    jest.requireMock('@/stores/terminology/store').terminologyStore.getState.mockReturnValue({ reset: mockTerminologyReset });
 
     locationService.stopLocationUpdates.mockResolvedValue(undefined);
     signalRService.disconnectAll.mockResolvedValue(undefined);
@@ -657,6 +666,8 @@ describe('app-reset.service', () => {
       expect(useUnitsStore.setState).toHaveBeenCalledWith(INITIAL_UNITS_STATE);
       // Logout must clear flags, resolution and identity so the next session fails closed.
       expect(featureFlagsStore.setState).toHaveBeenCalledWith(INITIAL_FEATURE_FLAGS_STATE);
+      // The department's own names must not label the next session's screens, nor a fetch still in flight restore them.
+      expect(mockTerminologyReset).toHaveBeenCalled();
       expect(mockStatusReset).toHaveBeenCalled();
       expect(mockOfflineQueueClear).toHaveBeenCalled();
       expect(mockLoadingReset).toHaveBeenCalled();
diff --git a/src/services/__tests__/push-notification-hook.test.ts b/src/services/__tests__/push-notification-hook.test.ts
index b8961ee8..00966975 100644
--- a/src/services/__tests__/push-notification-hook.test.ts
+++ b/src/services/__tests__/push-notification-hook.test.ts
@@ -64,6 +64,10 @@ jest.mock('@/lib/storage/app', () => ({
   getBaseApiUrl: jest.fn(() => mockBaseApiUrl),
 }));
 
+// The service sends the app header on its sign-out call; the real module reads MMKV storage,
+// which the minimal react-native stub above cannot construct.
+jest.mock('@/lib/mfa/client-app', () => ({ CLIENT_HEADER: 'X-Resgrid-Client', RESGRID_CLIENT: 'unit' }));
+
 jest.mock('@/lib/storage/notification-prefs', () => ({
   getModernNotificationSoundsEnabled: jest.fn(() => true),
   getAppliedNotificationSoundMode: jest.fn(() => undefined),
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..c22b43e0
--- /dev/null
+++ b/src/services/__tests__/push-notification-sign-out.test.ts
@@ -0,0 +1,346 @@
+import * as Notifications from 'expo-notifications';
+
+import { registerUnitDevice, unRegisterNativePush } from '@/api/devices/push';
+import { runSignOutHooks } from '@/lib/auth/sign-out-hooks';
+import { logger } from '@/lib/logging';
+
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'ios',
+    select: jest.fn((options: { ios?: unknown; default?: unknown }) => options.ios ?? options.default),
+  },
+}));
+
+jest.mock('expo-device', () => ({ isDevice: true }));
+
+jest.mock('expo-notifications', () => ({
+  setNotificationHandler: jest.fn(),
+  addNotificationReceivedListener: jest.fn(() => ({ remove: jest.fn() })),
+  addNotificationResponseReceivedListener: jest.fn(() => ({ remove: jest.fn() })),
+  getLastNotificationResponseAsync: jest.fn(() => Promise.resolve(null)),
+  getPermissionsAsync: jest.fn(() => Promise.resolve({ status: 'granted' })),
+  requestPermissionsAsync: jest.fn(() => Promise.resolve({ status: 'granted' })),
+  getDevicePushTokenAsync: jest.fn(() => Promise.resolve({ data: 'native-token' })),
+  setBadgeCountAsync: jest.fn(() => Promise.resolve(true)),
+  dismissAllNotificationsAsync: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock('@notifee/react-native', () => ({
+  __esModule: true,
+  default: {
+    createChannel: jest.fn(() => Promise.resolve()),
+    deleteChannel: jest.fn(() => Promise.resolve()),
+    setNotificationCategories: jest.fn(() => Promise.resolve()),
+    requestPermission: jest.fn(() => Promise.resolve({ authorizationStatus: 1 })),
+    cancelAllNotifications: jest.fn(() => Promise.resolve()),
+    onForegroundEvent: jest.fn(() => jest.fn()),
+    onBackgroundEvent: jest.fn(),
+  },
+  AndroidImportance: { HIGH: 4, DEFAULT: 3 },
+  AndroidVisibility: { PUBLIC: 1 },
+  AuthorizationStatus: { AUTHORIZED: 1, DENIED: 2 },
+  EventType: { PRESS: 1, ACTION_PRESS: 2 },
+}));
+
+jest.mock('@/stores/auth/store', () => {
+  const state = { status: 'signedIn', accessToken: 'access-token' };
+  const store = Object.assign(
+    jest.fn((selector?: (current: typeof state) => unknown) => (selector ? selector(state) : state)),
+    { getState: () => state }
+  );
+  return { __esModule: true, default: store };
+});
+
+jest.mock('@/stores/push-notification/store', () => ({
+  isSafeRouteId: jest.fn(() => true),
+  parseNotificationData: jest.fn(() => ({ type: 'unknown' })),
+  usePushNotificationModalStore: { getState: jest.fn(() => ({ showNotificationModal: jest.fn() })) },
+}));
+
+jest.mock('@/stores/app/core-store', () => ({ useCoreStore: { getState: jest.fn(() => ({})) } }));
+
+jest.mock('@/stores/app/location-store', () => ({ useLocationStore: { getState: jest.fn(() => ({})) } }));
+
+jest.mock('@/stores/check-in-timers/store', () => ({ useCheckInTimerStore: { getState: jest.fn(() => ({ performCheckIn: jest.fn() })) } }));
+
+jest.mock('@/stores/security/store', () => ({ securityStore: jest.fn(() => null) }));
+
+jest.mock('@/lib/navigation', () => ({ routerPushWithRetry: jest.fn(() => Promise.resolve()) }));
+
+jest.mock('@/lib/storage/notification-prefs', () => ({
+  getModernNotificationSoundsEnabled: jest.fn(() => true),
+  getAppliedNotificationSoundMode: jest.fn(() => undefined),
+  setAppliedNotificationSoundMode: jest.fn(),
+}));
+
+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: 'unit' }));
+
+jest.mock('@/lib/storage/app', () => ({
+  getOrCreateDeviceUuid: jest.fn(() => 'device-uuid'),
+  getBaseApiUrl: jest.fn(() => 'https://api.example/api/v4'),
+}));
+
+jest.mock('@/api/devices/push', () => ({
+  registerUnitDevice: jest.fn(() => Promise.resolve({ Status: 'queued' })),
+  unRegisterNativePush: jest.fn(() => Promise.resolve({ Status: 'success' })),
+}));
+
+describe('push notification sign-out', () => {
+  const originalFetch = global.fetch;
+  let fetchMock: jest.Mock;
+  let pushNotificationService: {
+    registerForPushNotifications: (unitId: string, code: string) => Promise<string | null>;
+    unregisterFromPushNotifications: () => Promise<void>;
+  };
+
+  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 unit as the signing-out session', async () => {
+    await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+    expect(registerUnitDevice).toHaveBeenCalledWith(expect.objectContaining({ UnitId: '42', 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({ 'Content-Type': 'application/json', Authorization: 'Bearer access-token', 'X-Resgrid-Client': 'unit' }));
+    expect(JSON.parse(init.body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '42' });
+  });
+
+  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('42', '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('42', '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('42', 'DEPT');
+    fetchMock.mockImplementationOnce(() => Promise.resolve({ ok: false, status: 400 }));
+    await expect(runSignOutHooks('access-token')).resolves.toBeUndefined();
+
+    await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+    fetchMock.mockImplementationOnce(() => Promise.reject(new Error('offline')));
+    await expect(runSignOutHooks('access-token')).resolves.toBeUndefined();
+
+    expect(logger.warn).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not remember a registration the server never accepted', async () => {
+    (registerUnitDevice as jest.Mock).mockRejectedValueOnce(new Error('offline'));
+
+    await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  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('42', 'DEPT');
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('forgets the registration when the local push state is reset', async () => {
+    await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+
+    await pushNotificationService.unregisterFromPushNotifications();
+    await runSignOutHooks('access-token');
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  describe('signing out while a registration is in flight', () => {
+    const settle = async (condition: () => boolean) => {
+      for (let i = 0; i < 100 && !condition(); i++) {
+        await Promise.resolve();
+      }
+    };
+
+    it('takes a registration that lands after sign-out off as the signed-out session, and never restores it', async () => {
+      let resolveRegistration: (value: { Status: string }) => void = () => {};
+      (registerUnitDevice as jest.Mock).mockImplementationOnce(() => new Promise((resolve) => (resolveRegistration = resolve)));
+
+      const registering = pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      await settle(() => (registerUnitDevice as jest.Mock).mock.calls.length > 0);
+
+      await runSignOutHooks('signed-out-token');
+      expect(fetchMock).not.toHaveBeenCalled();
+
+      resolveRegistration({ Status: 'queued' });
+      await expect(registering).resolves.toBeNull();
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const [url, init] = fetchMock.mock.calls[0];
+      expect(url).toBe('https://api.example/api/v4/Devices/UnRegisterNativePush');
+      expect(init.headers).toEqual(expect.objectContaining({ Authorization: 'Bearer signed-out-token' }));
+      expect(JSON.parse(init.body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '42' });
+
+      // Not restored: the next sign-out has nothing to take off.
+      fetchMock.mockClear();
+      await runSignOutHooks('access-token');
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('warns when a registration lands after a sign-out that had no access token', async () => {
+      let resolveRegistration: (value: { Status: string }) => void = () => {};
+      (registerUnitDevice as jest.Mock).mockImplementationOnce(() => new Promise((resolve) => (resolveRegistration = resolve)));
+
+      const registering = pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      await settle(() => (registerUnitDevice as jest.Mock).mock.calls.length > 0);
+
+      await runSignOutHooks(null);
+      resolveRegistration({ Status: 'queued' });
+
+      await expect(registering).resolves.toBeNull();
+      expect(fetchMock).not.toHaveBeenCalled();
+      expect(logger.warn).toHaveBeenCalledWith(expect.objectContaining({ message: 'Push: a registration that landed after sign-out could not be taken off' }));
+    });
+
+    it('does not register at all when sign-out comes before the request is sent', async () => {
+      let resolveToken: (value: { data: string }) => void = () => {};
+      (Notifications.getDevicePushTokenAsync as jest.Mock).mockImplementationOnce(() => new Promise((resolve) => (resolveToken = resolve)));
+
+      const registering = pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      await settle(() => (Notifications.getDevicePushTokenAsync as jest.Mock).mock.calls.length > 0);
+
+      await runSignOutHooks('access-token');
+      resolveToken({ data: 'native-token' });
+
+      await expect(registering).resolves.toBeNull();
+      expect(registerUnitDevice).not.toHaveBeenCalled();
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('switching units', () => {
+    it('takes the token off the unit the phone left, after the new unit is registered', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      await pushNotificationService.registerForPushNotifications('43', 'DEPT');
+
+      expect(unRegisterNativePush).toHaveBeenCalledTimes(1);
+      expect(unRegisterNativePush).toHaveBeenCalledWith({ Token: 'native-token', Prefix: 'DEPT', UnitId: '42' });
+      const registeredNew = (registerUnitDevice as jest.Mock).mock.invocationCallOrder[1];
+      const removedOld = (unRegisterNativePush as jest.Mock).mock.invocationCallOrder[0];
+      expect(registeredNew).toBeLessThan(removedOld);
+
+      // Sign-out then takes the token off the unit the phone is on now.
+      await runSignOutHooks('access-token');
+      expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '43' });
+    });
+
+    it('leaves the unit alone when the same unit registers again', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+
+      expect(unRegisterNativePush).not.toHaveBeenCalled();
+    });
+
+    it('takes the token off the old department when the unit moves to another one', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      await pushNotificationService.registerForPushNotifications('42', 'OTHER');
+
+      expect(unRegisterNativePush).toHaveBeenCalledWith({ Token: 'native-token', Prefix: 'DEPT', UnitId: '42' });
+    });
+
+    it('keeps the old unit when the new unit could not be registered', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      (registerUnitDevice as jest.Mock).mockRejectedValueOnce(new Error('offline'));
+
+      await pushNotificationService.registerForPushNotifications('43', 'DEPT');
+
+      expect(unRegisterNativePush).not.toHaveBeenCalled();
+      await runSignOutHooks('access-token');
+      expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '42' });
+    });
+
+    it('keeps the new registration when the old unit could not be cleared, and takes both off at sign-out', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      (unRegisterNativePush as jest.Mock).mockRejectedValueOnce(new Error('offline'));
+
+      await expect(pushNotificationService.registerForPushNotifications('43', 'DEPT')).resolves.toBe('native-token');
+
+      expect(logger.warn).toHaveBeenCalledWith(expect.objectContaining({ message: 'Push: the token could not be unregistered from the previous unit' }));
+      await runSignOutHooks('access-token');
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+      expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '43' });
+      expect(JSON.parse(fetchMock.mock.calls[1][1].body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '42' });
+    });
+
+    it('retries an old unit the server did not clear on the next registration', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      (unRegisterNativePush as jest.Mock).mockResolvedValueOnce({ Status: 'failure' });
+      await pushNotificationService.registerForPushNotifications('43', 'DEPT');
+
+      await pushNotificationService.registerForPushNotifications('44', 'DEPT');
+
+      // 42 failed, then 42 (retried) and 43 both cleared.
+      expect((unRegisterNativePush as jest.Mock).mock.calls.map(([input]) => input.UnitId)).toEqual(['42', '42', '43']);
+
+      // Nothing left pending: sign-out only takes the current unit off.
+      await runSignOutHooks('access-token');
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ Token: 'native-token', Prefix: 'DEPT', UnitId: '44' });
+    });
+
+    it('does not take the token off a pending old unit the phone has come back to', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      (unRegisterNativePush as jest.Mock).mockRejectedValueOnce(new Error('offline'));
+      await pushNotificationService.registerForPushNotifications('43', 'DEPT');
+      (unRegisterNativePush as jest.Mock).mockClear();
+
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+
+      expect(unRegisterNativePush).toHaveBeenCalledTimes(1);
+      expect(unRegisterNativePush).toHaveBeenCalledWith({ Token: 'native-token', Prefix: 'DEPT', UnitId: '43' });
+    });
+
+    it('warns when the server reports it could not clear the old unit', async () => {
+      await pushNotificationService.registerForPushNotifications('42', 'DEPT');
+      (unRegisterNativePush as jest.Mock).mockResolvedValueOnce({ Status: 'failure' });
+
+      await pushNotificationService.registerForPushNotifications('43', 'DEPT');
+
+      expect(logger.warn).toHaveBeenCalledWith(expect.objectContaining({ message: 'Push: the server did not unregister the token from the previous unit' }));
+    });
+  });
+});
diff --git a/src/services/__tests__/push-notification.test.ts b/src/services/__tests__/push-notification.test.ts
index 503ea47a..f4292409 100644
--- a/src/services/__tests__/push-notification.test.ts
+++ b/src/services/__tests__/push-notification.test.ts
@@ -53,6 +53,10 @@ jest.mock('@/lib/storage/app', () => ({
   getBaseApiUrl: jest.fn(() => 'https://api.test/api/v4'),
 }));
 
+// The service sends the app header on its sign-out call; the real module reads MMKV storage,
+// which the minimal react-native stub above cannot construct.
+jest.mock('@/lib/mfa/client-app', () => ({ CLIENT_HEADER: 'X-Resgrid-Client', RESGRID_CLIENT: 'unit' }));
+
 jest.mock('@/api/devices/push', () => ({
   registerUnitDevice: jest.fn(),
 }));
diff --git a/src/services/app-reset.service.ts b/src/services/app-reset.service.ts
index d5485755..42898b93 100644
--- a/src/services/app-reset.service.ts
+++ b/src/services/app-reset.service.ts
@@ -43,6 +43,7 @@ import { useRoutesStore } from '@/stores/routes/store';
 import { securityStore } from '@/stores/security/store';
 import { useSignalRStore } from '@/stores/signalr/signalr-store';
 import { useStatusBottomSheetStore } from '@/stores/status/store';
+import { terminologyStore } from '@/stores/terminology/store';
 import { useUnitsStore } from '@/stores/units/store';
 import { useWeatherAlertsStore } from '@/stores/weather-alerts/store';
 
@@ -296,6 +297,10 @@ export const resetAllStores = async (): Promise<void> => {
   // resolves, instead of gating on the previous identity's flags.
   featureFlagsStore.setState(INITIAL_FEATURE_FLAGS_STATE);
 
+  // The department's own module and record-type names must not label the next session's screens. reset() also drops
+  // the answer of a fetch still in flight, which would otherwise bring them back.
+  terminologyStore.getState().reset();
+
   // Stores with existing reset/clear methods
   useStatusBottomSheetStore.getState().reset();
   useOfflineQueueStore.getState().clearAllEvents();
diff --git a/src/services/push-notification.ts b/src/services/push-notification.ts
index 63056e60..e7ccd1dc 100644
--- a/src/services/push-notification.ts
+++ b/src/services/push-notification.ts
@@ -5,11 +5,14 @@ import type { Href } from 'expo-router';
 import { useEffect, useRef } from 'react';
 import { Platform } from 'react-native';
 
-import { registerUnitDevice } from '@/api/devices/push';
+import { registerUnitDevice, unRegisterNativePush } from '@/api/devices/push';
+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 { getBaseApiUrl, getOrCreateDeviceUuid } from '@/lib/storage/app';
 import { getAppliedNotificationSoundMode, getModernNotificationSoundsEnabled, setAppliedNotificationSoundMode } from '@/lib/storage/notification-prefs';
+import { type NativePushUnRegistrationInput } from '@/models/v4/device/nativePushUnRegistrationInput';
 import { useCoreStore } from '@/stores/app/core-store';
 import { useLocationStore } from '@/stores/app/location-store';
 import useAuthStore from '@/stores/auth/store';
@@ -156,9 +159,26 @@ const ANDROID_SOUND_CHANNELS: AndroidSoundChannel[] = [
   { id: 'message', name: 'Message', description: 'Messages', vibration: false, modernSound: 'modernmessage', classicSound: 'newmessage' },
 ];
 
+interface PushSession {
+  /** Set at sign-out: the access token and server the session signed out with. */
+  signOut?: { accessToken: string | null; apiUrl: string };
+}
+
+const isSameRegistration = (a: NativePushUnRegistrationInput, b: NativePushUnRegistrationInput): boolean => a.Token === b.Token && a.Prefix === b.Prefix && a.UnitId === b.UnitId;
+
 class PushNotificationService {
   private static instance: PushNotificationService;
   private pushToken: string | null = null;
+  /** What the server has registered for this phone (token, department and unit), so sign-out can take it back off. */
+  private registration: NativePushUnRegistrationInput | null = null;
+  /** Units the phone left whose removal the server has not confirmed: retried on the next registration and at sign-out. */
+  private staleRegistrations: NativePushUnRegistrationInput[] = [];
+  /**
+   * The signed-in session registrations belong to. Sign-out replaces it, so a registration still in flight then can
+   * tell its session has ended; the ended one keeps how sign-out reached the server only for as long as such a
+   * registration still holds it.
+   */
+  private session: PushSession = {};
   private notificationListener: { remove: () => void } | null = null;
   private responseListener: { remove: () => void } | null = null;
   private notifeeForegroundUnsubscribe: (() => void) | null = null;
@@ -525,6 +545,8 @@ class PushNotificationService {
       return null;
     }
 
+    const session = this.session;
+
     try {
       // Request OS notification permissions (iOS critical alerts included).
       const { status: existingStatus } = await Notifications.getPermissionsAsync();
@@ -579,15 +601,43 @@ class PushNotificationService {
         },
       });
 
+      // Signed out while permission and the token were sorted out: the session that asked for this has ended.
+      if (session !== this.session) {
+        return null;
+      }
+
+      const registration: NativePushUnRegistrationInput = { Token: this.pushToken || '', Prefix: departmentCode, UnitId: unitId };
+
       // Register device with backend
       await registerUnitDevice({
         UnitId: unitId,
-        Token: this.pushToken || '',
+        Token: registration.Token,
         Platform: Platform.OS === 'ios' ? 1 : 2,
         DeviceUuid: getOrCreateDeviceUuid(),
         Prefix: departmentCode,
       });
 
+      if (session !== this.session) {
+        // Signed out while the request was in flight. Sign-out could not take this registration off, as it had not
+        // landed yet: take it off now as the session that signed out, and never restore it, or the server keeps
+        // sending the signed-out unit's dispatches to this phone.
+        await this.unregisterAfterSignOut(session, registration);
+        return null;
+      }
+
+      const previous = this.registration;
+      this.registration = registration;
+      // A unit the phone left and has now come back to is its current one again, not one to take the token off.
+      this.staleRegistrations = this.staleRegistrations.filter((stale) => !isSameRegistration(stale, registration));
+
+      // Switching units: the phone is on the new unit now, so take its token off the unit it left, or the rig keeps
+      // getting that unit's dispatches. Only after the new registration is in, so a failure here never leaves the
+      // phone on no unit at all. A removal that fails is kept and tried again later.
+      if (previous && (previous.UnitId !== unitId || previous.Prefix !== departmentCode)) {
+        this.staleRegistrations.push(previous);
+      }
+      await this.removeStaleRegistrations(session);
+
       return this.pushToken;
     } catch (error) {
       logger.warn({
@@ -602,16 +652,98 @@ class PushNotificationService {
     return this.pushToken;
   }
 
+  /** Quiet: the new unit is already registered, so a failure here only leaves the old unit's dispatches arriving too. */
+  private async unregisterPreviousUnit(previous: NativePushUnRegistrationInput): Promise<boolean> {
+    try {
+      const result = await unRegisterNativePush(previous);
+      if (result?.Status !== 'success') {
+        logger.warn({ message: 'Push: the server did not unregister the token from the previous unit', context: { unitId: previous.UnitId, status: result?.Status } });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.warn({ message: 'Push: the token could not be unregistered from the previous unit', context: { unitId: previous.UnitId, error } });
+      return false;
+    }
+  }
+
+  /** Takes the token off the units the phone left; each one stays pending until the server confirms its removal. */
+  private async removeStaleRegistrations(session: PushSession): Promise<void> {
+    for (const stale of [...this.staleRegistrations]) {
+      // Signed out meanwhile: sign-out took the rest off as the session that ended.
+      if (session !== this.session) {
+        return;
+      }
+      if (await this.unregisterPreviousUnit(stale)) {
+        this.staleRegistrations = this.staleRegistrations.filter((entry) => entry !== stale);
+      }
+    }
+  }
+
+  /**
+   * Takes this phone's token off the unit at sign-out, as the session that is signing out (the hook below runs
+   * before logout clears its access token), along with any unit it left whose removal is still pending.
+   */
+  public async unregisterAtSignOut(accessToken: string | null): Promise<void> {
+    const registrations = [this.registration, ...this.staleRegistrations].filter((registration): registration is NativePushUnRegistrationInput => registration !== null);
+    this.registration = null;
+    this.staleRegistrations = [];
+
+    // Read while the session's server is still current: a server switch applies the new URL once sign-out returns.
+    const apiUrl = getBaseApiUrl();
+    // A registration still in flight belongs to this session too, and takes itself off the same way once it lands.
+    this.session.signOut = { accessToken, apiUrl };
+    this.session = {};
+
+    if (!accessToken) {
+      return;
+    }
+
+    await Promise.all(registrations.map((registration) => this.unregisterAsSignedOutSession(registration, accessToken, apiUrl)));
+  }
+
+  /** A registration that landed after its session signed out: taken off with the token that session signed out with. */
+  private async unregisterAfterSignOut(session: PushSession, registration: NativePushUnRegistrationInput): Promise<void> {
+    const signOut = session.signOut;
+    if (!signOut?.accessToken) {
+      logger.warn({ message: 'Push: a registration that landed after sign-out could not be taken off', context: { unitId: registration.UnitId } });
+      return;
+    }
+
+    await this.unregisterAsSignedOutSession(registration, signOut.accessToken, signOut.apiUrl);
+  }
+
+  /**
+   * 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.
+   */
+  private async unregisterAsSignedOutSession(registration: NativePushUnRegistrationInput, accessToken: string, apiUrl: string): Promise<void> {
+    try {
+      const response = await fetch(`${apiUrl}/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: { unitId: registration.UnitId, status: response.status } });
+      }
+    } catch (error) {
+      logger.warn({ message: 'Push: the device token could not be unregistered at sign-out', context: { unitId: registration.UnitId, error } });
+    }
+  }
+
   /**
    * Best-effort local push teardown on logout: clears the in-memory token,
    * badge and delivered notifications so the previous user's alerts don't
-   * linger for the next user of the device. NOTE: the backend has no
-   * unregister-device endpoint yet — server-side token invalidation should be
-   * added there and called from here when available.
+   * linger for the next user of the device. The server-side removal already
+   * ran earlier in sign-out (unregisterAtSignOut, via the sign-out hook below),
+   * while the session's access token still worked.
    */
   public async unregisterFromPushNotifications(): Promise<void> {
     try {
       this.pushToken = null;
+      this.registration = null;
+      this.staleRegistrations = [];
       await Notifications.setBadgeCountAsync(0).catch(() => {});
       await Notifications.dismissAllNotificationsAsync().catch(() => {});
       if (Platform.OS === 'android') {
@@ -648,6 +780,10 @@ class PushNotificationService {
 
 export const pushNotificationService = PushNotificationService.getInstance();
 
+// Sign-out takes this phone's token off the unit while the session can still authenticate, so the next person to
+// use the device never gets the previous one's dispatches.
+registerSignOutHook((accessToken) => pushNotificationService.unregisterAtSignOut(accessToken));
+
 // React hook for component usage
 export const usePushNotifications = () => {
   const activeUnitId = useCoreStore((state) => state.activeUnitId);
diff --git a/src/stores/app/__tests__/core-store.test.ts b/src/stores/app/__tests__/core-store.test.ts
index 1a143755..fc8020ad 100644
--- a/src/stores/app/__tests__/core-store.test.ts
+++ b/src/stores/app/__tests__/core-store.test.ts
@@ -72,6 +72,7 @@ import { getActiveUnitId, getActiveCallId, removeActiveUnitId } from '@/lib/stor
 import { getConfig } from '@/api/config';
 import { logger } from '@/lib/logging';
 import { GetConfigResultData } from '@/models/v4/configs/getConfigResultData';
+import type { UnitTypeStatusResultData } from '@/models/v4/statuses/unitTypeStatusResultData';
 import { getAllUnitStatuses } from '@/api/satuses/statuses';
 import { getUnitStatus } from '@/api/units/unitStatuses';
 import { useUnitsStore } from '@/stores/units/store';
@@ -458,6 +459,77 @@ describe('Core Store', () => {
       expect(useCoreStore.getState().activeStatuses).toEqual(unitStatuses[0]);
     });
 
+    it('should resolve activeStatuses by the unit custom status set id, so a renamed unit type keeps its statuses', async () => {
+      (useUnitsStore.getState as jest.Mock).mockReturnValue({
+        fetchUnits: jest.fn(async () => undefined),
+        units: [{ ...activeUnit, Type: 'Engine (renamed)', CustomStatusSetId: 's3' }],
+        unitStatuses,
+      });
+
+      await useCoreStore.getState().setActiveUnit('unit-1');
+
+      expect(useCoreStore.getState().activeStatuses).toEqual(unitStatuses[1]);
+    });
+
+    it('should resolve activeStatuses by unit type name when the set id is the built-in 0 (or not sent)', async () => {
+      (useUnitsStore.getState as jest.Mock).mockReturnValue({
+        fetchUnits: jest.fn(async () => undefined),
+        units: [{ ...activeUnit, CustomStatusSetId: '0' }],
+        unitStatuses,
+      });
+
+      await useCoreStore.getState().setActiveUnit('unit-1');
+
+      expect(useCoreStore.getState().activeStatuses).toEqual(unitStatuses[1]);
+    });
+
+    it('should match the current status option by its id before its text', async () => {
+      const statusSets = [
+        { UnitType: '0', StatusId: '', Statuses: [{ Id: 0, Text: 'Available' }] },
+        {
+          UnitType: '3',
+          StatusId: 's3',
+          Statuses: [
+            { Id: 21, Text: 'Available' },
+            { Id: 22, Text: 'En Route' },
+          ],
+        },
+      ] as unknown as UnitTypeStatusResultData[];
+      (useUnitsStore.getState as jest.Mock).mockReturnValue({
+        fetchUnits: jest.fn(async () => undefined),
+        units: [activeUnit],
+        unitStatuses: statusSets,
+      });
+      (getUnitStatus as jest.Mock).mockImplementation(async () => ({ Data: { UnitId: 'unit-1', StateId: 22, State: 'Responding' } }));
+
+      await useCoreStore.getState().setActiveUnit('unit-1');
+
+      expect(useCoreStore.getState().activeUnitStatusType).toEqual(statusSets[1].Statuses[1]);
+    });
+
+    it('should match the current status option by its text when the server sends no option id', async () => {
+      const statusSets = [
+        {
+          UnitType: '3',
+          StatusId: 's3',
+          Statuses: [
+            { Id: 21, Text: 'Available' },
+            { Id: 22, Text: 'En Route' },
+          ],
+        },
+      ] as unknown as UnitTypeStatusResultData[];
+      (useUnitsStore.getState as jest.Mock).mockReturnValue({
+        fetchUnits: jest.fn(async () => undefined),
+        units: [activeUnit],
+        unitStatuses: statusSets,
+      });
+      (getUnitStatus as jest.Mock).mockImplementation(async () => ({ Data: { UnitId: 'unit-1', State: 'En Route' } }));
+
+      await useCoreStore.getState().setActiveUnit('unit-1');
+
+      expect(useCoreStore.getState().activeUnitStatusType).toEqual(statusSets[0].Statuses[1]);
+    });
+
     it('should log a network failure at warn rather than error', async () => {
       // Axios "Network Error" — no response received (offline / background launch)
       const networkError = Object.assign(new Error('Network Error'), {
diff --git a/src/stores/app/core-store.ts b/src/stores/app/core-store.ts
index e958457a..0aee5d56 100644
--- a/src/stores/app/core-store.ts
+++ b/src/stores/app/core-store.ts
@@ -9,6 +9,7 @@ import { logger } from '@/lib/logging';
 import { applyServerMapboxToken } from '@/lib/mapbox-token';
 import { zustandStorage } from '@/lib/storage';
 import { getActiveCallId, getActiveUnitId, removeActiveCallId, removeActiveUnitId, setActiveCallId, setActiveUnitId } from '@/lib/storage/app';
+import { findCurrentUnitStatusOption, findUnitStatusSet } from '@/lib/unit-status-set';
 import { type CallPriorityResultData } from '@/models/v4/callPriorities/callPriorityResultData';
 import { type CallResultData } from '@/models/v4/calls/callResultData';
 import { type GetConfigResultData } from '@/models/v4/configs/getConfigResultData';
@@ -183,20 +184,10 @@ export const useCoreStore = create<CoreState>()(
             // fetchUnits() above already fetched /Statuses/GetAllUnitStatuses and
             // stored the identical payload as unitStatuses — reuse it instead of
             // issuing the same request a second time.
-            let activeStatuses: UnitTypeStatusResultData | undefined = undefined;
+            // The unit type's custom status set (by CustomStatusSetId, which survives a renamed unit type, then by
+            // the unit type name); a unit without one uses the built-in statuses.
             const defaultStatuses = find(unitStatuses, ['UnitType', '0']);
-
-            if (activeUnit.Type) {
-              const statusesForType = find(unitStatuses, ['UnitType', activeUnit.Type.toString()]);
-
-              if (statusesForType) {
-                activeStatuses = statusesForType;
-              } else {
-                activeStatuses = defaultStatuses;
-              }
-            } else {
-              activeStatuses = defaultStatuses;
-            }
+            const activeStatuses: UnitTypeStatusResultData | undefined = findUnitStatusSet(unitStatuses, activeUnit) ?? defaultStatuses;
 
             set({
               activeUnit: activeUnit,
@@ -225,9 +216,9 @@ export const useCoreStore = create<CoreState>()(
           const unitStatus = await getUnitStatus(unitId);
 
           if (unitStatus) {
-            const unitStatusType = unitStatuses.find((status) => status.UnitType === activeUnit?.Type);
+            const unitStatusType = findUnitStatusSet(unitStatuses, activeUnit);
             if (unitStatusType) {
-              const unitStatusInfo = unitStatusType.Statuses.find((status) => status.Text === unitStatus.Data.State);
+              const unitStatusInfo = findCurrentUnitStatusOption(unitStatusType.Statuses, unitStatus.Data);
               set({
                 activeUnitStatus: unitStatus.Data,
                 activeUnitStatusType: unitStatusInfo,
diff --git a/src/stores/terminology/__tests__/store.test.ts b/src/stores/terminology/__tests__/store.test.ts
new file mode 100644
index 00000000..593a8041
--- /dev/null
+++ b/src/stores/terminology/__tests__/store.test.ts
@@ -0,0 +1,196 @@
+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({});
+  });
+
+  describe('superseded requests', () => {
+    const deferred = () => {
+      let resolve: (value: { Data: { Key: string; Name: string }[] }) => void = () => {};
+      let reject: (error: Error) => void = () => {};
+      const promise = new Promise<{ Data: { Key: string; Name: string }[] }>((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return { promise, resolve, reject };
+    };
+
+    it('drops the answer of a request still in flight at reset, so it is not restored or persisted', async () => {
+      const pending = deferred();
+      getTerminology.mockReturnValueOnce(pending.promise);
+
+      const fetching = terminologyStore.getState().fetchTerminology();
+      terminologyStore.getState().reset();
+      pending.resolve({ Data: [{ Key: TermKeys.Units, Name: 'Apparatus' }] });
+      await fetching;
+
+      const state = terminologyStore.getState();
+      expect(state.names).toEqual({});
+      expect(state.isLoaded).toBe(false);
+      expect(state.identityKey).toBeNull();
+    });
+
+    it('drops the error of a request still in flight at reset', async () => {
+      const pending = deferred();
+      getTerminology.mockReturnValueOnce(pending.promise);
+
+      const fetching = terminologyStore.getState().fetchTerminology();
+      terminologyStore.getState().reset();
+      pending.reject(new Error('offline'));
+      await fetching;
+
+      expect(terminologyStore.getState().error).toBeNull();
+      expect(terminologyStore.getState().isLoaded).toBe(false);
+    });
+
+    it('never lets an older request overwrite a newer one', async () => {
+      const older = deferred();
+      const newer = deferred();
+      getTerminology.mockReturnValueOnce(older.promise).mockReturnValueOnce(newer.promise);
+
+      const first = terminologyStore.getState().fetchTerminology();
+      const second = terminologyStore.getState().fetchTerminology();
+      newer.resolve({ Data: [{ Key: TermKeys.Units, Name: 'Apparatus' }] });
+      await second;
+      older.resolve({ Data: [{ Key: TermKeys.Units, Name: 'Rigs' }] });
+      await first;
+
+      expect(terminologyStore.getState().names).toEqual({ [TermKeys.Units]: 'Apparatus' });
+    });
+
+    it('drops the answer when the session it was made for has moved on', async () => {
+      const pending = deferred();
+      getTerminology.mockReturnValueOnce(pending.promise);
+
+      const fetching = terminologyStore.getState().fetchTerminology();
+      setIdentity('user-2', 'dept-2');
+      pending.resolve({ Data: [{ Key: TermKeys.Units, Name: 'Apparatus' }] });
+      await fetching;
+
+      expect(terminologyStore.getState().names).toEqual({});
+      expect(terminologyStore.getState().identityKey).toBeNull();
+    });
+  });
+
+  it('reset clears the names and identity', () => {
+    terminologyStore.setState({ names: { [TermKeys.Records]: 'Reports' }, isLoaded: true, error: 'offline', identityKey: 'user-1:dept-1' });
+
+    terminologyStore.getState().reset();
+
+    const state = terminologyStore.getState();
+    expect(state.names).toEqual({});
+    expect(state.isLoaded).toBe(false);
+    expect(state.error).toBeNull();
+    expect(state.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');
+    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..af32ca52
--- /dev/null
+++ b/src/stores/terminology/store.ts
@@ -0,0 +1,161 @@
+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;
+};
+
+// Bumped by every fetch and by reset(). Only the newest request may commit its answer: an older one would
+// overwrite a newer one's names, and one still in flight at sign-out would bring the previous department's
+// names back (and persist them) after the reset cleared them.
+let requestGeneration = 0;
+
+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>;
+  /** Clears the names and drops the answer of any request still in flight. */
+  reset: () => void;
+}
+
+export const terminologyStore = create<TerminologyState>()(
+  persist(
+    (set, get) => ({
+      names: {},
+      isLoaded: false,
+      error: null,
+      identityKey: null,
+      fetchTerminology: async () => {
+        requestGeneration += 1;
+        const generation = requestGeneration;
+        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 });
+        }
+        // Superseded by a newer request or a reset, or the session it was made for has moved on.
+        const isCurrent = () => generation === requestGeneration && identityKey === getCurrentIdentityKey();
+        try {
+          const response = await getTerminology();
+          if (!isCurrent()) {
+            return;
+          }
+          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) {
+          if (!isCurrent()) {
+            return;
+          }
+          // 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 });
+        }
+      },
+      reset: () => {
+        requestGeneration += 1;
+        set({ names: {}, isLoaded: false, error: null, identityKey: null });
+      },
+    }),
+    {
+      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);