Develop

src/components/incident-command/__tests__/incident-command-tab-panel.test.tsx

@@ -26,6 +26,23 @@ jest.mock('lucide-react-native', () => ({
     const { View } = require('react-native');
     return <View testID="phone-icon" />;
   },
+  // Icons used by the incident chat section rendered inside the panel.
+  MessageCircle: () => {
+    const { View } = require('react-native');
+    return <View testID="message-icon" />;
+  },
+  MessagesSquare: () => {
+    const { View } = require('react-native');
+    return <View testID="messages-icon" />;
+  },
+  ShieldCheck: () => {
+    const { View } = require('react-native');
+    return <View testID="shield-icon" />;
+  },
+  Users: () => {
+    const { View } = require('react-native');
+    return <View testID="users-icon" />;
+  },
 }));
 
 jest.mock('@/lib/logging', () => ({

src/components/incident-command/incident-chat-section.tsx

@@ -0,0 +1,139 @@
+import { router } from 'expo-router';
+import { MessageCircle, MessagesSquare, Radio, ShieldCheck, Users } from 'lucide-react-native';
+import React, { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { Box } from '@/components/ui/box';
+import { Heading } from '@/components/ui/heading';
+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 { useDirectMessage } from '@/hooks/use-direct-message';
+import { type IncidentContactInfo, type ResourceIncidentView } from '@/models/v4/incidentCommand/resourceIncidentView';
+
+import { getIncidentRoleName } from './incident-role-names';
+
+interface IncidentChatSectionProps {
+  view: ResourceIncidentView;
+  testID?: string;
+}
+
+/** One tappable channel row. Rendered only when the server handed us an id we are allowed to open. */
+const ChannelRow: React.FC<{ label: string; hint?: string | null; icon: React.ElementType; channelId?: string | null; testID: string }> = ({ label, hint, icon: IconComponent, channelId, testID }) => {
+  const onPress = useCallback(() => {
+    if (channelId) {
+      router.push(`/chat/${channelId}`);
+    }
+  }, [channelId]);
+
+  if (!channelId) {
+    return null;
+  }
+
+  return (
+    <Pressable onPress={onPress} className="rounded-lg border border-neutral-200 p-3 dark:border-neutral-700" testID={testID}>
+      <HStack className="items-center" space="sm">
+        <IconComponent size={18} color="#3b82f6" />
+        <VStack className="min-w-0 flex-1">
+          <Text className="font-medium">{label}</Text>
+          {hint ? <Text className="text-xs text-gray-500">{hint}</Text> : null}
+        </VStack>
+      </HStack>
+    </Pressable>
+  );
+};
+
+/** A person on the incident with a button to open a 1:1 with them. */
+const ContactRow: React.FC<{ label: string; contact?: IncidentContactInfo | null; onMessage: (userId?: string | null) => void; testID: string }> = ({ label, contact, onMessage, testID }) => {
+  const { t } = useTranslation();
+  const handlePress = useCallback(() => onMessage(contact?.UserId), [onMessage, contact]);
+
+  if (!contact) {
+    return null;
+  }
+
+  return (
+    <HStack className="items-center justify-between py-1" testID={testID}>
+      <VStack className="min-w-0 flex-1">
+        <Text className="text-xs text-gray-500">{label}</Text>
+        <Text className="font-medium">{contact.Name}</Text>
+      </VStack>
+      {/* External contacts have a name and phone but no Resgrid account, so no 1:1 to open. */}
+      {contact.UserId ? (
+        <Pressable onPress={handlePress} className="p-3" hitSlop={8} accessibilityLabel={t('incident_command.message_person', { name: contact.Name })} testID={`${testID}-message`}>
+          <MessageCircle size={20} color="#3b82f6" />
+        </Pressable>
+      ) : null}
+    </HStack>
+  );
+};
+
+/**
+ * Incident chat on the Command tab: the channels this responder can open, and the people on the
+ * incident they can reach 1:1.
+ *
+ * Access is decided entirely by the server — a channel id only appears in the payload when the
+ * caller is actually allowed in, and it disappears again when they are (for example) taken off the
+ * lane. Nothing here infers access on its own.
+ */
+export const IncidentChatSection: React.FC<IncidentChatSectionProps> = ({ view, testID = 'incident-command-chat' }) => {
+  const { t } = useTranslation();
+  const { openDirectMessage } = useDirectMessage();
+
+  const chat = view.Chat;
+  const assignment = view.MyAssignment;
+  const roles = view.Roles ?? [];
+
+  const handleMessage = useCallback((userId?: string | null) => void openDirectMessage(userId), [openDirectMessage]);
+
+  const hasChannels = !!(chat?.IncidentChannelId || chat?.LaneChannelId || chat?.CommandChannelId || chat?.LeadsChannelId || chat?.DispatchChannelId);
+  // Only ICS role holders live here — the commander and this resource's lane leads already have
+  // contact cards higher up the panel, and listing them twice just made the screen noisy.
+  const hasContacts = roles.length > 0;
+
+  if (!hasChannels && !hasContacts) {
+    return null;
+  }
+
+  return (
+    <Box testID={testID}>
+      <Heading size="sm" className="mb-2">
+        {t('incident_command.chat')}
+      </Heading>
+
+      {chat?.IsFrozen ? (
+        <Box className="mb-2 rounded-lg bg-neutral-100 p-2 dark:bg-neutral-800" testID={`${testID}-frozen`}>
+          <Text className="text-xs text-gray-600 dark:text-gray-300">{t('incident_command.chat_frozen')}</Text>
+        </Box>
+      ) : null}
+
+      {hasChannels ? (
+        <VStack space="sm">
+          <ChannelRow label={t('incident_command.incident_channel')} icon={MessagesSquare} channelId={chat?.IncidentChannelId} testID={`${testID}-incident`} />
+          <ChannelRow label={t('incident_command.lane_channel')} hint={assignment?.LaneName} icon={MessagesSquare} channelId={chat?.LaneChannelId} testID={`${testID}-lane`} />
+          <ChannelRow label={t('incident_command.command_channel')} hint={t('incident_command.command_channel_hint')} icon={ShieldCheck} channelId={chat?.CommandChannelId} testID={`${testID}-command`} />
+          <ChannelRow label={t('incident_command.leads_channel')} hint={t('incident_command.leads_channel_hint')} icon={Users} channelId={chat?.LeadsChannelId} testID={`${testID}-leads`} />
+          <ChannelRow label={t('incident_command.dispatch_channel')} hint={t('incident_command.dispatch_channel_hint')} icon={Radio} channelId={chat?.DispatchChannelId} testID={`${testID}-dispatch`} />
+        </VStack>
+      ) : null}
+
+      {hasContacts ? (
+        <Box className="mt-3">
+          <Text className="mb-1 text-xs font-semibold uppercase text-gray-500">{t('incident_command.ics_positions')}</Text>
+          {roles.map((role) => (
+            <ContactRow
+              key={`${role.RoleType}-${role.Contact?.UserId ?? ''}`}
+              label={getIncidentRoleName(t, role.RoleType)}
+              contact={role.Contact}
+              onMessage={handleMessage}
+              testID={`${testID}-contact-role-${role.RoleType}`}
+            />
+          ))}
+        </Box>
+      ) : null}
+    </Box>
+  );
+};
+
+export default IncidentChatSection;

src/components/incident-command/incident-command-tab-panel.tsx

@@ -1,5 +1,5 @@
 import { format } from 'date-fns';
-import { MailIcon, PhoneIcon } from 'lucide-react-native';
+import { MailIcon, MessageCircle, PhoneIcon } from 'lucide-react-native';
 import { useColorScheme } from 'nativewind';
 import React, { useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -13,10 +13,13 @@ 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 { useDirectMessage } from '@/hooks/use-direct-message';
 import { logger } from '@/lib/logging';
 import { type IncidentContactInfo, IncidentNeedStatus, type TacticalObjective, TacticalObjectiveStatus } from '@/models/v4/incidentCommand/resourceIncidentView';
 import { useIncidentCommandStore } from '@/stores/calls/incident-command-store';
 
+import { IncidentChatSection } from './incident-chat-section';
+
 interface IncidentCommandTabPanelProps {
   callId: string;
 }
@@ -102,6 +105,9 @@ interface ContactRowProps {
 }
 
 const ContactRow: React.FC<ContactRowProps> = ({ label, contact, testID }) => {
+  const { t } = useTranslation();
+  const { openDirectMessage } = useDirectMessage();
+
   return (
     <Box className="border-b border-outline-100 pb-2" testID={testID}>
       <Text className="text-sm text-gray-500">{label}</Text>
@@ -122,6 +128,15 @@ const ContactRow: React.FC<ContactRowProps> = ({ label, contact, testID }) => {
           </HStack>
         </Pressable>
       ) : null}
+      {/* External contacts carry a name and phone but no Resgrid account, so there is nobody to message. */}
+      {contact.UserId ? (
+        <Pressable onPress={() => void openDirectMessage(contact.UserId)} testID={`${testID}-message`}>
+          <HStack className="mt-1 items-center">
+            <MessageCircle size={14} color="#3B82F6" />
+            <Text className="ml-1 text-sm text-blue-500">{t('incident_command.send_message')}</Text>
+          </HStack>
+        </Pressable>
+      ) : null}
     </Box>
   );
 };
@@ -264,6 +279,9 @@ export const IncidentCommandTabPanel: React.FC<IncidentCommandTabPanelProps> = (
         </VStack>
       </Box>
 
+      {/* Incident chat: the channels this responder may open, plus who they can reach 1:1. */}
+      <IncidentChatSection view={view} />
+
       {/* Objectives */}
       <Box className={`rounded-lg p-4 shadow-xs ${cardClass}`} testID="incident-command-objectives">
         <Heading size="sm">{t('incident_command.objectives')}</Heading>

src/components/incident-command/incident-role-names.ts

@@ -0,0 +1,45 @@
+import { type TFunction } from 'i18next';
+
+/**
+ * Standard NIMS/ICS position titles, keyed by the Core `IncidentRoleType` value.
+ *
+ * English titles rather than translation keys: these are the position names an IC is trained
+ * against, and the IC app treats them the same way. Translating them needs a subject-matter
+ * translator per locale, not a literal one.
+ */
+const ICS_ROLE_NAMES: Record<number, string> = {
+  0: 'Incident Commander',
+  1: 'Deputy Incident Commander',
+  2: 'Unified Command Member',
+  3: 'Operations Section Chief',
+  4: 'Planning Section Chief',
+  5: 'Logistics Section Chief',
+  6: 'Finance/Admin Section Chief',
+  7: 'Safety Officer',
+  8: 'Liaison Officer',
+  9: 'Public Information Officer',
+  10: 'Staging Area Manager',
+  11: 'Resources Unit Leader',
+  12: 'Situation Unit Leader',
+  13: 'Documentation Unit Leader',
+  14: 'Communications Unit Leader',
+  15: 'Division/Group Supervisor',
+  16: 'Branch Director',
+  17: 'Strike Team/Task Force Leader',
+  18: 'Medical Unit Leader',
+  19: 'Rehab Officer',
+  20: 'Medical Branch Director',
+  21: 'Triage Officer',
+  22: 'Treatment Officer',
+  23: 'Transport Officer',
+  24: 'HazMat Group Supervisor',
+  25: 'Decon Officer',
+  26: 'Entry Team Leader',
+  27: 'Search Group Supervisor',
+  28: 'Air Operations Branch Director',
+  29: 'Shelter/Mass Care Coordinator',
+  30: 'Damage Assessment Lead',
+};
+
+/** Display name for an ICS position; falls back to a generic label for a value we don't know yet. */
+export const getIncidentRoleName = (t: TFunction, roleType: number): string => ICS_ROLE_NAMES[roleType] ?? t('incident_command.role_generic', { role: roleType });

src/hooks/use-direct-message.ts

@@ -0,0 +1,48 @@
+import { router } from 'expo-router';
+import { useCallback, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { createDirectMessage } from '@/api/chat/chat';
+import { logger } from '@/lib/logging';
+import { useToastStore } from '@/stores/toast/store';
+
+/**
+ * Opens a 1:1 conversation with someone and navigates to it.
+ *
+ * The server dedups on a normalized participant key, so calling this repeatedly for the same person
+ * reuses the existing conversation rather than starting a new one — which is what makes it safe to
+ * hang a "message" button off every contact on an incident.
+ */
+export const useDirectMessage = () => {
+  const { t } = useTranslation();
+  const [isOpening, setIsOpening] = useState(false);
+
+  const openDirectMessage = useCallback(
+    async (targetUserId?: string | null) => {
+      if (!targetUserId) {
+        // External lane leads have a name and phone but no Resgrid account to message.
+        useToastStore.getState().showToast('info', t('incident_command.dm_unavailable'));
+        return;
+      }
+
+      setIsOpening(true);
+      try {
+        const channel = await createDirectMessage({ TargetUserId: targetUserId });
+        const channelId = channel?.Data?.ChatChannelId;
+        if (!channelId) {
+          useToastStore.getState().showToast('error', t('incident_command.dm_failed'));
+          return;
+        }
+        router.push(`/chat/${channelId}`);
+      } catch (error) {
+        logger.error({ message: 'chat: failed to open direct message', context: { error, targetUserId } });
+        useToastStore.getState().showToast('error', t('incident_command.dm_failed'));
+      } finally {
+        setIsOpening(false);
+      }
+    },
+    [t]
+  );
+
+  return { openDirectMessage, isOpening };
+};

src/models/v4/chat/chatEnums.ts

@@ -13,6 +13,10 @@ export enum ChatChannelType {
   IncidentLane = 6,
   IncidentCommand = 7,
   Chatbot = 8,
+  /** IC plus every lane's primary/secondary lead — command talking to the people running the lanes. */
+  IncidentLeads = 9,
+  /** The incident's line to the dispatch desk: everyone on the incident, plus every authorized dispatcher. */
+  IncidentDispatch = 10,
 }
 
 /** Message type (ChatMessageResultData.MessageType). */

src/models/v4/incidentCommand/resourceIncidentView.ts

@@ -121,6 +121,33 @@ export class ResourceLaneAssignmentView {
   public LinkedNeed?: IncidentNeed | null = null;
 }
 
+/** Who holds an ICS position on the incident, with the contact details to reach them. */
+export class IncidentRoleContactInfo {
+  /** Maps to IncidentRoleType. */
+  public RoleType: number = 0;
+  public Contact?: IncidentContactInfo | null = null;
+}
+
+/**
+ * The incident's chat channels, already filtered by the server to the ones this caller may open.
+ * A null id means "not available to you" — not command staff, not a lane lead, or not provisioned.
+ * Never infer access from anything else: if the id isn't here, the channel will reject you.
+ */
+export class IncidentChatChannels {
+  /** Call-wide incident channel (everyone on the call). */
+  public IncidentChannelId?: string | null = null;
+  /** Private command channel — command staff (IC or an ICS role holder) only. */
+  public CommandChannelId?: string | null = null;
+  /** "All Leads" channel — the IC and lane primary/secondary leads only. */
+  public LeadsChannelId?: string | null = null;
+  /** The caller's own lane channel, when they are assigned to a lane. */
+  public LaneChannelId?: string | null = null;
+  /** The incident's line to the dispatch desk — open to everyone on the incident. */
+  public DispatchChannelId?: string | null = null;
+  /** True once the incident is closed: readable, but frozen as a point-in-time record. */
+  public IsFrozen: boolean = false;
+}
+
 export class ResourceIncidentView {
   public IncidentCommandId: string = '';
   public CallId: number = 0;
@@ -136,4 +163,8 @@ export class ResourceIncidentView {
   public Notes: IncidentNote[] = [];
   public Attachments: IncidentAttachment[] = [];
   public MyAssignment?: ResourceLaneAssignmentView | null = null;
+  /** ICS positions filled on this incident, so a crew can reach the right person directly. */
+  public Roles?: IncidentRoleContactInfo[] = [];
+  /** Chat channels this caller may open. */
+  public Chat?: IncidentChatChannels | null = null;
 }