@yancyyu/openhermit 1.5.8

package/src/renderer/utils/memberLaunchDiagnostics.ts

@@ -0,0 +1,216 @@
+import type {
+  MemberLaunchState,
+  MemberSpawnLivenessSource,
+  MemberSpawnStatus,
+  MemberSpawnStatusEntry,
+  TeamAgentRuntimeDiagnosticSeverity,
+  TeamAgentRuntimeEntry,
+  TeamAgentRuntimeLivenessKind,
+  TeamAgentRuntimePidSource,
+} from '@shared/types';
+
+export interface MemberLaunchDiagnosticsPayload {
+  teamName?: string;
+  runId?: string;
+  memberName: string;
+  launchState?: MemberLaunchState;
+  spawnStatus?: MemberSpawnStatus;
+  livenessKind?: TeamAgentRuntimeLivenessKind;
+  livenessSource?: MemberSpawnLivenessSource;
+  pid?: number;
+  pidSource?: TeamAgentRuntimePidSource;
+  paneId?: string;
+  panePid?: number;
+  paneCurrentCommand?: string;
+  processCommand?: string;
+  runtimePid?: number;
+  runtimeSessionId?: string;
+  runtimeDiagnostic?: string;
+  runtimeDiagnosticSeverity?: TeamAgentRuntimeDiagnosticSeverity;
+  diagnostics?: string[];
+  updatedAt?: string;
+}
+
+const MAX_DIAGNOSTIC_STRING_LENGTH = 500;
+const MAX_DIAGNOSTIC_ITEMS = 20;
+const SECRET_FLAG_PATTERN =
+  /(--(?:api-key|token|password|secret|authorization|auth-token)(?:=|\s+))("[^"]*"|'[^']*'|\S+)/gi;
+
+function normalizeDiagnosticValue(value: unknown): string | undefined {
+  if (value == null) {
+    return undefined;
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message;
+  }
+  if (
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    typeof value === 'bigint' ||
+    typeof value === 'symbol'
+  ) {
+    return String(value);
+  }
+  try {
+    const json = JSON.stringify(value);
+    return typeof json === 'string' ? json : String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function boundedString(
+  value: unknown,
+  maxLength = MAX_DIAGNOSTIC_STRING_LENGTH
+): string | undefined {
+  const normalized = normalizeDiagnosticValue(value);
+  const trimmed = normalized?.replace(/\s+/g, ' ').trim();
+  if (!trimmed) return undefined;
+  const redacted = trimmed.replace(SECRET_FLAG_PATTERN, '$1[redacted]');
+  return redacted.length > maxLength
+    ? `${redacted.slice(0, Math.max(0, maxLength - 3))}...`
+    : redacted;
+}
+
+function boundedNumber(value: number | undefined): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.trunc(value)
+    : undefined;
+}
+
+function uniqueDiagnostics(
+  ...groups: (readonly (string | undefined)[] | undefined)[]
+): string[] | undefined {
+  const seen = new Set<string>();
+  const diagnostics: string[] = [];
+  for (const group of groups) {
+    for (const item of group ?? []) {
+      const normalized = boundedString(item);
+      if (!normalized || seen.has(normalized)) continue;
+      seen.add(normalized);
+      diagnostics.push(normalized);
+      if (diagnostics.length >= MAX_DIAGNOSTIC_ITEMS) {
+        return diagnostics;
+      }
+    }
+  }
+  return diagnostics.length > 0 ? diagnostics : undefined;
+}
+
+export function buildMemberLaunchDiagnosticsPayload(params: {
+  teamName?: string | null;
+  runId?: string | null;
+  memberName: string;
+  spawnStatus?: MemberSpawnStatus;
+  launchState?: MemberLaunchState;
+  livenessSource?: MemberSpawnLivenessSource;
+  spawnEntry?: MemberSpawnStatusEntry;
+  runtimeEntry?: TeamAgentRuntimeEntry;
+}): MemberLaunchDiagnosticsPayload {
+  const spawnEntry = params.spawnEntry;
+  const runtimeEntry = params.runtimeEntry;
+  const runtimeDiagnostic =
+    boundedString(spawnEntry?.runtimeDiagnostic) ??
+    boundedString(runtimeEntry?.runtimeDiagnostic) ??
+    boundedString(spawnEntry?.hardFailureReason) ??
+    boundedString(spawnEntry?.error);
+  const diagnostics = uniqueDiagnostics(
+    runtimeDiagnostic ? [runtimeDiagnostic] : undefined,
+    spawnEntry?.hardFailureReason ? [spawnEntry.hardFailureReason] : undefined,
+    spawnEntry?.error ? [spawnEntry.error] : undefined,
+    runtimeEntry?.diagnostics
+  );
+  const runId = boundedString(params.runId ?? undefined);
+
+  return {
+    ...(params.teamName ? { teamName: params.teamName } : {}),
+    ...(runId ? { runId } : {}),
+    memberName: params.memberName,
+    ...((spawnEntry?.launchState ?? params.launchState)
+      ? { launchState: spawnEntry?.launchState ?? params.launchState }
+      : {}),
+    ...((spawnEntry?.status ?? params.spawnStatus)
+      ? { spawnStatus: spawnEntry?.status ?? params.spawnStatus }
+      : {}),
+    ...((spawnEntry?.livenessKind ?? runtimeEntry?.livenessKind)
+      ? { livenessKind: spawnEntry?.livenessKind ?? runtimeEntry?.livenessKind }
+      : {}),
+    ...((spawnEntry?.livenessSource ?? params.livenessSource)
+      ? { livenessSource: spawnEntry?.livenessSource ?? params.livenessSource }
+      : {}),
+    ...(boundedNumber(runtimeEntry?.pid) ? { pid: boundedNumber(runtimeEntry?.pid) } : {}),
+    ...(runtimeEntry?.pidSource ? { pidSource: runtimeEntry.pidSource } : {}),
+    ...(boundedString(runtimeEntry?.paneId) ? { paneId: boundedString(runtimeEntry?.paneId) } : {}),
+    ...(boundedNumber(runtimeEntry?.panePid)
+      ? { panePid: boundedNumber(runtimeEntry?.panePid) }
+      : {}),
+    ...(boundedString(runtimeEntry?.paneCurrentCommand)
+      ? { paneCurrentCommand: boundedString(runtimeEntry?.paneCurrentCommand) }
+      : {}),
+    ...(boundedString(runtimeEntry?.processCommand)
+      ? { processCommand: boundedString(runtimeEntry?.processCommand) }
+      : {}),
+    ...(boundedNumber(runtimeEntry?.runtimePid)
+      ? { runtimePid: boundedNumber(runtimeEntry?.runtimePid) }
+      : {}),
+    ...(boundedString(runtimeEntry?.runtimeSessionId)
+      ? { runtimeSessionId: boundedString(runtimeEntry?.runtimeSessionId) }
+      : {}),
+    ...(runtimeDiagnostic ? { runtimeDiagnostic } : {}),
+    ...((spawnEntry?.runtimeDiagnosticSeverity ?? runtimeEntry?.runtimeDiagnosticSeverity)
+      ? {
+          runtimeDiagnosticSeverity:
+            spawnEntry?.runtimeDiagnosticSeverity ?? runtimeEntry?.runtimeDiagnosticSeverity,
+        }
+      : {}),
+    ...(diagnostics ? { diagnostics } : {}),
+    ...(boundedString(spawnEntry?.updatedAt ?? runtimeEntry?.updatedAt)
+      ? { updatedAt: boundedString(spawnEntry?.updatedAt ?? runtimeEntry?.updatedAt) }
+      : {}),
+  };
+}
+
+export function hasMemberLaunchDiagnosticsDetails(
+  payload: MemberLaunchDiagnosticsPayload
+): boolean {
+  const weakLiveness =
+    payload.livenessKind === 'runtime_process_candidate' ||
+    payload.livenessKind === 'permission_blocked' ||
+    payload.livenessKind === 'shell_only' ||
+    payload.livenessKind === 'registered_only' ||
+    payload.livenessKind === 'stale_metadata' ||
+    payload.livenessKind === 'not_found';
+  return Boolean(
+    (payload.launchState && payload.launchState !== 'confirmed_alive') ||
+    (payload.spawnStatus && payload.spawnStatus !== 'online') ||
+    weakLiveness ||
+    payload.runtimeDiagnostic ||
+    payload.diagnostics?.length
+  );
+}
+
+export function hasMemberLaunchDiagnosticsError(payload: MemberLaunchDiagnosticsPayload): boolean {
+  return Boolean(
+    payload.spawnStatus === 'error' ||
+    payload.launchState === 'failed_to_start' ||
+    payload.runtimeDiagnosticSeverity === 'error'
+  );
+}
+
+export function getMemberLaunchDiagnosticsErrorMessage(
+  payload: MemberLaunchDiagnosticsPayload
+): string | undefined {
+  if (!hasMemberLaunchDiagnosticsError(payload)) {
+    return undefined;
+  }
+  return payload.runtimeDiagnostic ?? payload.diagnostics?.[0] ?? 'Launch failed';
+}
+
+export function formatMemberLaunchDiagnosticsPayload(
+  payload: MemberLaunchDiagnosticsPayload
+): string {
+  return JSON.stringify(payload, null, 2);
+}

package/src/renderer/utils/memberRuntimeSummary.ts

@@ -0,0 +1,122 @@
+import { formatTeamModelSummary } from '@renderer/components/team/dialogs/TeamModelSelector';
+import { formatBytes } from '@renderer/utils/formatters';
+import { formatTeamProviderBackendLabel } from '@renderer/utils/providerBackendIdentity';
+import { inferTeamProviderIdFromModel } from '@shared/utils/teamProvider';
+
+import type { TeamLaunchParams } from '@renderer/store/slices/teamSlice';
+import type {
+  MemberSpawnStatusEntry,
+  ResolvedTeamMember,
+  TeamAgentRuntimeEntry,
+  TeamProviderId,
+} from '@shared/types';
+
+function normalizeMemberBackendLabel(
+  providerId: TeamProviderId,
+  backendLabel: string | undefined
+): string | undefined {
+  if (!backendLabel) {
+    return undefined;
+  }
+
+  if (providerId === 'codex' && backendLabel === 'Codex native') {
+    return 'Codex';
+  }
+
+  return backendLabel;
+}
+
+function isMemberLaunchPending(spawnEntry: MemberSpawnStatusEntry | undefined): boolean {
+  if (!spawnEntry) {
+    return false;
+  }
+
+  return (
+    spawnEntry.launchState === 'starting' ||
+    spawnEntry.launchState === 'runtime_pending_bootstrap' ||
+    spawnEntry.launchState === 'runtime_pending_permission' ||
+    spawnEntry.status === 'waiting' ||
+    spawnEntry.status === 'spawning'
+  );
+}
+
+export function getRuntimeMemorySourceLabel(
+  runtimeEntry: TeamAgentRuntimeEntry | undefined
+): string | undefined {
+  if (!runtimeEntry?.pidSource) {
+    return undefined;
+  }
+  if (
+    runtimeEntry.providerId === 'opencode' &&
+    runtimeEntry.restartable === false &&
+    runtimeEntry.pidSource === 'opencode_bridge'
+  ) {
+    return 'RSS source: shared OpenCode host';
+  }
+  if (runtimeEntry.pidSource === 'agent_process_table') {
+    return 'RSS source: runtime process';
+  }
+  if (runtimeEntry.pidSource === 'lead_process') {
+    return 'RSS source: lead process';
+  }
+  if (runtimeEntry.pidSource === 'runtime_bootstrap') {
+    return 'RSS source: runtime bootstrap process';
+  }
+  if (runtimeEntry.pidSource === 'persisted_metadata') {
+    return 'RSS source: persisted runtime metadata';
+  }
+  return `PID source: ${runtimeEntry.pidSource}`;
+}
+
+export function resolveMemberRuntimeSummary(
+  member: ResolvedTeamMember,
+  launchParams: TeamLaunchParams | undefined,
+  spawnEntry: MemberSpawnStatusEntry | undefined,
+  runtimeEntry?: TeamAgentRuntimeEntry
+): string | undefined {
+  const memberProviderBackendId = (member as ResolvedTeamMember & { providerBackendId?: string })
+    .providerBackendId;
+  const memberModel = member.model?.trim() || '';
+  const runtimeModel = spawnEntry?.runtimeModel?.trim() || runtimeEntry?.runtimeModel?.trim();
+  const inferredMemberProvider =
+    inferTeamProviderIdFromModel(memberModel) ?? inferTeamProviderIdFromModel(runtimeModel);
+  const configuredProvider: TeamProviderId =
+    member.providerId ?? inferredMemberProvider ?? launchParams?.providerId ?? 'anthropic';
+  const memberProviderForInheritance = member.providerId ?? inferredMemberProvider;
+  const inheritsLeadRuntimeDefaults =
+    memberProviderForInheritance == null ||
+    launchParams?.providerId == null ||
+    memberProviderForInheritance === launchParams.providerId;
+  const configuredModel =
+    memberModel || (inheritsLeadRuntimeDefaults ? launchParams?.model?.trim() || '' : '');
+  const configuredEffort =
+    member.effort ?? (inheritsLeadRuntimeDefaults ? launchParams?.effort : undefined);
+  const configuredProviderBackendId =
+    memberProviderBackendId ??
+    (inheritsLeadRuntimeDefaults ? launchParams?.providerBackendId : undefined);
+  const backendLabel = normalizeMemberBackendLabel(
+    configuredProvider,
+    formatTeamProviderBackendLabel(configuredProvider, configuredProviderBackendId)
+  );
+  const memorySuffix =
+    typeof runtimeEntry?.rssBytes === 'number' && runtimeEntry.rssBytes > 0
+      ? ` · ${formatBytes(runtimeEntry.rssBytes)}`
+      : '';
+
+  if (runtimeModel && (isMemberLaunchPending(spawnEntry) || configuredModel.length === 0)) {
+    const runtimeProvider = inferTeamProviderIdFromModel(runtimeModel) ?? configuredProvider;
+    const summary = formatTeamModelSummary(runtimeProvider, runtimeModel, configuredEffort);
+    return `${summary}${backendLabel ? ` · ${backendLabel}` : ''}${memorySuffix}`;
+  }
+
+  if (isMemberLaunchPending(spawnEntry)) {
+    if (!configuredModel.length && !memorySuffix) {
+      return undefined;
+    }
+    const summary = formatTeamModelSummary(configuredProvider, configuredModel, configuredEffort);
+    return `${summary}${backendLabel ? ` · ${backendLabel}` : ''}${memorySuffix}`;
+  }
+
+  const summary = formatTeamModelSummary(configuredProvider, configuredModel, configuredEffort);
+  return `${summary}${backendLabel ? ` · ${backendLabel}` : ''}${memorySuffix}`;
+}

package/src/renderer/utils/memberSpawnStatusPolling.ts

@@ -0,0 +1,29 @@
+import type { MemberSpawnStatusEntry } from '@shared/types';
+
+export const MEMBER_SPAWN_STATUS_REFRESH_MS = 2_500;
+
+export function hasUnresolvedMemberSpawnStatus(
+  memberSpawnStatuses: Record<string, MemberSpawnStatusEntry> | undefined,
+  memberSpawnSnapshot:
+    | {
+        statuses?: Record<string, MemberSpawnStatusEntry>;
+        summary?: { pendingCount?: number };
+      }
+    | undefined
+): boolean {
+  if ((memberSpawnSnapshot?.summary?.pendingCount ?? 0) > 0) {
+    return true;
+  }
+  const entries = [
+    ...Object.values(memberSpawnStatuses ?? {}),
+    ...Object.values(memberSpawnSnapshot?.statuses ?? {}),
+  ];
+  return entries.some(
+    (entry) =>
+      entry.status === 'waiting' ||
+      entry.status === 'spawning' ||
+      entry.launchState === 'starting' ||
+      entry.launchState === 'runtime_pending_bootstrap' ||
+      entry.launchState === 'runtime_pending_permission'
+  );
+}

package/src/renderer/utils/mentionLinkify.ts

@@ -0,0 +1,90 @@
+/**
+ * Shared utility for converting @memberName and @teamName mentions in plain text
+ * to markdown links with mention:// and team:// protocols.
+ *
+ * Used by UserChatGroup, TeammateMessageItem, ActivityItem, TaskCommentsSection.
+ * MarkdownViewer already handles rendering mention:// and team:// links as colored badges.
+ */
+
+/**
+ * Convert `@memberName` in plain text to markdown links with mention:// protocol.
+ * Encodes color in the URL so MarkdownViewer can render colored badges without extra context.
+ * Greedy match: longer names are tried first to avoid partial matches.
+ *
+ * @param text - The plain text to process
+ * @param memberColorMap - Map of member name → color key (e.g. "blue", "red")
+ * @returns Text with @mentions replaced by markdown links
+ */
+export function linkifyMentionsInMarkdown(
+  text: string,
+  memberColorMap: Map<string, string>
+): string {
+  if (memberColorMap.size === 0) return text;
+
+  // Sort by name length descending for greedy matching
+  const names = [...memberColorMap.keys()].sort((a, b) => b.length - a.length);
+  const escaped = names.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  const pattern = new RegExp(
+    // eslint-disable-next-line no-useless-escape -- backslash-quote and backslash-hyphen needed in template literal for RegExp
+    `(^|[\\s(\\[{"\'])@(${escaped.join('|')})(?=[\\s,.:;!?)\\]}'\u2019-]|$)`,
+    'gi'
+  );
+
+  return text.replace(pattern, (_match: string, prefix: string, name: string) => {
+    // Find the canonical name (case-insensitive lookup)
+    const canonical = names.find((n) => n.toLowerCase() === name.toLowerCase()) ?? name;
+    const color = memberColorMap.get(canonical) ?? '';
+    return `${prefix}[@${canonical}](mention://${encodeURIComponent(color)}/${encodeURIComponent(canonical)})`;
+  });
+}
+
+/**
+ * Convert `@teamName` in plain text to markdown links with team:// protocol.
+ * Greedy match: longer names are tried first to avoid partial matches.
+ *
+ * @param text - The plain text to process
+ * @param teamNames - Set or array of known team names
+ * @returns Text with @teamName replaced by markdown links
+ */
+export function linkifyTeamMentionsInMarkdown(
+  text: string,
+  teamNames: ReadonlySet<string> | readonly string[]
+): string {
+  const names: readonly string[] = Array.isArray(teamNames) ? teamNames : [...teamNames];
+  if (names.length === 0) return text;
+
+  // Sort by name length descending for greedy matching
+  const sorted = [...names].sort((a, b) => b.length - a.length);
+  const escaped = sorted.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  const pattern = new RegExp(
+    // eslint-disable-next-line no-useless-escape -- backslash-quote and backslash-hyphen needed in template literal for RegExp
+    `(^|[\\s(\\[{"\'])@(${escaped.join('|')})(?=[\\s,.:;!?)\\]}'\u2019-]|$)`,
+    'gi'
+  );
+
+  return text.replace(pattern, (_match: string, prefix: string, name: string) => {
+    const canonical = sorted.find((n) => n.toLowerCase() === name.toLowerCase()) ?? name;
+    return `${prefix}[${canonical}](team://${encodeURIComponent(canonical)})`;
+  });
+}
+
+/**
+ * Apply both member and team linkification. Team names are matched first to avoid
+ * team names being captured as member mentions when they share similar names.
+ *
+ * @param text - The plain text to process
+ * @param memberColorMap - Map of member name → color key
+ * @param teamNames - Known team names
+ * @returns Text with both @member and @team mentions replaced by markdown links
+ */
+export function linkifyAllMentionsInMarkdown(
+  text: string,
+  memberColorMap: Map<string, string>,
+  teamNames: ReadonlySet<string> | readonly string[] = []
+): string {
+  // Apply team linkification first (team names tend to be longer / more specific)
+  let result = linkifyTeamMentionsInMarkdown(text, teamNames);
+  // Then member linkification on the remaining text
+  result = linkifyMentionsInMarkdown(result, memberColorMap);
+  return result;
+}

package/src/renderer/utils/mentionSuggestions.ts

@@ -0,0 +1,34 @@
+import type { MentionSuggestion } from '@renderer/types/mention';
+
+export function getSuggestionTriggerChar(suggestion: MentionSuggestion): '@' | '#' | '/' {
+  if (suggestion.type === 'task') return '#';
+  if (suggestion.type === 'command' || suggestion.type === 'skill') return '/';
+  return '@';
+}
+
+export function getSuggestionInsertionText(suggestion: MentionSuggestion): string {
+  if (suggestion.type === 'command' || suggestion.type === 'skill') {
+    return suggestion.command?.slice(1) ?? suggestion.insertText ?? suggestion.name;
+  }
+  return suggestion.insertText ?? suggestion.name;
+}
+
+export function doesSuggestionMatchQuery(suggestion: MentionSuggestion, query: string): boolean {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) return true;
+
+  const haystacks = [
+    suggestion.name,
+    suggestion.subtitle,
+    suggestion.description,
+    suggestion.relativePath,
+    suggestion.searchText,
+    suggestion.teamDisplayName,
+    suggestion.teamName,
+    suggestion.command,
+  ]
+    .filter(Boolean)
+    .map((value) => value!.toLowerCase());
+
+  return haystacks.some((value) => value.includes(normalizedQuery));
+}

