Repository navigation
feat(web): add a Chat / Concierge switch to the chat list - #2122
Conversation
zoolsher
left a comment
There was a problem hiding this comment.
Design & Alternatives review: 💬 COMMENT
Problem: When a guardian who mostly uses one kind of chat opens the chat list, they scroll past the other kind. This happens because the list puts the Concierge's main, topic and task chats in a section above Projects, and task chats also appear under their project.
Goals: Show one kind of chat at a time. Keep the open chat visible. Remember the choice on each device. Signal activity in the hidden mode. Make the rail's Chat link and Ctrl/Cmd+Shift+O follow the mode. Keep the list unchanged when there is no Concierge.
Non-goals: No server-side preference, no API or schema change, no new routes.
PR's approach: A small external store in lib/chat-list-mode.ts holds the mode and the last ordinary chat in localStorage, read through useSyncExternalStore. A pure function chatListModeForRoute maps the open route to a mode. useChatListFollowsRoute writes that mode once per navigation. It is called from two places: RecentChats, which uses its own reactive lists, and RomeShellLayout, which reads the query cache without re-rendering. The rail (AppGrid) and the shortcut read the stored mode.
Alternatives considered (all checked against the code):
- Do nothing, or make the existing Concierge section collapsible.
RecentChatsalready collapses project groups (collapsedGroups/toggleGroup), soConciergeChatscould reuse that. This is cheap, but task chats would still be duplicated under projects, and the rail and shortcut would not adapt. It does not solve the whole problem. - Work out the mode from the route alone, with a temporary in-memory override. No localStorage, and no remount problem. But a blank
/chat, the rail target and the shortcut would have no device preference, which breaks the "stored per device" goal. - Put the mode in the URL (for example a separate Concierge list route or a query parameter). The mode would live in one place and be shareable. But it needs new routes, every link to
/chatwould have to change, and it reaches into the router, back/forward history and the phone layer. Much larger blast radius for little gain.
| approach | added complexity | correctness/completeness | blast radius | reversibility | maintenance | effort |
|---|---|---|---|---|---|---|
| PR: stored mode + route sync | moderate (store, 2 sync callers) | complete, except that a remount overrides the guardian's switch | chat list, rail Chat link, shortcut | two-way door (2 localStorage keys) | OK if there is one writer per navigation | done |
| Collapsible Concierge section | low | partial (task chats stay duplicated; rail and shortcut unchanged) | chat list only | two-way door | low | small |
| Mode from route + in-memory override | low–moderate | no device preference for blank chat, rail or shortcut | chat list, rail | two-way door | low | medium |
| Mode in the URL / separate route | high | complete, mode in one place | router, links, phone layer, history | mostly reversible, but route URLs become semi-public | higher | large |
Recommendation: The PR's approach fits best. It is a two-way door with no API, schema or wire-format commitment, and it reuses the existing useChatSessions and useConciergeChats lists and the query cache. Alternatives 1 and 2 do not meet the stated goals, and alternative 3 costs far more. One design flaw needs fixing: each mounted list remembers separately which navigation it has already applied. RecentChats is mounted conditionally: the desktop peek list on every hover, the collapse toggle, and the phone list layer. So on every remount it writes the route's mode again and silently undoes the guardian's own switch. That contradicts the PR's stated rule that "a guardian's own switch between navigations stands". Sharing the record of the last applied navigation between all callers fixes it without restructuring.
Verdict: COMMENT — A per-device stored mode that follows the route is the right design, but the route is followed separately by every mounted list, so remounting the list undoes the guardian's own switch. A small, reversible fix closes that.
1 finding(s) posted as inline comments below.
| Severity | Category | File | Title |
|---|---|---|---|
| P2 | design | packages/web/src/hooks/use-chat-list-mode.ts |
Remounting the chat list undoes the guardian's own mode switch |
Automated review by RomeOS Code Review · commit 4a52907 · Full review history
| const ordinaryChatId = route?.ordinaryChatId; | ||
| useEffect(() => { | ||
| if (!mode || applied.current === routeKey) return; | ||
| applied.current = routeKey; |
There was a problem hiding this comment.
[P2] design — Remounting the chat list undoes the guardian's own mode switch
applied is a useRef that belongs to one mounted list, but RecentChats mounts and unmounts often: the desktop peek list (chatPeek.open) mounts on every hover, the collapse toggle remounts the list, and so does the phone list layer. The sessions query keeps its data forever (gcTime: Infinity), so a fresh list can tell the open chat's kind at once, and its first effect writes the route's mode again. Example: on a collapsed desktop with an ordinary chat open, hover the list, switch to Concierge, move away, hover again. The list is back on Chat. That breaks the rule "A guardian's own switch between navigations stands", and no test remounts the list. Simplest fix: keep the last applied routeKey once, at module level in lib/chat-list-mode.ts, instead of in a per-instance useRef. The shell and every list instance then apply a navigation at most once between them. Add a test that switches, unmounts, remounts and expects the switch to hold.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
yunfanye
left a comment
There was a problem hiding this comment.
Design & Alternatives review: 💬 COMMENT
When guardians browse one kind of chat, unrelated chats consume scrolling space because both kinds share one list.
Goals: Separate chat kinds, preserve navigation context and device preferences, and surface activity in the hidden mode. Non-goals: Change chat identity, backend APIs or persistence schemas.
The PR appropriately reuses chatKind/isProjectChat in packages/web/src/lib/chat-session.ts, existing row renderers and the shared SegmentedControl. However, route synchronization runs independently in the shell and the mountable list.
| Approach | Added complexity | Correctness/completeness | Blast radius | Reversibility | Maintenance | Effort |
|---|---|---|---|---|---|---|
| PR: two views, multiple route followers | Medium | Remount and cold-route gaps | List, rail, shortcut | Easy | Multiple owners | Implemented |
| Keep mixed list; reuse existing project collapsing in RecentChats.tsx | None | Does not achieve kind separation | List only | Easy | Lowest | None |
| Keep two views; synchronize once in RomeShellLayout.tsx using routed-session metadata | Low–medium | Handles hidden lists and preserves manual switches | Same surfaces | Easy | One owner | Small–medium refactor |
The last option is feasible using the existing getSession in packages/web/src/lib/chat-api.ts, which already coalesces concurrent reads. Recommendation: Keep the presentation design, but centralize route following in the persistent shell rather than inferring it independently from list caches. No public API, schema or wire-format one-way doors are introduced; the two localStorage keys are reversible.
Verification included implementation, callers and tests. An isolated React hook harness reproduced both cases below; the full suite was not rerun.
Verdict: COMMENT — The two-view UI fits the problem, but one shell-owned route synchronizer would be simpler and avoid reproduced state inconsistencies.
1 finding(s) posted as inline comments below.
| Severity | Category | File | Title |
|---|---|---|---|
| P2 | architecture | packages/web/src/hooks/use-chat-list-mode.ts |
Give route-to-mode synchronization one persistent owner |
Automated review by RomeOS Code Review · commit 4a52907 · Full review history
| mainChatId, | ||
| kindOf, | ||
| }); | ||
| const applied = useRef<string | null>(null); |
There was a problem hiding this comment.
[P2] architecture — Give route-to-mode synchronization one persistent owner
This hook runs in both RomeShellLayout and RecentChats, but applied is instance-local: on /message, choosing Chat and then collapsing/reopening the list resets it to Concierge without navigation. Conversely, on a cold phone/collapsed load, a routed chat absent from the list cache never updates the mode or last ordinary chat, leaving the rail and shortcut using stale choices. Centralize route following in the persistent shell, resolving unknown route metadata through the existing getSession, and let the list consume that state and submit manual changes. Add regression tests for same-route list remounts and cold deep links with the list hidden.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
4a52907 to
bba37e5
Compare
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
d1f6d1a to
5d86561
Compare
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
1e718ec to
d786cbf
Compare
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
There was a problem hiding this comment.
🔁 This review has been superseded. See the latest review.
The chat list header gets an icon-only switch between two modes. Chat mode leads with a New chat row and lists only common and fork chats under Projects. Concierge mode leads with a New topic row, then the main chat and topic chats, then a Tasks section with the latest five task chats and a More row. The hover plus beside the main chat is gone, since the New topic row replaces it. The mode is stored per device and follows the open chat. A dot on the other segment shows unread Concierge messages, or an ordinary chat replying. Ctrl/Cmd+Shift+O opens a new chat or a new topic chat by mode, and the rail's Chat entry opens the main chat or the last ordinary chat. Without a Concierge there is no switch and the list stays as it was, plus the New chat row. Co-Authored-By: Rome OS <noreply@romeos.cc>
…ashboard mock The mock had one Concierge chat and no unread or running Concierge state, so the chat list's Concierge mode and its dots could not be shown without a backend. Co-Authored-By: Rome OS <noreply@romeos.cc>
… alone The shell now owns following the open chat, and the chat list only reads the mode and writes the guardian's own switch. A list that mounts again on the same page, as the collapse toggle, the hover peek and the phone list do, no longer undoes that switch. When the open chat is in no loaded list, the shell asks for its own session, and also reads the Concierge's chats this tab has loaded. A deep link opened with the list hidden now moves the mode and the last ordinary chat too. Each tab keeps its mode in memory, seeded from the device's stored value at load, and no longer reads other tabs' changes. The stored value still tells a new tab where to start. The main-chat message subscription recounts only the Concierge's chats. The Tasks More row drops its off-scale padding, and the rail-names e2e finds the Chat tile by its label and checks its target by mode. Co-Authored-By: Rome OS <noreply@romeos.cc>
…guardian Task chats list only in Concierge mode, so one that waits for the guardian gave no sign in Chat mode. The Concierge segment's dot now also shows for a waiting task chat, and its label says so. A failed, finished or running task chat does not light it. The comment on the route follower's session read no longer claims the open page shares that request. Co-Authored-By: Rome OS <noreply@romeos.cc>
Deleting the open ordinary chat went to the main chat's page, which switches the chat list to Concierge mode. The chat list and the chat's own delete now open a blank chat when the deleted chat is ordinary, and keep the main chat for any other chat. Co-Authored-By: Rome OS <noreply@romeos.cc>
…chat The phone header's delete still went to the main chat's page, which switches the chat list to Concierge mode. It now opens a blank chat when the deleted chat is ordinary, as the chat list and the chat's own delete do. Co-Authored-By: Rome OS <noreply@romeos.cc>
The shell applied a chat page's mode once per history entry and kept that mark while the guardian visited another page. Back to the same entry then matched the mark and skipped the mode, so a switch made on the chat stood. Leaving the chat pages now clears the mark. Co-Authored-By: Rome OS <noreply@romeos.cc>
…glossary The glossary still described one list with the main chat above Projects, a plus beside the main chat, and task chats under their project. It now describes the two modes, what each lists, the dots, which mode shows, the shortcut and the rail's Chat entry, and where deleting an open chat lands. The decided-against entry on a New chat button now says why the list became two modes. Co-Authored-By: Rome OS <noreply@romeos.cc>
d786cbf to
fa01ad0
Compare
zoolsher
left a comment
There was a problem hiding this comment.
Code Review: 💬 COMMENT
What the PR does: It splits the dashboard chat list into two modes:
- Chat mode: a New chat row, then common and fork chats under Projects.
- Concierge mode: a New topic row, the main chat, topic chats, and a Tasks section that shows five rows and a More row.
A small per-tab store in lib/chat-list-mode.ts holds the mode and the last ordinary chat. It is seeded from localStorage once per page load and writes back to it. Only the persistent RomeShellLayout follows the route, through useChatListFollowsRoute. When the open chat is in no cached list, it falls back to getSession. The rail (AppGrid) and Ctrl/Cmd+Shift+O read the stored mode.
Approach: This is the right problem, and the approach is about as simple as it can be:
- It reuses
chatKind/isProjectChat, the existing row renderers andSegmentedControl. - One component that stays mounted owns route syncing, so the earlier P2s about remounts and cold deep links are resolved.
- It adds two localStorage keys and changes no API or schema, so a revert is clean.
Compared with the last reviewed commit (d786cbf): the head was rebased onto main. RecentChats.tsx, use-chat-list-mode.ts, chat-list-mode.ts, AppGrid.tsx, RomeShellLayout.tsx and use-chat-sessions.ts match d786cbf byte for byte. ConciergeEntry.tsx and Chat.tsx differ only by the TopicChatDeleteDialog change that came from main. So the open threads still apply:
- Concierge unread refresh (P2): still present. I traced it again and repeat it below because it decides the verdict.
- Archived-only list in the rail (P3): still present. It is optional, so I did not repeat it.
What I checked beyond the diff:
chatKind,activeSessionFromPathandisChatPathinchat-session.ts.useConciergeChat: off/messageit only reads the cache. A nullmainChatIdstill classifies a topic chat as Concierge, throughagentName.- The chat-sessions query keys and the shared sessions-changed listener in
use-chat-sessions.ts. ConciergeChats/ConciergeEntry, where the refresh subscriptions live.- The status stream in
RecentChats:session_runningrefreshes topic chats in both modes. markSessionReadinChat.tsx, which emits sessions-changed after a read.- The delete paths in
Chat.tsx,FreeGrid.tsxandRecentChats, which all keep the user in Chat mode. - The
hideSidebarhandling for the shortcut. - The glossary updates in
docs/domains.
I could not run the tests: the clone has no node_modules.
Design & alternatives
| Approach | Complexity | Correctness | Blast radius | Reversibility |
|---|---|---|---|---|
| PR: per-tab store, shell-owned route follower, mode-aware list | Low–medium | Good. One stale-unread gap remains | Chat list, rail, shortcut | Easy (2 localStorage keys) |
| Keep one mixed list, collapse sections | Lowest | Doesn't separate the two kinds | List only | Easy |
| Mode in a URL param instead of a store | Medium | Survives reloads per URL, but every chat link must carry it | All chat links | Harder |
The PR's choice is reasonable.
Verdict: COMMENT — I found no new defects, but one P2 from an earlier review is still in the code at fa01ad0: the Concierge unread dot can go stale after a read in Chat mode.
1 finding(s) posted as inline comments below.
| Severity | Category | File | Title |
|---|---|---|---|
| P2 | correctness | packages/web/src/shell/RecentChats.tsx |
Concierge dot still goes stale after a read in Chat mode (open since the last review) |
Automated review by RomeOS Code Review · commit fa01ad0 · Full review history
| const recountConciergeChats = useCallback(() => { | ||
| void queryClient.invalidateQueries({ queryKey: CONCIERGE_CHATS_QUERY_KEY }); | ||
| }, [queryClient]); | ||
| useLiveEvents( |
There was a problem hiding this comment.
[P2] correctness — Concierge dot still goes stale after a read in Chat mode (open since the last review)
This is still present at fa01ad0; RecentChats.tsx is unchanged since d786cbf. In Chat mode ConciergeChats is unmounted, so its useSessionsChanged(refresh) is gone. Chat.markSessionRead calls notifySessionsChanged() after apiMarkSessionRead, but in this mode that event only invalidates chat-sessions, not CONCIERGE_CHATS_QUERY_KEY. The message_insert / session_running refetch can land before the read mark. Then, after you leave the main chat or a topic chat (for example with New chat), the Concierge dot shows for messages already read, until the next focus refetch. Simplest fix: in RecentChats, add useSessionsChanged(() => { if (mode === "chat") recountConciergeChats(); }), and add a test that reads, navigates and expects no dot.
Jessie-QingYu
left a comment
There was a problem hiding this comment.
Code Review: 💬 COMMENT
What the PR does. It splits the dashboard chat list into two modes:
- Chat mode shows a New chat row, then common and fork chats under Projects.
- Concierge mode shows a New topic row, the main chat, topic chats, and a Tasks section capped at five rows with a More row.
A per-tab store in lib/chat-list-mode.ts holds the mode and the last ordinary chat. It is seeded from localStorage once per page load. useChatListFollowsRoute runs only in RomeShellLayout, which stays mounted, and falls back to getSession when the open chat is in no loaded list. The rail (AppGrid) and Ctrl/Cmd+Shift+O read the stored mode.
Approach. The PR solves the right problem in about as simple a way as the problem allows:
- It reuses
chatKind/isProjectChat, the existing row renderers andSegmentedControl. - One mounted component follows the route, which fixes the earlier remount and cold-deep-link findings.
- It adds two localStorage keys and changes no API or schema, so a revert is clean.
Nothing here is over-complicated.
Checked beyond the diff:
chatKind,activeSessionFromPathandisChatPathinchat-session.ts.useConciergeChatandrefreshTopicChatsinuse-concierge.ts.useChatSessionsand its query keys. Everychat-sessionscache entry is aChatSession[], sofindCachedChatSessionis safe.use-session-identity.ts:forkableisisProjectChat(chatKind(session)), which is correct for the new delete targets inChat.tsxandFreeGrid.tsx.ConciergeEntry: the plus is removed and nonewTopicChatordata-concierge-new-topicreferences remain.- i18n keys exist in both locales.
- The
session_runningandmessage_insertrecount paths inRecentChats.
There are no node_modules in the clone, so I could not run the tests. I relied on reading the code and the new test files.
Outstanding. @yunfanye's earlier P2 ("Refresh the Concierge unread query after reads in Chat mode") still applies at fa01ad0. A read in Chat mode emits CHAT_SESSIONS_CHANGED_EVENT, but only ConciergeChats and ConciergeEntry listen for it, and neither is mounted in Chat mode. So concierge-chats keeps the old unread count. Below I confirm it with the exact path and a one-line fix. I have no new findings beyond it.
The earlier P3 still holds as well: an archived-only cache in hasCachedChatSessions makes the rail open a blank chat even though the last ordinary chat still exists. It is optional and not repeated here.
Verdict: COMMENT — The design is sound and most earlier findings are fixed, but one P2 from an earlier review is still in the code at head fa01ad0: the Concierge dot can stay lit after a read made in Chat mode.
1 finding(s) posted as inline comments below.
| Severity | Category | File | Title |
|---|---|---|---|
| P2 | correctness | packages/web/src/shell/RecentChats.tsx |
Still open at head: a read in Chat mode leaves the Concierge dot stale |
Automated review by RomeOS Code Review · commit fa01ad0 · Full review history
| const recountConciergeChats = useCallback(() => { | ||
| void queryClient.invalidateQueries({ queryKey: CONCIERGE_CHATS_QUERY_KEY }); | ||
| }, [queryClient]); | ||
| useLiveEvents( |
There was a problem hiding this comment.
[P2] correctness — Still open at head: a read in Chat mode leaves the Concierge dot stale
This confirms @yunfanye's open thread at fa01ad0. Chat.markSessionRead calls emitSessionsChanged() after apiMarkSessionRead, but in Chat mode nothing that is mounted invalidates CONCIERGE_CHATS_QUERY_KEY on that event. The only listeners are ConciergeChats and ConciergeEntry, and both are unmounted. Path: the main chat is open and the guardian switched to Chat mode. A message with no turn arrives (an alert or a digest), and the message_insert recount sees unread=1. The chat marks it read, but nothing recounts. Leaving that chat then shows a red Concierge dot for messages already read, and it lasts until a focus refetch or a turn ends. Simplest fix, next to recountConciergeChats: useSessionsChanged(() => { if (hasConcierge && mode === "chat") recountConciergeChats(); });. Add a read-then-navigate test.
yunfanye
left a comment
There was a problem hiding this comment.
Code Review: 💬 COMMENT
The mode split is appropriately scoped, with route synchronization owned by the persistent shell. Beyond-the-diff checks covered classification, navigation, deletion and cache invalidation. All 23 focused logic tests passed; an isolated AppGrid probe reproduced the finding. The full suite was not run because the clone lacks dependencies.
Verdict: COMMENT — The rail can retain a deleted chat as its target because it does not observe session-cache updates.
1 finding(s) posted as inline comments below.
| Severity | Category | File | Title |
|---|---|---|---|
| P2 | correctness | packages/web/src/shell/AppGrid.tsx |
Subscribe the rail target to session-cache changes |
Automated review by RomeOS Code Review · commit fa01ad0 · Full review history
| const queryClient = useQueryClient(); | ||
| const chatListMode = useChatListModeForShell(true, "concierge"); | ||
| const lastOrdinaryChatId = useLastOrdinaryChatId(); | ||
| const lastOrdinaryChatExists = |
There was a problem hiding this comment.
[P2] correctness — Subscribe the rail target to session-cache changes
useQueryClient() and these imperative cache reads do not subscribe AppGrid to session-list changes. With a blank chat open in Chat mode, deleting the remembered ordinary chat removes it from the cache but leaves the rail pointing at /chat/<deleted-id> until an unrelated render, so clicking it attempts to reopen the deleted session instead of using the blank-chat fallback. Subscribe to the relevant cache updates and add a regression test that removes the remembered chat after mounting; the current tests only seed the cache before rendering.
…et current (#2150) ## Why Two parts of the Chat / Concierge switch from #2122 read data that changed without telling them. In Chat mode nothing recounted the Concierge's chats when the open main or topic chat was marked read, so leaving that chat showed the Concierge dot for messages already read. The rail's Chat entry read the loaded chat lists once per render, so deleting the remembered chat left the entry linking to it until something else rendered. ## Invariants - In Chat mode, the Concierge dot clears once the open Concierge chat is read. - The rail's Chat entry in Chat mode opens a blank chat as soon as the remembered chat is gone from the loaded lists. - A loaded archived list does not show that an active chat is gone. ## Scope - The chat list recounts the Concierge's chats on a read while it is in Chat mode. In Concierge mode the Concierge section already does, so the two never both run. - The rail follows the loaded chat lists instead of reading them at render. A chat found in any loaded list counts as existing. A chat missing from every loaded list counts as gone once the active or the all list is loaded. - A delete from the dashboard drops the chat from every cached chat list, including a list nothing is using, such as the search dialog's. A delete made in another tab or on another device reaches this tab's lists only when they refetch, so the rail can keep the link until then. - Not covered: a remembered chat that is archived while only the active list is loaded still reads as gone, which sends the rail to a blank chat. - No layout change, so no screenshots. ## Merge danger Two-way door. No migration, API or stored-value change, and a revert returns the previous behavior. Blast radius: the chat list's Concierge dot and the rail's Chat link. ## Evidence - Chat mode with unread Concierge messages, then a read: the dot clears. Fails without the change. - Rail mounted in Chat mode, then the remembered chat leaves the loaded list: the entry changes from that chat to a blank chat. Fails without the change. - A list nothing is using still holds the remembered chat, and a delete goes through: the entry changes to a blank chat, and the list loses the chat. A delete that fails changes nothing. Fails without the change. - Only the archived list loaded: the entry keeps the remembered chat. Fails without the change. - Full rome-web unit suite passes: 3583 tests. `e2e/rail-names.spec.ts` passes against the mock build. 🤖 Generated with [Rome OS](https://github.com/rome-os/rome) --------- Co-authored-by: Rome OS <noreply@romeos.cc>
## Why A guardian who switched the chat list to Chat mode found it back in Concierge mode every time the app opened. The device stored the choice, but the home address always opened the main chat, and the list follows the open chat. The home address now opens the chat that the rail's Chat entry would. ## Invariants - Opening the app at its home address keeps the chat-list mode the device last showed. - In Chat mode it opens the last ordinary chat, or a blank chat once that chat is gone. In Concierge mode, or on a device that has never shown a mode, it opens the main chat as before. ## Scope - Covers the home address only, which is where the desktop app and a bare visit land. - A reload on a specific chat still shows that chat's mode, so the open chat stays in the list, as #2122 set out. ## Merge danger Two-way door: a revert restores the old landing. Blast radius: where the dashboard lands at `/` for a device whose stored mode is Chat. ## Evidence - Chat mode with a last ordinary chat: `/` opens that chat. Fails without the fix. - Chat mode once that chat has been deleted: `/` opens a blank chat. Fails without the fix. - Mock dashboard: picked Chat, loaded `/` again, and the app landed on `/chat` with the list in Chat mode. Picked Concierge, loaded `/` again, and it landed on the main chat. Only the landing route changes, so no view looks different. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Why
The chat list mixes two kinds of chat. Ordinary chats group under Projects, while the main chat, topic chats and task chats sit in a Concierge section above them, and task chats sit under their project beside ordinary chats. Someone who mostly uses one kind scrolls past the other. The list now has two modes, switched from an icon pair in its header, so each mode shows one kind.
Invariants
Scope
docs/domains/chats.mdand the domains README) to describe the two modes, in the same change as the code.Merge danger
Two-way door. The change adds two localStorage keys and no migration or API change, and a revert returns the old list. Blast radius: the dashboard chat list, the rail's Chat link and the new-chat shortcut.
Evidence
e2e/rail-names.spec.tspasses against the mock build, with the Chat tile's target checked in both modes.pnpm dev:all) cannot run on the machine used for this change and is left to CI.Desktop 1280×900, Chat mode, with the red dot on Concierge:

Desktop 1280×900, Concierge mode, with the Tasks section and the dot on Chat:

Phone 390×844, touch on, chat list open:


Phone 320×800, Chat mode, where the header holds a row of buttons:

🤖 Generated with Rome OS