Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

fix(favorites): show unread notification indicators (#9609)

dev-rb5d1571947ab9
diff --git a/apps/web/AGENTS.md b/apps/web/AGENTS.md
index 7616ceed9c..14351cc941 100644
--- a/apps/web/AGENTS.md
+++ b/apps/web/AGENTS.md
@@ -537,6 +537,7 @@ resolved session ID; keep the existing `AgentSessionProvider` subscription to
pending edits against the persisted server snapshot instead of replaying an older one.
- Mobile dock customization shares the navigation island’s measured capacity; persist ordering per user with `mobile-dock-order.ts`, preserve gated destinations, and keep Search and More fixed. Reorder handles drag without a hold delay; the rest of each row scrolls.
- Share sidebar and mobile dock unread presence through `components/app/use-navigation-unread.ts`; keep badges reactive to read/done changes, guard all query data with `queryReadyGate` so pending preferences or paused queries cannot suspend the shell, and avoid fetching extra pages for counts.
+- Show notification unread dots on favorite rows in Chat, Tasks, Drive, and Reviews; reuse Chat's channel activity and the existing Soup entity hydration plus `getEntityNotifications` elsewhere, without a separate notification query or refresh registry. Never paginate favorites or the global notification feed just for dots.
- Name Home thread rows from their latest scoped notification, including document mentions and reactions; use the thread author only when no notification exists. Document rows whose newest outstanding notification is a comment, and calendar event rows whose newest is a join request, say who did it (`row-notification.ts`).
- Use `ChannelTitleIcon` for conversation breadcrumbs so DMs retain participant or agent avatars and named channels retain their pictures; suppress avatar actions inside breadcrumb buttons.
- Normalize thread-only conversation URLs in `channelsSearch` before Home, Chat, or touch views derive their message target.
@@ -659,7 +660,8 @@ resolved session ID; keep the existing `AgentSessionProvider` subscription to
- Keep CRM contacts explicitly included in the auxiliary GraphQL backfill;
bump its checkpoint version when changing the hydration input contract.
- Refresh the channel list's bounded unread edge when opening a conversation,
- including an empty unread result after a read on another device.
+ including an empty unread result after a read on another device. Include
+ off-page favorites in unread presence without adding them to section counts.
- Decide channel detail access from completed server results; bound confirmations of contradictory cache membership, preserve known unavailable state during retries, and keep unavailable routes registered for notification/reconnect refresh.
- Read folders for picking or moving through `createFolderList`
(`queries/storage/folder-list`): it matches the Drive sidebar's source, so a
diff --git a/apps/web/src/features/channels-view/components/rail/ChannelFavoriteRows.tsx b/apps/web/src/features/channels-view/components/rail/ChannelFavoriteRows.tsx
index 414539064a..27727bda07 100644
--- a/apps/web/src/features/channels-view/components/rail/ChannelFavoriteRows.tsx
+++ b/apps/web/src/features/channels-view/components/rail/ChannelFavoriteRows.tsx
@@ -4,6 +4,7 @@ import { FavoriteIcon } from '@app/features/favorites/FavoriteIcon';
import { useFavoriteDisplayName } from '@app/util/favorites';
import { ChannelMutedIndicator } from '@channel/components/ChannelMutedIndicator';
import { isTouchDevice } from '@core/mobile/isTouchDevice';
+import { UnreadIndicator } from '@entity/components/UnreadIndicator';
import CaretDownIcon from '@icon/system/regular/caret-down.svg';
import type { Favorite } from '@service-storage/generated/schemas/favorite';
import { cn } from '@ui';
@@ -75,6 +76,9 @@ export function ChannelFavoriteRow(props: { favorite: Favorite }) {
</ViewSidebar.Icon>
<span class="min-w-0 flex-1 truncate">{displayName()}</span>
<ChannelMutedIndicator muted={item().muted} />
+ <Show when={item().unread}>
+ <UnreadIndicator active />
+ </Show>
</ViewSidebar.Item>
);
diff --git a/apps/web/src/features/channels-view/components/rail/ChannelsRail.test.tsx b/apps/web/src/features/channels-view/components/rail/ChannelsRail.test.tsx
index 26dee96ca2..44b70d92b9 100644
--- a/apps/web/src/features/channels-view/components/rail/ChannelsRail.test.tsx
+++ b/apps/web/src/features/channels-view/components/rail/ChannelsRail.test.tsx
@@ -23,6 +23,11 @@ const mocks = vi.hoisted(() => ({
fetchChannel: vi.fn<(id: string) => Promise<ChannelEntity>>(),
bulkPreferences: vi.fn(),
favoriteId: undefined as string | undefined,
+ favorites: [] as Favorite[],
+ referencedChannels: [] as ChannelEntity[],
+ sectionsEnabled: true,
+ activityChannels: (): readonly ChannelEntity[] => [],
+ additionalActivityChannels: (): readonly ChannelEntity[] => [],
fetchGroupIds:
vi.fn<typeof import('../../queries')['fetchChannelGroupIds']>(),
hydrate:
@@ -221,7 +226,7 @@ vi.mock('@queries/channel-labels/channel-labels', () => ({
useSetChannelLabelMutation: () => ({}),
}));
vi.mock('@queries/favorites/favorites', () => ({
- useFavoritesData: () => () => ({ favorites: [] }),
+ useFavoritesData: () => () => ({ favorites: mocks.favorites }),
useReorderFavoritesMutation: () => ({ mutateAsync: vi.fn() }),
}));
vi.mock('@queries/soup/search', () => ({
@@ -251,7 +256,7 @@ vi.mock('../../channels-view-context', () => ({
},
},
tab: () => mocks.tab,
- sectionsEnabled: () => true,
+ sectionsEnabled: () => mocks.sectionsEnabled,
threadsEnabled: () => false,
selectedChannel: () => mocks.selected,
setSelectedChannel: mocks.select,
@@ -265,13 +270,12 @@ vi.mock('../../queries', () => ({
).values(),
],
useChannelsByIdsQuery: () => ({ isEnabled: false }),
- // What the real helper answers for the disabled lookup above.
- resolveReferencedChannels: (previous: ChannelEntity[]) => previous,
+ resolveReferencedChannels: () => mocks.referencedChannels,
}));
vi.mock('@queries/channel/by-ids', () => ({
useChannelsByIdsQuery: () => ({ isEnabled: false }),
useCachedChannelsByIds: () => ({
- channels: () => [],
+ channels: () => mocks.referencedChannels,
pendingIds: () => new Set<string>(),
failedIds: () => new Set<string>(),
error: () => undefined,
@@ -287,7 +291,15 @@ vi.mock('./SmartTagDialog', () => ({ promptSmartTag: vi.fn() }));
vi.mock('./ExpandedChannelsRail', () => ({ ExpandedChannelsRail: () => null }));
vi.mock('./hooks/useChannelCalls', () => ({ useChannelCalls: () => ({}) }));
vi.mock('./hooks/useChannelRailActivity', () => ({
- useChannelRailActivity: () => ({ unreadChannelIds: () => new Set<string>() }),
+ useChannelRailActivity: (
+ channels: () => readonly ChannelEntity[],
+ _calls: unknown,
+ additionalChannels: () => readonly ChannelEntity[] = () => []
+ ) => {
+ mocks.activityChannels = channels;
+ mocks.additionalActivityChannels = additionalChannels;
+ return { unreadChannelIds: () => new Set<string>() };
+ },
}));
vi.mock('./next/ExpandedChannelsRail', async (importOriginal) => {
const { ExpandedChannelsRail: RealRenderer } =
@@ -452,6 +464,9 @@ beforeEach(() => {
vi.clearAllMocks();
mocks.realRenderer = false;
mocks.focusedRow = undefined;
+ mocks.favorites = [];
+ mocks.referencedChannels = [];
+ mocks.sectionsEnabled = true;
mocks.listRows = undefined;
mocks.hotkeys.clear();
mocks.userId = 'viewer';
@@ -496,6 +511,31 @@ afterEach(() => {
vi.restoreAllMocks();
});
+it.each([false, true])(
+ 'tracks unread activity for favorites outside loaded channel pages with sections enabled: %s',
+ (enabled) => {
+ mocks.sectionsEnabled = enabled;
+ mocks.favorites = [
+ {
+ entityId: 'outside-page',
+ entityType: 'channel',
+ createdAt: '2026-01-01',
+ sortOrder: 0,
+ },
+ ];
+ mocks.referencedChannels = [{ ...channel, id: 'outside-page' }];
+
+ mount();
+
+ expect(mocks.additionalActivityChannels().map(({ id }) => id)).toContain(
+ 'outside-page'
+ );
+ expect(
+ mocks.activityChannels().some(({ id }) => id === 'outside-page')
+ ).toBe(enabled);
+ }
+);
+
it('delegates keyboard scrolling to the sectioned renderer instead of global indexes', () => {
mount();
mocks.scroll(0);
diff --git a/apps/web/src/features/channels-view/components/rail/ChannelsRail.tsx b/apps/web/src/features/channels-view/components/rail/ChannelsRail.tsx
index e10b1b6f0a..054d6ae37f 100644
--- a/apps/web/src/features/channels-view/components/rail/ChannelsRail.tsx
+++ b/apps/web/src/features/channels-view/components/rail/ChannelsRail.tsx
@@ -454,16 +454,17 @@ export function ChannelsRail(props: ChannelsRailProps) {
channelsById().get(channelId) ??
referencedChannels().find((channel) => channel.id === channelId);
+ const favoriteChannels = createMemo(() =>
+ favoriteChannelIds().flatMap((id) => channelById(id) ?? [])
+ );
const activityChannels = createMemo(() => {
if (!sectionsEnabled()) return allChannels();
- return deduplicateChannels([
- allChannels(),
- favoriteChannelIds().flatMap((id) => channelById(id) ?? []),
- ]);
+ return deduplicateChannels([allChannels(), favoriteChannels()]);
});
const channelActivity = useChannelRailActivity(
activityChannels,
- channelCalls
+ channelCalls,
+ favoriteChannels
);
const isLabelOpen = (labelId: string) =>
diff --git a/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.test.ts b/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.test.ts
index 7d47364044..2d565fae78 100644
--- a/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.test.ts
+++ b/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.test.ts
@@ -1,21 +1,31 @@
import type { ChannelEntity } from '@entity/types/entity';
import type { NotificationSource } from '@notifications/notification-source';
+import type { Favorite } from '@service-storage/generated/schemas/favorite';
import { createRoot, createSignal } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
const source = vi.hoisted(() => ({
notifications: vi.fn<NotificationSource['notifications']>(() => []),
+ mutedEntities: () => [],
subscribe: vi.fn(() => () => {}),
withLocalState: vi.fn<NonNullable<NotificationSource['withLocalState']>>(),
}));
vi.mock('@components/app/GlobalAppState', () => ({
useGlobalNotificationSource: () => source,
}));
-vi.mock('@entity/utils/notification', () => ({
- notificationIsRead: (n: { state: string }) => n.state !== 'unseen',
+const rail = vi.hoisted(() => ({
+ railId: 'rail',
+ selectedChannel: () => undefined,
+ list: { focus: { key: () => undefined } },
+ channelActivity: { unreadChannelIds: () => new Set<string>() },
+}));
+vi.mock('../ChannelsRailContext', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('../ChannelsRailContext')>()),
+ useChannelsRail: () => rail,
}));
import { useChannelRailActivity } from './useChannelRailActivity';
+import { useChannelRailFavoriteItemState } from './useChannelRailState';
const row = (
id: string,
@@ -73,6 +83,58 @@ describe('bounded channel unread indicators', () => {
expect(activity.unreadCount('channels')).toBe(1);
});
+ it.each(['seen', 'done'] as const)(
+ 'keeps favorite unread state aligned with channel reads, rollback, and new notifications after %s',
+ (state) => {
+ const [localState, setLocalState] = createSignal<typeof state>();
+ source.withLocalState.mockImplementation(
+ (notification) => localState() ?? notification.state
+ );
+ const [channels, setChannels] = createSignal([
+ row('favorite', [
+ { id: 'n1', state: 'unseen', createdAt: '2026-01-01' },
+ ]),
+ row('other', []),
+ ]);
+ const [favorite, setFavorite] = createSignal<Favorite>({
+ entityId: 'favorite',
+ entityType: 'channel',
+ createdAt: '2026-01-01',
+ sortOrder: 0,
+ });
+ const { item, activity } = createRoot((cleanup) => {
+ dispose = cleanup;
+ const activity = useChannelRailActivity(
+ () => channels().filter((channel) => channel.id === 'other'),
+ calls,
+ channels
+ );
+ rail.channelActivity = activity;
+ return { item: useChannelRailFavoriteItemState(favorite), activity };
+ });
+
+ expect(item().unread).toBe(true);
+ expect(activity.unreadCount('channels')).toBe(0);
+ expect(activity.targetChannelId('channels')).toBeUndefined();
+ setLocalState(state);
+ expect(item().unread).toBe(false);
+ setLocalState(undefined);
+ expect(item().unread).toBe(true);
+ setChannels([row('favorite', []), row('other', [])]);
+ expect(item().unread).toBe(false);
+ setChannels([
+ row('favorite', [
+ { id: 'n2', state: 'unseen', createdAt: '2026-01-02' },
+ ]),
+ row('other', []),
+ ]);
+ expect(item().unread).toBe(true);
+ setFavorite((current) => ({ ...current, entityId: 'other' }));
+ expect(item().unread).toBe(false);
+ expect(source.notifications).not.toHaveBeenCalled();
+ }
+ );
+
it.each(['seen', 'done'] as const)(
'clears dots, counts, and activity targets immediately on local %s, and restores them on rollback',
(state) => {
@@ -138,6 +200,22 @@ describe('bounded channel unread indicators', () => {
expect(source.notifications).not.toHaveBeenCalled();
});
+ it('prefers the loaded channel read state over an older favorite lookup', () => {
+ const activity = createRoot((cleanup) => {
+ dispose = cleanup;
+ return useChannelRailActivity(
+ () => [row('one', [])],
+ calls,
+ () => [
+ row('one', [{ id: 'n1', state: 'unseen', createdAt: '2026-01-01' }]),
+ ]
+ );
+ });
+
+ expect(activity.unreadChannelIds().size).toBe(0);
+ expect(activity.unreadCount('channels')).toBe(0);
+ });
+
it('uses one witness per channel without reading the global notification feed', () => {
const [channels, setChannels] = createSignal([
row('one', [{ id: 'n1', state: 'unseen', createdAt: '2026-01-01' }]),
diff --git a/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.ts b/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.ts
index 16c3315abd..28834ac7dc 100644
--- a/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.ts
+++ b/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailActivity.ts
@@ -28,7 +28,9 @@ type ChannelActivityTarget = {
export function useChannelRailActivity(
channels: Accessor<readonly ChannelEntity[]>,
- calls: ReturnType<typeof useChannelCalls>
+ calls: ReturnType<typeof useChannelCalls>,
+ /** Track favorites outside the lists without adding them to section counts. */
+ additionalChannels: Accessor<readonly ChannelEntity[]> = () => []
) {
const notificationSource = useGlobalNotificationSource();
const [activityTargets, setActivityTargets] = createStore<
@@ -60,7 +62,13 @@ export function useChannelRailActivity(
created_at: DateValue;
}[] = [];
const legacyChannelIds = new Set<string>();
- for (const channel of channels()) {
+ const notificationChannels = new Map(
+ [...additionalChannels(), ...channels()].map((channel) => [
+ channel.id,
+ channel,
+ ])
+ );
+ for (const channel of notificationChannels.values()) {
if (channel.unreadNotifications === undefined) {
legacyChannelIds.add(channel.id);
continue;
diff --git a/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailState.ts b/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailState.ts
index 49bd965f75..b0759febc0 100644
--- a/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailState.ts
+++ b/apps/web/src/features/channels-view/components/rail/hooks/useChannelRailState.ts
@@ -70,6 +70,9 @@ export function useChannelRailFavoriteItemState(favorite: Accessor<Favorite>) {
muted:
muteItem !== undefined &&
isMutedItem(notificationSource.mutedEntities(), muteItem),
+ unread:
+ current.entityType === 'channel' &&
+ rail.channelActivity.unreadChannelIds().has(current.entityId),
};
});
}
diff --git a/apps/web/src/features/drive-view/views/drive-sidebar.tsx b/apps/web/src/features/drive-view/views/drive-sidebar.tsx
index a4c00e34cf..a2c0c9a11e 100644
--- a/apps/web/src/features/drive-view/views/drive-sidebar.tsx
+++ b/apps/web/src/features/drive-view/views/drive-sidebar.tsx
@@ -7,6 +7,7 @@ import {
import { ConnectorImportSidebar } from '@app/features/connector-import/connector-import';
import { FavoriteContextMenu } from '@app/features/favorites/FavoriteContextMenu';
import { FavoriteIcon } from '@app/features/favorites/FavoriteIcon';
+import { FavoriteUnreadIndicator } from '@app/features/favorites/FavoriteUnreadIndicator';
import { createFolderDropTargets } from '@app/features/next-soup/actions';
import { useFavoriteDisplayName } from '@app/util/favorites';
import { createScrollTopFade } from '@core/util/createScrollTopFade';
@@ -83,6 +84,7 @@ function DriveFavorite(props: { favorite: Favorite; onNavigate?: () => void }) {
<FavoriteIcon favorite={props.favorite} class="size-4" />
</ViewSidebar.Icon>
<span class="truncate">{name()}</span>
+ <FavoriteUnreadIndicator favorite={props.favorite} />
</ViewSidebar.Item>
</FavoriteContextMenu>
);
diff --git a/apps/web/src/features/favorites/FavoriteUnreadIndicator.tsx b/apps/web/src/features/favorites/FavoriteUnreadIndicator.tsx
new file mode 100644
index 0000000000..c3b5fdb73f
--- /dev/null
+++ b/apps/web/src/features/favorites/FavoriteUnreadIndicator.tsx
@@ -0,0 +1,104 @@
+import {
+ compileToAst,
+ defineQueryFilters,
+ queryStateFrom,
+} from '@app/features/next-soup/filters/filter-store';
+import { getEntityNotifications } from '@app/features/soup/entity-notifications';
+import { useFeatureFlag } from '@app/lib/analytics/posthog';
+import { useGlobalNotificationSource } from '@components/app/GlobalAppState';
+import { enableGraphqlSoup } from '@core/constant/featureFlags';
+import { useIsAuthenticated } from '@core/context/user';
+import { fireAndForget } from '@core/util/fireAndForget';
+import { UnreadIndicator } from '@entity/components/UnreadIndicator';
+import {
+ createEffectOnEntityTypeNotification,
+ entityHasUnreadNotifications,
+ notificationIsRead,
+} from '@notifications/notification-helpers';
+import { queryReadyGate } from '@queries/gate';
+import type { SoupEntityRef } from '@queries/soup/graphql/entity-input';
+import { useSoupAstItemsQuery } from '@queries/soup/items';
+import type { Favorite } from '@service-storage/generated/schemas/favorite';
+import { createMemo, Show } from 'solid-js';
+import { match } from 'ts-pattern';
+
+/** Favorite rows share the entity's existing notification read state. */
+export function FavoriteUnreadIndicator(props: { favorite: Favorite }) {
+ const source = useGlobalNotificationSource();
+ const graphqlSoup = useFeatureFlag(enableGraphqlSoup);
+ const authenticated = useIsAuthenticated();
+ const fields = createMemo(() => {
+ const { entityId, entityType } = props.favorite;
+ return match(entityType)
+ .with('document', () => ({ documentId: [entityId] }))
+ .with('project', () => ({ folderId: [entityId] }))
+ .with('foreign_entity', () => ({ foreignEntityRecordId: [entityId] }))
+ .otherwise(() => undefined);
+ });
+ const entityQuery = useSoupAstItemsQuery(
+ () => {
+ const body = compileToAst(
+ queryStateFrom(defineQueryFilters({ include: fields() }))
+ );
+ // folderId selects children; a favorite targets the folder itself.
+ if (props.favorite.entityType === 'project') {
+ body.pf = { l: { pids: props.favorite.entityId } };
+ }
+ return { params: { limit: 1, sort_method: 'updated_at' }, body };
+ },
+ () => ({
+ enabled:
+ !graphqlSoup().loading &&
+ graphqlSoup().enabled &&
+ authenticated() === true &&
+ fields() !== undefined,
+ keepPreviousData: false,
+ showSupportedForeignEntities: true,
+ graphqlCacheFirstEntities: match(props.favorite.entityType)
+ .returnType<SoupEntityRef[] | undefined>()
+ .with('document', () => [
+ { entityType: 'DOCUMENT', entityId: props.favorite.entityId },
+ ])
+ .with('project', () => [
+ { entityType: 'PROJECT', entityId: props.favorite.entityId },
+ ])
+ .otherwise(() => undefined),
+ })
+ );
+ createEffectOnEntityTypeNotification(
+ source,
+ props.favorite.entityType,
+ (notification) => {
+ if (
+ entityQuery.isEnabled &&
+ notification.entity_id === props.favorite.entityId
+ ) {
+ fireAndForget(entityQuery.refresh(), 'favorite-notifications');
+ }
+ }
+ );
+ const unread = () => {
+ if (graphqlSoup().loading || authenticated() !== true) return false;
+ if (!graphqlSoup().enabled) {
+ return entityHasUnreadNotifications(source, {
+ id: props.favorite.entityId,
+ type: props.favorite.entityType,
+ });
+ }
+ if (!fields() || !queryReadyGate(entityQuery)) return false;
+ const entity = entityQuery.data.entities.find(
+ (entity) => entity.id === props.favorite.entityId
+ );
+ return entity
+ ? getEntityNotifications(entity, source).some(
+ (notification) => !notificationIsRead(notification)
+ )
+ : false;
+ };
+
+ return (
+ <Show when={unread()}>
+ <UnreadIndicator active class="ml-auto" />
+ </Show>
+ );
+}
diff --git a/apps/web/src/features/reviews-view/components/ReviewsSidebar.tsx b/apps/web/src/features/reviews-view/components/ReviewsSidebar.tsx
index 02ef2b0d95..ef874da7a5 100644
--- a/apps/web/src/features/reviews-view/components/ReviewsSidebar.tsx
+++ b/apps/web/src/features/reviews-view/components/ReviewsSidebar.tsx
@@ -5,6 +5,7 @@ import {
ViewSidebar,
} from '@app/components/view-shell';
import { ViewCreateMenu } from '@app/features/command/view-create-menu';
+import { FavoriteUnreadIndicator } from '@app/features/favorites/FavoriteUnreadIndicator';
import { t } from '@app/lib/i18n';
import { globalSplitManager } from '@app/signal/splitLayout';
import { PrOriginIcon } from '@block-pr/component/PrLinks';
@@ -84,6 +85,7 @@ function ReviewFavoriteRow(props: {
/>
</ViewSidebar.Icon>
<span class="truncate">{name()}</span>
+ <FavoriteUnreadIndicator favorite={props.favorite} />
</ViewSidebar.Item>
</ContextMenu.Trigger>
<ContextMenu.Portal>
diff --git a/apps/web/src/features/tasks-view/components/TasksSidebar.tsx b/apps/web/src/features/tasks-view/components/TasksSidebar.tsx
index 3e1cce3dbe..887e2125af 100644
--- a/apps/web/src/features/tasks-view/components/TasksSidebar.tsx
+++ b/apps/web/src/features/tasks-view/components/TasksSidebar.tsx
@@ -8,6 +8,7 @@ import { SidebarCreateHeader } from '@app/components/view-shell/SidebarCreateBut
import { ConnectorImportSidebar } from '@app/features/connector-import/connector-import';
import { FavoriteContextMenu } from '@app/features/favorites/FavoriteContextMenu';
import { FavoriteIcon } from '@app/features/favorites/FavoriteIcon';
+import { FavoriteUnreadIndicator } from '@app/features/favorites/FavoriteUnreadIndicator';
import { t } from '@app/lib/i18n';
import { useParams } from '@app/lib/split-router';
import {
@@ -89,6 +90,7 @@ function FavoriteRow(props: {
<FavoriteIcon favorite={props.favorite} class="size-4" />
</ViewSidebar.Icon>
<span class="truncate">{name()}</span>
+ <FavoriteUnreadIndicator favorite={props.favorite} />
</ViewSidebar.Item>
</FavoriteContextMenu>
);
diff --git a/docs/agent-guide/navigation.md b/docs/agent-guide/navigation.md
index 975d96b30b..e3cf0f599b 100644
--- a/docs/agent-guide/navigation.md
+++ b/docs/agent-guide/navigation.md
@@ -890,6 +890,11 @@ otherwise. Cached pictures remain visible when a background picture query
rejects with an error; an omitted or unavailable channel preview uses the
fallback icon.
+Favorites in Chat, Tasks, Drive, and Reviews show an accent dot while their entity
+has unread notifications. Chat favorites use the same unread state as the regular
+channel rows in both sidebar designs. Reading or completing those notifications
+clears the dot; a failed read restores it.
+
With the GraphQL local cache enabled, cached favorites remain visible when offline
or when a background refresh fails. Toggle and reorder success while offline means
the change was accepted into the durable queue, not yet confirmed by the server.