@yancyyu/openhermit 1.5.8

package/src/renderer/utils/taskReferenceUtils.ts

@@ -0,0 +1,331 @@
+import { getSuggestionInsertionText } from '@renderer/utils/mentionSuggestions';
+
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type { TaskRef } from '@shared/types';
+
+const TASK_REF_REGEX = /#([A-Za-z0-9-]+)\b/g;
+const TASK_META_START = '\u2063';
+const TASK_META_END = '\u2064';
+const ZERO_WIDTH_ALPHABET = ['\u200B', '\u200C', '\u200D', '\u2060'] as const;
+const ZERO_WIDTH_TO_BITS = new Map(
+  ZERO_WIDTH_ALPHABET.map((char, index) => [char, index] as const)
+);
+
+function isAllowedTaskRefBoundary(char: string | undefined): boolean {
+  if (!char) return true;
+  return !/\w/.test(char);
+}
+
+function buildSuggestionsByRef(
+  taskSuggestions: MentionSuggestion[]
+): Map<string, MentionSuggestion[]> {
+  const suggestionsByRef = new Map<string, MentionSuggestion[]>();
+
+  for (const suggestion of taskSuggestions) {
+    if (suggestion.type !== 'task') continue;
+    const ref = getSuggestionInsertionText(suggestion).trim().toLowerCase();
+    if (!ref) continue;
+
+    const existing = suggestionsByRef.get(ref);
+    if (existing) {
+      existing.push(suggestion);
+    } else {
+      suggestionsByRef.set(ref, [suggestion]);
+    }
+  }
+
+  return suggestionsByRef;
+}
+
+function resolveTaskSuggestion(candidates: MentionSuggestion[]): MentionSuggestion | null {
+  if (candidates.length === 0) return null;
+
+  const currentTeamCandidate = candidates.find((candidate) => candidate.isCurrentTeamTask);
+  if (currentTeamCandidate) return currentTeamCandidate;
+
+  if (candidates.length === 1) return candidates[0];
+
+  return null;
+}
+
+export interface TaskReferenceMatch {
+  start: number;
+  end: number;
+  raw: string;
+  ref: string;
+  suggestion: MentionSuggestion;
+  encoded: boolean;
+}
+
+interface EncodedTaskMetadata {
+  taskId: string;
+  teamName: string;
+  displayId: string;
+}
+
+interface EncodedTaskMetadataMatch {
+  metadata: EncodedTaskMetadata;
+  end: number;
+}
+
+interface ParsedTaskLinkHref {
+  taskId: string;
+  teamName?: string;
+  displayId?: string;
+}
+
+function encodeZeroWidthPayload(value: string): string {
+  const bytes = new TextEncoder().encode(value);
+  let encoded = '';
+
+  for (const byte of bytes) {
+    encoded += ZERO_WIDTH_ALPHABET[(byte >> 6) & 0b11];
+    encoded += ZERO_WIDTH_ALPHABET[(byte >> 4) & 0b11];
+    encoded += ZERO_WIDTH_ALPHABET[(byte >> 2) & 0b11];
+    encoded += ZERO_WIDTH_ALPHABET[byte & 0b11];
+  }
+
+  return encoded;
+}
+
+function decodeZeroWidthPayload(value: string): string | null {
+  if (value.length % 4 !== 0) return null;
+
+  const bytes = new Uint8Array(value.length / 4);
+  for (let i = 0; i < value.length; i += 4) {
+    const a = ZERO_WIDTH_TO_BITS.get(value.charAt(i) as (typeof ZERO_WIDTH_ALPHABET)[number]);
+    const b = ZERO_WIDTH_TO_BITS.get(value.charAt(i + 1) as (typeof ZERO_WIDTH_ALPHABET)[number]);
+    const c = ZERO_WIDTH_TO_BITS.get(value.charAt(i + 2) as (typeof ZERO_WIDTH_ALPHABET)[number]);
+    const d = ZERO_WIDTH_TO_BITS.get(value.charAt(i + 3) as (typeof ZERO_WIDTH_ALPHABET)[number]);
+    if (a == null || b == null || c == null || d == null) return null;
+    bytes[i / 4] = (a << 6) | (b << 4) | (c << 2) | d;
+  }
+
+  try {
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+function extractEncodedTaskMetadata(
+  text: string,
+  position: number
+): EncodedTaskMetadataMatch | null {
+  if (text[position] !== TASK_META_START) return null;
+
+  const end = text.indexOf(TASK_META_END, position + 1);
+  if (end === -1) return null;
+
+  const encodedPayload = text.slice(position + 1, end);
+  const decodedPayload = decodeZeroWidthPayload(encodedPayload);
+  if (!decodedPayload) return null;
+
+  try {
+    const parsed = JSON.parse(decodedPayload) as EncodedTaskMetadata;
+    if (!parsed.taskId || !parsed.teamName || !parsed.displayId) return null;
+    return {
+      metadata: parsed,
+      end: end + 1,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function buildTaskSuggestionFromMetadata(
+  metadata: EncodedTaskMetadata,
+  taskSuggestions: MentionSuggestion[]
+): MentionSuggestion {
+  return (
+    taskSuggestions.find(
+      (suggestion) =>
+        suggestion.type === 'task' &&
+        suggestion.taskId === metadata.taskId &&
+        suggestion.teamName === metadata.teamName
+    ) ?? {
+      id: `task:${metadata.teamName}:${metadata.taskId}`,
+      name: metadata.displayId,
+      type: 'task',
+      taskId: metadata.taskId,
+      teamName: metadata.teamName,
+      teamDisplayName: metadata.teamName,
+    }
+  );
+}
+
+function buildTaskRefFromSuggestion(
+  suggestion: MentionSuggestion,
+  displayId: string
+): TaskRef | null {
+  if (!suggestion.taskId || !suggestion.teamName) {
+    return null;
+  }
+  return {
+    taskId: suggestion.taskId,
+    displayId,
+    teamName: suggestion.teamName,
+  };
+}
+
+export function createEncodedTaskReference(
+  displayId: string,
+  taskId: string,
+  teamName: string
+): string {
+  const encodedPayload = encodeZeroWidthPayload(
+    JSON.stringify({
+      displayId,
+      taskId,
+      teamName,
+    } satisfies EncodedTaskMetadata)
+  );
+  return `#${displayId}${TASK_META_START}${encodedPayload}${TASK_META_END}`;
+}
+
+export function buildTaskLinkHref(taskRef: TaskRef): string {
+  return `task://${encodeURIComponent(taskRef.taskId)}?team=${encodeURIComponent(taskRef.teamName)}&display=${encodeURIComponent(taskRef.displayId)}`;
+}
+
+export function parseTaskLinkHref(href: string): ParsedTaskLinkHref | null {
+  if (!href.startsWith('task://')) return null;
+  try {
+    const raw = href.slice('task://'.length);
+    if (!raw) return null;
+
+    const queryIndex = raw.indexOf('?');
+    if (queryIndex === -1) {
+      return {
+        taskId: decodeURIComponent(raw),
+      };
+    }
+
+    const taskIdPart = raw.slice(0, queryIndex);
+    const search = new URLSearchParams(raw.slice(queryIndex + 1));
+    const teamName = search.get('team');
+    const displayId = search.get('display');
+    return {
+      taskId: decodeURIComponent(taskIdPart),
+      teamName: teamName ? decodeURIComponent(teamName) : undefined,
+      displayId: displayId ? decodeURIComponent(displayId) : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function linkifyTaskIdsInMarkdown(text: string, taskRefs?: TaskRef[]): string {
+  if (!text) return text;
+
+  const orderedTaskRefs = taskRefs ?? [];
+  let taskRefIndex = 0;
+  let result = '';
+  let cursor = 0;
+
+  for (const match of text.matchAll(TASK_REF_REGEX)) {
+    const raw = match[0];
+    const ref = match[1];
+    const start = match.index ?? -1;
+    if (start < 0) continue;
+
+    result += text.slice(cursor, start);
+    const preceding = start > 0 ? text[start - 1] : undefined;
+    if (!isAllowedTaskRefBoundary(preceding)) {
+      result += raw;
+      cursor = start + raw.length;
+      continue;
+    }
+
+    const structuredTaskRef =
+      taskRefIndex < orderedTaskRefs.length &&
+      orderedTaskRefs[taskRefIndex]?.displayId.toLowerCase() === ref.toLowerCase()
+        ? orderedTaskRefs[taskRefIndex++]
+        : undefined;
+    const href = structuredTaskRef ? buildTaskLinkHref(structuredTaskRef) : `task://${ref}`;
+    result += `[${raw}](${href})`;
+    cursor = start + raw.length;
+  }
+
+  result += text.slice(cursor);
+  return result;
+}
+
+export function stripEncodedTaskReferenceMetadata(text: string): string {
+  if (!text.includes(TASK_META_START)) return text;
+
+  let result = '';
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = text.indexOf(TASK_META_START, cursor);
+    if (start === -1) {
+      result += text.slice(cursor);
+      break;
+    }
+
+    result += text.slice(cursor, start);
+    const match = extractEncodedTaskMetadata(text, start);
+    cursor = match ? match.end : start + 1;
+  }
+
+  return result;
+}
+
+export function findTaskReferenceMatches(
+  text: string,
+  taskSuggestions: MentionSuggestion[]
+): TaskReferenceMatch[] {
+  if (!text) return [];
+
+  const suggestionsByRef = buildSuggestionsByRef(taskSuggestions);
+
+  const matches: TaskReferenceMatch[] = [];
+  for (const match of text.matchAll(TASK_REF_REGEX)) {
+    const raw = match[0];
+    const ref = match[1];
+    const start = match.index ?? -1;
+    if (start < 0) continue;
+
+    const preceding = start > 0 ? text[start - 1] : undefined;
+    if (!isAllowedTaskRefBoundary(preceding)) continue;
+
+    const metadataMatch = extractEncodedTaskMetadata(text, start + raw.length);
+    const suggestion = metadataMatch
+      ? buildTaskSuggestionFromMetadata(metadataMatch.metadata, taskSuggestions)
+      : resolveTaskSuggestion(suggestionsByRef.get(ref.toLowerCase()) ?? []);
+    if (!suggestion) continue;
+
+    matches.push({
+      start,
+      end: metadataMatch?.end ?? start + raw.length,
+      raw,
+      ref,
+      suggestion,
+      encoded: metadataMatch != null,
+    });
+  }
+
+  return matches;
+}
+
+export function extractTaskRefsFromText(
+  text: string,
+  taskSuggestions: MentionSuggestion[]
+): TaskRef[] {
+  if (!text) return [];
+
+  return findTaskReferenceMatches(text, taskSuggestions)
+    .map((match) => {
+      if (match.encoded) {
+        const metadataMatch = extractEncodedTaskMetadata(text, match.start + match.raw.length);
+        if (!metadataMatch) return null;
+        return {
+          taskId: metadataMatch.metadata.taskId,
+          displayId: metadataMatch.metadata.displayId,
+          teamName: metadataMatch.metadata.teamName,
+        } satisfies TaskRef;
+      }
+
+      return buildTaskRefFromSuggestion(match.suggestion, match.ref);
+    })
+    .filter((taskRef): taskRef is TaskRef => taskRef !== null);
+}

package/src/renderer/utils/teamEffortOptions.ts

@@ -0,0 +1,150 @@
+import { isTeamEffortLevelForProvider } from '@shared/utils/effortLevels';
+
+import type { CliProviderStatus, EffortLevel, TeamProviderId } from '@shared/types';
+
+const BASE_EFFORT_OPTIONS = [{ value: '', label: '默认' }] as const;
+const SAFE_SHARED_EFFORTS = new Set<EffortLevel>(['low', 'medium', 'high']);
+
+export const TEAM_EFFORT_LABELS: Record<EffortLevel, string> = {
+  none: '无',
+  minimal: '极低',
+  low: '低',
+  medium: '中',
+  high: '高',
+  max: 'Max',
+  xhigh: 'XHigh',
+};
+
+interface TeamEffortOption {
+  value: string;
+  label: string;
+}
+
+function getCatalogModel(
+  providerId: TeamProviderId | undefined,
+  providerStatus: CliProviderStatus | null | undefined,
+  model: string | undefined
+): NonNullable<CliProviderStatus['modelCatalog']>['models'][number] | null {
+  const catalog = providerStatus?.modelCatalog;
+  if (!providerId || catalog?.providerId !== providerId) {
+    return null;
+  }
+
+  const explicitModel = model?.trim();
+  if (explicitModel) {
+    return (
+      catalog.models.find(
+        (item) => item.launchModel === explicitModel || item.id === explicitModel
+      ) ?? null
+    );
+  }
+
+  return (
+    catalog.models.find((item) => item.id === catalog.defaultModelId) ??
+    catalog.models.find((item) => item.launchModel === catalog.defaultLaunchModel) ??
+    catalog.models.find((item) => item.isDefault) ??
+    null
+  );
+}
+
+function normalizeEfforts(
+  providerId: TeamProviderId,
+  candidateEfforts: readonly EffortLevel[],
+  configPassthrough: boolean
+): EffortLevel[] {
+  if (providerId === 'codex' && configPassthrough) {
+    return [...candidateEfforts];
+  }
+
+  return candidateEfforts.filter((effort) => SAFE_SHARED_EFFORTS.has(effort));
+}
+
+export function getTeamEffortOptions(params: {
+  providerId?: TeamProviderId;
+  model?: string;
+  limitContext?: boolean;
+  providerStatus?: CliProviderStatus | null;
+}): readonly TeamEffortOption[] {
+  const providerId = params.providerId;
+  if (!providerId) {
+    return BASE_EFFORT_OPTIONS;
+  }
+
+  if (providerId === 'anthropic') {
+    const catalogModel = getCatalogModel(providerId, params.providerStatus, params.model);
+    const catalogEfforts = catalogModel?.supportedReasoningEfforts ?? [];
+
+    // If catalog is available and reports no supported efforts, only show Default.
+    if (catalogModel && catalogEfforts.length === 0) {
+      return [{ value: '', label: '默认' }];
+    }
+
+    // If catalog reports specific efforts, use those.
+    if (catalogEfforts.length > 0) {
+      const normalized = normalizeEfforts(providerId, catalogEfforts as EffortLevel[], false);
+      if (normalized.length > 0) {
+        return [
+          { value: '', label: '默认' },
+          ...normalized.map((effort: EffortLevel) => ({
+            value: effort,
+            label: TEAM_EFFORT_LABELS[effort],
+          })),
+        ];
+      }
+    }
+
+    return [
+      { value: '', label: '默认' },
+      { value: 'low', label: TEAM_EFFORT_LABELS.low },
+      { value: 'medium', label: TEAM_EFFORT_LABELS.medium },
+      { value: 'high', label: TEAM_EFFORT_LABELS.high },
+    ];
+  }
+
+  const runtimeCapability = params.providerStatus?.runtimeCapabilities?.reasoningEffort;
+  const catalogModel = getCatalogModel(providerId, params.providerStatus, params.model);
+  const catalogEfforts = catalogModel?.supportedReasoningEfforts ?? [];
+  const candidateEfforts =
+    catalogEfforts.length > 0
+      ? catalogEfforts
+      : ((runtimeCapability?.values ?? []) as EffortLevel[]);
+  const efforts = normalizeEfforts(
+    providerId,
+    candidateEfforts,
+    runtimeCapability?.configPassthrough === true
+  );
+  const defaultLabel = catalogModel?.defaultReasoningEffort
+    ? `默认（${TEAM_EFFORT_LABELS[catalogModel.defaultReasoningEffort]}）`
+    : '默认';
+
+  if (providerId === 'codex') {
+    const fallbackEfforts =
+      efforts.length > 0 ? efforts : (['low', 'medium', 'high'] as EffortLevel[]);
+    return [
+      { value: '', label: defaultLabel },
+      ...fallbackEfforts.map((effort) => ({
+        value: effort,
+        label: TEAM_EFFORT_LABELS[effort],
+      })),
+    ];
+  }
+
+  return [
+    { value: '', label: defaultLabel },
+    { value: 'low', label: TEAM_EFFORT_LABELS.low },
+    { value: 'medium', label: TEAM_EFFORT_LABELS.medium },
+    { value: 'high', label: TEAM_EFFORT_LABELS.high },
+  ];
+}
+
+export function resolveTeamEffortForLaunch(params: {
+  providerId?: TeamProviderId;
+  selectedEffort?: string | null;
+}): EffortLevel | undefined {
+  const providerId = params.providerId;
+  if (!providerId || !isTeamEffortLevelForProvider(params.selectedEffort, providerId)) {
+    return undefined;
+  }
+
+  return params.selectedEffort;
+}

package/src/renderer/utils/teamLaunchSummaryCopy.ts

@@ -0,0 +1,17 @@
+export function buildPendingRuntimeSummaryCopy(input: {
+  confirmedCount?: number | null;
+  expectedMemberCount?: number | null;
+  memberCount?: number | null;
+  runtimeProcessPendingCount?: number | null;
+  includePeriod?: boolean;
+}): string {
+  const pendingCount = input.runtimeProcessPendingCount ?? 0;
+  if (pendingCount <= 0) {
+    return input.includePeriod
+      ? 'Last launch is still reconciling.'
+      : 'Last launch is still reconciling';
+  }
+  const expectedCount = input.expectedMemberCount ?? input.memberCount ?? 0;
+  const message = `Last launch is still reconciling - ${input.confirmedCount ?? 0}/${expectedCount} teammates confirmed alive, ${pendingCount} runtime${pendingCount === 1 ? '' : 's'} still awaiting confirmation`;
+  return input.includePeriod ? `${message}.` : message;
+}

package/src/renderer/utils/teamMessageExpandStorage.ts

@@ -0,0 +1,39 @@
+const STORAGE_PREFIX = 'team-msg-expanded:';
+
+function storageKey(teamName: string): string {
+  return `${STORAGE_PREFIX}${teamName}`;
+}
+
+export function getExpandedOverrides(teamName: string): Set<string> {
+  try {
+    const raw = localStorage.getItem(storageKey(teamName));
+    if (!raw) return new Set();
+    const arr = JSON.parse(raw) as unknown;
+    if (!Array.isArray(arr)) return new Set();
+    return new Set(arr.filter((x): x is string => typeof x === 'string'));
+  } catch {
+    return new Set();
+  }
+}
+
+export function addExpanded(teamName: string, messageKey: string): void {
+  try {
+    const set = getExpandedOverrides(teamName);
+    if (set.has(messageKey)) return;
+    set.add(messageKey);
+    localStorage.setItem(storageKey(teamName), JSON.stringify([...set]));
+  } catch {
+    // quota or disabled
+  }
+}
+
+export function removeExpanded(teamName: string, messageKey: string): void {
+  try {
+    const set = getExpandedOverrides(teamName);
+    if (!set.has(messageKey)) return;
+    set.delete(messageKey);
+    localStorage.setItem(storageKey(teamName), JSON.stringify([...set]));
+  } catch {
+    // quota or disabled
+  }
+}

package/src/renderer/utils/teamMessageFiltering.ts

@@ -0,0 +1,95 @@
+import {
+  getSanitizedInboxMessageSummary,
+  getSanitizedInboxMessageText,
+} from '@renderer/utils/bootstrapPromptSanitizer';
+import { shouldKeepIdleMessageInActivityWhenNoiseHidden } from '@renderer/utils/idleNotificationSemantics';
+import { isInboxNoiseMessage } from '@shared/utils/inboxNoise';
+
+import type { InboxMessage } from '@shared/types';
+
+export interface TeamMessagesFilter {
+  from: Set<string>;
+  to: Set<string>;
+  showNoise: boolean;
+}
+
+export function filterTeamMessages(
+  messages: InboxMessage[],
+  options: {
+    includePassiveIdlePeerSummariesWhenNoiseHidden?: boolean;
+    timeWindow?: { start: number; end: number } | null;
+    filter: TeamMessagesFilter;
+    searchQuery: string;
+  }
+): InboxMessage[] {
+  const {
+    includePassiveIdlePeerSummariesWhenNoiseHidden = false,
+    timeWindow,
+    filter,
+    searchQuery,
+  } = options;
+
+  let list = messages.filter((m) => m.messageKind !== 'task_comment_notification');
+  if (timeWindow) {
+    list = list.filter((m) => {
+      const ts = new Date(m.timestamp).getTime();
+      return ts >= timeWindow.start && ts < timeWindow.end;
+    });
+  }
+  if (!filter.showNoise) {
+    list = list.filter((m) => {
+      const text = typeof m.text === 'string' ? m.text : '';
+      if (!isInboxNoiseMessage(text)) return true;
+      return (
+        includePassiveIdlePeerSummariesWhenNoiseHidden &&
+        shouldKeepIdleMessageInActivityWhenNoiseHidden(text)
+      );
+    });
+  }
+
+  const hasFrom = filter.from.size > 0;
+  const hasTo = filter.to.size > 0;
+  if (hasFrom && hasTo) {
+    list = list.filter((m) => {
+      const fromMatch = Boolean(m.from?.trim() && filter.from.has(m.from.trim()));
+      const toMatch = Boolean(m.to?.trim() && filter.to.has(m.to.trim()));
+      return fromMatch && toMatch;
+    });
+  } else if (hasFrom || hasTo) {
+    list = list.filter((m) => {
+      if (hasFrom) return Boolean(m.from?.trim() && filter.from.has(m.from.trim()));
+      if (hasTo) return Boolean(m.to?.trim() && filter.to.has(m.to.trim()));
+      return true;
+    });
+  }
+
+  const q = searchQuery.trim().toLowerCase();
+  if (q) {
+    list = list.filter((m) => {
+      const text = getSanitizedInboxMessageText(m).toLowerCase();
+      const summary = getSanitizedInboxMessageSummary(m).toLowerCase();
+      const from = (m.from ?? '').toLowerCase();
+      const to = (m.to ?? '').toLowerCase();
+      return text.includes(q) || summary.includes(q) || from.includes(q) || to.includes(q);
+    });
+  }
+
+  const visibleMessageIds = new Set(
+    list
+      .map((m) => (typeof m.messageId === 'string' ? m.messageId.trim() : ''))
+      .filter((id) => id.length > 0)
+  );
+
+  return list.filter((m) => {
+    const relayOfMessageId =
+      typeof m.relayOfMessageId === 'string' ? m.relayOfMessageId.trim() : '';
+    if (!relayOfMessageId) {
+      return true;
+    }
+    const ownMessageId = typeof m.messageId === 'string' ? m.messageId.trim() : '';
+    if (relayOfMessageId === ownMessageId) {
+      return true;
+    }
+    return !visibleMessageIds.has(relayOfMessageId);
+  });
+}

package/src/renderer/utils/teamMessageKey.ts

@@ -0,0 +1,14 @@
+import type { InboxMessage } from '@shared/types';
+
+const FALLBACK_SLICE = 80;
+
+/**
+ * Stable key for a team message. Prefer messageId; otherwise build from timestamp, from, and text.
+ */
+export function toMessageKey(message: InboxMessage): string {
+  if (typeof message.messageId === 'string' && message.messageId.trim().length > 0) {
+    return message.messageId;
+  }
+  const text = (message.text ?? '').slice(0, FALLBACK_SLICE);
+  return `${message.timestamp}-${message.from}-${text}`;
+}

package/src/renderer/utils/teamMessageReadStorage.ts

@@ -0,0 +1,49 @@
+const STORAGE_PREFIX = 'team-messages-read:';
+
+function storageKey(teamName: string): string {
+  return `${STORAGE_PREFIX}${teamName}`;
+}
+
+export function getReadSet(teamName: string): Set<string> {
+  try {
+    const raw = localStorage.getItem(storageKey(teamName));
+    if (!raw) return new Set();
+    const arr = JSON.parse(raw) as unknown;
+    if (!Array.isArray(arr)) return new Set();
+    return new Set(arr.filter((x): x is string => typeof x === 'string'));
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * Mark a message as read and persist. If `fullSet` is provided, that set is written
+ * (avoids losing keys when a previous write failed). Otherwise reads from localStorage and adds one key.
+ */
+export function markRead(teamName: string, messageKey: string, fullSet?: Set<string>): void {
+  const toWrite =
+    fullSet ??
+    (() => {
+      const set = getReadSet(teamName);
+      if (set.has(messageKey)) return null;
+      set.add(messageKey);
+      return set;
+    })();
+  if (!toWrite) return;
+  try {
+    localStorage.setItem(storageKey(teamName), JSON.stringify([...toWrite]));
+  } catch {
+    // quota or disabled
+  }
+}
+
+/**
+ * Persist a full set of read keys at once (bulk mark-all-as-read).
+ */
+export function markBulkRead(teamName: string, fullSet: Set<string>): void {
+  try {
+    localStorage.setItem(storageKey(teamName), JSON.stringify([...fullSet]));
+  } catch {
+    // quota or disabled
+  }
+}