package/src/renderer/utils/mergeTeamMessages.ts

@@ -0,0 +1,27 @@
+import { toMessageKey } from './teamMessageKey';
+
+import type { InboxMessage } from '@shared/types';
+
+function compareMessages(a: InboxMessage, b: InboxMessage): number {
+  const diff = Date.parse(b.timestamp) - Date.parse(a.timestamp);
+  if (diff !== 0) return diff;
+  return toMessageKey(a).localeCompare(toMessageKey(b));
+}
+
+/**
+ * Merge multiple message arrays into one newest-first list with stable deduplication.
+ *
+ * Later arrays win for duplicate keys so callers can overlay fresher/live message data
+ * on top of paginated history without losing already-loaded older pages.
+ */
+export function mergeTeamMessages(...messageLists: readonly InboxMessage[][]): InboxMessage[] {
+  const merged = new Map<string, InboxMessage>();
+
+  for (const list of messageLists) {
+    for (const message of list) {
+      merged.set(toMessageKey(message), message);
+    }
+  }
+
+  return Array.from(merged.values()).sort(compareMessages);
+}

package/src/renderer/utils/messageRenderEquality.ts

@@ -0,0 +1,158 @@
+import { toMessageKey } from '@renderer/utils/teamMessageKey';
+
+import type { AttachmentMeta, InboxMessage, TaskRef, ToolCallMeta } from '@shared/types';
+
+export function areStringArraysEqual(
+  prev: readonly string[] | undefined,
+  next: readonly string[] | undefined
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  if (prev.length !== next.length) return false;
+
+  for (let i = 0; i < prev.length; i++) {
+    if (prev[i] !== next[i]) return false;
+  }
+
+  return true;
+}
+
+export function areStringMapsEqual(
+  prev: ReadonlyMap<string, string> | undefined,
+  next: ReadonlyMap<string, string> | undefined
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  if (prev.size !== next.size) return false;
+
+  for (const [key, value] of prev) {
+    if (next.get(key) !== value) return false;
+  }
+
+  return true;
+}
+
+export function areTaskRefsEqual(prev?: readonly TaskRef[], next?: readonly TaskRef[]): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  if (prev.length !== next.length) return false;
+
+  for (let i = 0; i < prev.length; i++) {
+    if (
+      prev[i].taskId !== next[i].taskId ||
+      prev[i].displayId !== next[i].displayId ||
+      prev[i].teamName !== next[i].teamName
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function areAttachmentsEqual(
+  prev?: readonly AttachmentMeta[],
+  next?: readonly AttachmentMeta[]
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  if (prev.length !== next.length) return false;
+
+  for (let i = 0; i < prev.length; i++) {
+    if (
+      prev[i].id !== next[i].id ||
+      prev[i].filename !== next[i].filename ||
+      prev[i].mimeType !== next[i].mimeType ||
+      prev[i].size !== next[i].size
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function areToolCallsEqual(
+  prev?: readonly ToolCallMeta[],
+  next?: readonly ToolCallMeta[]
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  if (prev.length !== next.length) return false;
+
+  for (let i = 0; i < prev.length; i++) {
+    if (prev[i].name !== next[i].name || prev[i].preview !== next[i].preview) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function areSlashCommandsEqual(
+  prev?: InboxMessage['slashCommand'],
+  next?: InboxMessage['slashCommand']
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  return (
+    prev.name === next.name &&
+    prev.command === next.command &&
+    prev.args === next.args &&
+    prev.knownDescription === next.knownDescription
+  );
+}
+
+export function areCommandOutputsEqual(
+  prev?: InboxMessage['commandOutput'],
+  next?: InboxMessage['commandOutput']
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return !prev && !next;
+  return prev.stream === next.stream && prev.commandLabel === next.commandLabel;
+}
+
+export function areInboxMessagesEquivalentForRender(
+  prev: InboxMessage,
+  next: InboxMessage
+): boolean {
+  if (prev === next) return true;
+  if (toMessageKey(prev) !== toMessageKey(next)) return false;
+  if (prev.messageId !== next.messageId) return false;
+  if (prev.timestamp !== next.timestamp) return false;
+  if (prev.from !== next.from) return false;
+  if (prev.to !== next.to) return false;
+  if (prev.text !== next.text) return false;
+  if (prev.summary !== next.summary) return false;
+  if (prev.color !== next.color) return false;
+  if (prev.read !== next.read) return false;
+  if (prev.relayOfMessageId !== next.relayOfMessageId) return false;
+  if (prev.source !== next.source) return false;
+  if (prev.leadSessionId !== next.leadSessionId) return false;
+  if (prev.toolSummary !== next.toolSummary) return false;
+  if (prev.messageKind !== next.messageKind) return false;
+
+  return (
+    areTaskRefsEqual(prev.taskRefs, next.taskRefs) &&
+    areAttachmentsEqual(prev.attachments, next.attachments) &&
+    areSlashCommandsEqual(prev.slashCommand, next.slashCommand) &&
+    areCommandOutputsEqual(prev.commandOutput, next.commandOutput)
+  );
+}
+
+export function areThoughtMessagesEquivalentForRender(
+  prev: InboxMessage,
+  next: InboxMessage
+): boolean {
+  if (prev === next) return true;
+  if (toMessageKey(prev) !== toMessageKey(next)) return false;
+  if (prev.messageId !== next.messageId) return false;
+  if (prev.timestamp !== next.timestamp) return false;
+  if (prev.text !== next.text) return false;
+  if (prev.toolSummary !== next.toolSummary) return false;
+
+  return (
+    areTaskRefsEqual(prev.taskRefs, next.taskRefs) &&
+    areToolCallsEqual(prev.toolCalls, next.toolCalls)
+  );
+}