+
{header}
- {copyBody ?
: null}
+ {copyBody || actions ? (
+
+ {actions}
+ {copyBody ?
+ ) : null}
+
+
+ {children}
-
{children}
{footer}
);
diff --git a/src/store/chatPanel/__tests__/chatPanelWorkItemActionAtoms.test.ts b/src/store/chatPanel/__tests__/chatPanelWorkItemActionAtoms.test.ts
new file mode 100644
index 0000000000..08449f23c8
--- /dev/null
+++ b/src/store/chatPanel/__tests__/chatPanelWorkItemActionAtoms.test.ts
@@ -0,0 +1,63 @@
+import { createStore } from "jotai";
+import { describe, expect, it } from "vitest";
+
+import {
+ consumeChatPanelWorkItemActionAtom,
+ pendingChatPanelWorkItemActionAtom,
+ requestChatPanelWorkItemActionAtom,
+} from "../chatPanelWorkItemActionAtoms";
+
+describe("chat panel Work Item action requests", () => {
+ it("consumes a matching start request exactly once", () => {
+ const store = createStore();
+ const request = store.set(requestChatPanelWorkItemActionAtom, {
+ workItemShortId: "ORG-42",
+ action: "start_agent",
+ });
+
+ expect(store.get(pendingChatPanelWorkItemActionAtom)).toEqual(request);
+ expect(store.set(consumeChatPanelWorkItemActionAtom, request)).toEqual(
+ request
+ );
+ expect(store.get(pendingChatPanelWorkItemActionAtom)).toBeNull();
+ expect(store.set(consumeChatPanelWorkItemActionAtom, request)).toBeNull();
+ });
+
+ it("does not consume a request from another Work Item", () => {
+ const store = createStore();
+ const request = store.set(requestChatPanelWorkItemActionAtom, {
+ workItemShortId: "ORG-42",
+ action: "start_agent",
+ });
+
+ expect(
+ store.set(consumeChatPanelWorkItemActionAtom, {
+ ...request,
+ workItemShortId: "ORG-43",
+ })
+ ).toBeNull();
+ expect(store.get(pendingChatPanelWorkItemActionAtom)).toEqual(request);
+ });
+
+ it("lets the newest unclaimed navigation intent supersede an older one", () => {
+ const store = createStore();
+ const olderRequest = store.set(requestChatPanelWorkItemActionAtom, {
+ workItemShortId: "ORG-42",
+ action: "start_agent",
+ });
+ const newestRequest = store.set(requestChatPanelWorkItemActionAtom, {
+ workItemShortId: "ORG-43",
+ action: "start_agent",
+ });
+
+ expect(store.get(pendingChatPanelWorkItemActionAtom)).toEqual(
+ newestRequest
+ );
+ expect(
+ store.set(consumeChatPanelWorkItemActionAtom, olderRequest)
+ ).toBeNull();
+ expect(
+ store.set(consumeChatPanelWorkItemActionAtom, newestRequest)
+ ).toEqual(newestRequest);
+ });
+});
diff --git a/src/store/chatPanel/chatPanelTabsAtom.ts b/src/store/chatPanel/chatPanelTabsAtom.ts
index f1ed721823..ca1e4277ed 100644
--- a/src/store/chatPanel/chatPanelTabsAtom.ts
+++ b/src/store/chatPanel/chatPanelTabsAtom.ts
@@ -72,3 +72,10 @@ export {
chatPanelTabCountAtom,
chatPanelTabsAtom,
} from "./chatPanelTabsState";
+export {
+ consumeChatPanelWorkItemActionAtom,
+ pendingChatPanelWorkItemActionAtom,
+ requestChatPanelWorkItemActionAtom,
+ type ChatPanelWorkItemAction,
+ type ChatPanelWorkItemActionRequest,
+} from "./chatPanelWorkItemActionAtoms";
diff --git a/src/store/chatPanel/chatPanelWorkItemActionAtoms.ts b/src/store/chatPanel/chatPanelWorkItemActionAtoms.ts
new file mode 100644
index 0000000000..6cb6eb4ea3
--- /dev/null
+++ b/src/store/chatPanel/chatPanelWorkItemActionAtoms.ts
@@ -0,0 +1,45 @@
+import { atom } from "jotai";
+
+export type ChatPanelWorkItemAction = "start_agent";
+
+export interface ChatPanelWorkItemActionRequest {
+ requestId: string;
+ workItemShortId: string;
+ action: ChatPanelWorkItemAction;
+}
+
+export const pendingChatPanelWorkItemActionAtom =
+ atom
(null);
+
+export const requestChatPanelWorkItemActionAtom = atom(
+ null,
+ (_get, set, request: Omit) => {
+ const pendingRequest: ChatPanelWorkItemActionRequest = {
+ ...request,
+ requestId: crypto.randomUUID(),
+ };
+ set(pendingChatPanelWorkItemActionAtom, pendingRequest);
+ return pendingRequest;
+ }
+);
+
+export const consumeChatPanelWorkItemActionAtom = atom(
+ null,
+ (
+ get,
+ set,
+ request: ChatPanelWorkItemActionRequest
+ ): ChatPanelWorkItemActionRequest | null => {
+ const pendingRequest = get(pendingChatPanelWorkItemActionAtom);
+ if (
+ pendingRequest?.requestId !== request.requestId ||
+ pendingRequest.workItemShortId !== request.workItemShortId ||
+ pendingRequest.action !== request.action
+ ) {
+ return null;
+ }
+
+ set(pendingChatPanelWorkItemActionAtom, null);
+ return pendingRequest;
+ }
+);
From 2ca0006b2ba02e4000773f10bba6539ffac8f286 Mon Sep 17 00:00:00 2001
From: hanafish <1106510024@qq.com>
Date: Mon, 27 Jul 2026 23:39:47 +0800
Subject: [PATCH 03/11] test(team-inbox): cover dual-instance mention receipts
Pre-commit hook ran. Total eslint: 2, total circular: 0
---
.../core/cloud-dual-instance-ui.spec.mjs | 98 +++++++++++++++++++
tests/e2e/support/core/cloudOrgUiDriver.mjs | 15 ++-
2 files changed, 112 insertions(+), 1 deletion(-)
diff --git a/tests/e2e/specs/core/cloud-dual-instance-ui.spec.mjs b/tests/e2e/specs/core/cloud-dual-instance-ui.spec.mjs
index e9462010ae..aabe8d5184 100644
--- a/tests/e2e/specs/core/cloud-dual-instance-ui.spec.mjs
+++ b/tests/e2e/specs/core/cloud-dual-instance-ui.spec.mjs
@@ -23,6 +23,7 @@ import {
openCreateOrgFormFromSidebar,
openTurnCommentPanel,
postTurnComment,
+ postTurnCommentMentioning,
pressEscape,
provisionCloudUser,
publishCloudSessionMetadata,
@@ -62,6 +63,7 @@ const SESSION_NOTE_BODY = `Dual-instance session note ${RUN_ID}`;
const EDITED_COMMENT_BODY = `@agent dual-instance edited task ${RUN_ID}`;
const EDITED_COMMENT_BRIEF = EDITED_COMMENT_BODY.slice("@agent ".length);
const REPLY_BODY = `Owner reply from the other instance ${RUN_ID}`;
+const TEAM_INBOX_MENTION_BODY = `Team Inbox mention ${RUN_ID}`;
const SEND_BODY = `Continue this work from the matching workspace ${RUN_ID}`;
const PROJECT_NAME = `Dual cloud project ${RUN_ID}`;
const PROJECT_SLUG = PROJECT_NAME.toLowerCase()
@@ -2353,6 +2355,102 @@ describe("Cloud collaboration with two independent rendered app instances", func
}
});
+ it("C2. delivers a structured member mention and persists the teammate read receipt", async function () {
+ this.timeout(180_000);
+
+ unwrap(
+ await invokeE2E("openSession", sessionId),
+ "primary reopen source session for Team Inbox mention"
+ );
+ await openTurnCommentPanel(sourceTurnAnchorEventId);
+ await postTurnCommentMentioning(TEAM_INBOX_MENTION_BODY, teammate.userId);
+ await waitForRendered(
+ '[data-testid="comment-member-mention-pill"]',
+ "primary rendered teammate mention chip",
+ CLOUD_FETCH_TIMEOUT_MS
+ );
+
+ await waitForRenderedOn(
+ second.client,
+ '[data-testid="sidebar-team-inbox"]',
+ "secondary Team Inbox navigation",
+ CLOUD_FETCH_TIMEOUT_MS
+ );
+ await clickRenderedOn(
+ second.client,
+ '[data-testid="sidebar-team-inbox"]',
+ "secondary Team Inbox navigation"
+ );
+ await second.client.waitUntil(
+ async () =>
+ executeOn(
+ second.client,
+ `
+ const body = arguments[0];
+ const row = Array.from(
+ document.querySelectorAll(
+ '[data-testid="team-inbox-row"][data-item-kind="comment_mention"]'
+ )
+ ).find((candidate) => (candidate.textContent ?? '').includes(body));
+ if (!row) return false;
+ row.setAttribute('data-e2e-team-inbox-mention', 'true');
+ return row.getAttribute('data-unread') === 'true';
+ `,
+ [TEAM_INBOX_MENTION_BODY]
+ ),
+ {
+ timeout: CLOUD_FETCH_TIMEOUT_MS,
+ interval: 250,
+ timeoutMsg:
+ "secondary Team Inbox never rendered the teammate mention as unread",
+ }
+ );
+
+ await clickRenderedOn(
+ second.client,
+ '[data-e2e-team-inbox-mention="true"]',
+ "secondary unread Team Inbox mention"
+ );
+
+ let teammateInbox = null;
+ await second.client.waitUntil(
+ async () => {
+ teammateInbox = await callProjectsRpc(
+ env,
+ teammate,
+ "cloud_list_team_inbox_mentions",
+ { p_org_id: teamOrgId, p_cursor: null, p_limit: 50 }
+ );
+ const mention = (teammateInbox?.mentions ?? []).find(
+ (entry) => entry.body === TEAM_INBOX_MENTION_BODY
+ );
+ return Boolean(mention?.readAt && teammateInbox.unreadCount === 0);
+ },
+ {
+ timeout: CLOUD_FETCH_TIMEOUT_MS,
+ interval: 500,
+ timeoutMsg:
+ "secondary click did not persist the viewer-scoped cloud read receipt",
+ }
+ );
+
+ const ownerInbox = await callProjectsRpc(
+ env,
+ owner,
+ "cloud_list_team_inbox_mentions",
+ { p_org_id: teamOrgId, p_cursor: null, p_limit: 50 }
+ );
+ if (
+ (ownerInbox?.mentions ?? []).some(
+ (entry) => entry.body === TEAM_INBOX_MENTION_BODY
+ )
+ ) {
+ throw new Error(
+ "mention projection leaked the teammate-targeted comment into the owner Inbox"
+ );
+ }
+ });
+
it("D. syncs comment CRUD/status, intercepts send into a same-remote fork, and revokes directed access live", async function () {
this.timeout(360_000);
diff --git a/tests/e2e/support/core/cloudOrgUiDriver.mjs b/tests/e2e/support/core/cloudOrgUiDriver.mjs
index a3cdf1a7ad..e510139af5 100644
--- a/tests/e2e/support/core/cloudOrgUiDriver.mjs
+++ b/tests/e2e/support/core/cloudOrgUiDriver.mjs
@@ -977,7 +977,7 @@ async function postOpenComment(body) {
await browser.waitUntil(
async () =>
(await execJS(
- js.click('[data-testid="session-comment-composer"] button')
+ js.click('[data-testid="session-comment-composer-submit"]')
)) === "clicked",
{
timeout: RENDER_TIMEOUT_MS,
@@ -996,6 +996,19 @@ export async function postTurnComment(body) {
await postOpenComment(body);
}
+/** Posts through the production member picker; no RPC/helper creates mention state. */
+export async function postTurnCommentMentioning(body, memberUserId) {
+ await clickRendered(
+ '[data-testid="session-comment-composer-mention-members"]',
+ "comment member mention picker"
+ );
+ await clickRendered(
+ `[data-testid="session-comment-mention-${memberUserId}"]`,
+ "comment mentioned member"
+ );
+ await postOpenComment(body);
+}
+
/** Opens the header-level session-notes dialog and posts an unanchored note. */
export async function postSessionNote(body) {
await clickRendered(
From 4ec1851132c7696543e18f829b91349be7fbc023 Mon Sep 17 00:00:00 2001
From: hanafish <1106510024@qq.com>
Date: Mon, 27 Jul 2026 23:40:24 +0800
Subject: [PATCH 04/11] docs(audit): record team inbox closure
Pre-commit hook ran. Total eslint: 2, total circular: 0
---
.../TeamInboxCollaboration.md | 85 ++++++++++++++++
.../TeamInboxThread.md | 98 +++++++++++++++++++
.../TeamInboxCollaboration.md | 51 ++++++++++
.../TeamInboxResponsive.md | 48 +++++++++
.../TeamInboxThread.md | 61 ++++++++++++
.../TeamInboxCollaboration.md | 25 +++++
.../TeamInboxKanban.md | 12 +++
7 files changed, 380 insertions(+)
create mode 100644 docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md
create mode 100644 docs/architecture-audit-2026-07-27/TeamInboxThread.md
create mode 100644 docs/frontend-ui-audit-2026-07-27/TeamInboxCollaboration.md
create mode 100644 docs/frontend-ui-audit-2026-07-27/TeamInboxResponsive.md
create mode 100644 docs/frontend-ui-audit-2026-07-27/TeamInboxThread.md
create mode 100644 docs/org2-performance-guard-2026-07-27/TeamInboxCollaboration.md
create mode 100644 docs/org2-performance-guard-2026-07-27/TeamInboxKanban.md
diff --git a/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md b/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md
new file mode 100644
index 0000000000..0d9af282b0
--- /dev/null
+++ b/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md
@@ -0,0 +1,85 @@
+# Architecture Audit — Team Inbox Multi-User Collaboration
+
+**Scope:** structured member mentions, durable viewer-scoped read receipts, authoritative unread counts, full-roster Work Item identity projection, and dual-instance UI coverage.
+**Date:** 2026-07-27
+
+## Layer 1 — Compilation correctness
+
+- TypeScript `tsc --noEmit`: passed.
+- Focused ESLint over all changed collaboration/UI files: passed.
+- Twenty-four focused Vitest files: 230 tests passed after the capability-gate regression cases were added.
+- Cloud migration was statically reviewed; live apply and live two-account E2E remain deployment validation.
+
+## Layer 2 — Dead code and structural deduplication
+
+- Removed the cloud mention localStorage receipt owner; server receipts are now the sole cross-device source of truth.
+- `resolveMentions` and `MemberMentionChip` own repeated UUID-to-name and pill UI logic.
+- Session comments load the active roster through the existing shared roster coordinator rather than adding a second fetch/cache.
+- Work Item history, description creator, assignee, and reviewer all project the same roster identities.
+
+## Layer 3 — Naming consistency
+
+- `mentionedUserIds` is used consistently on client wire/domain models; PostgreSQL uses `mentioned_user_ids`.
+- `readAt` denotes the viewer-specific receipt timestamp, while `unreadCount` denotes the authoritative full-result total.
+- `markAllTeamInboxMentionsRead` is explicitly org/viewer scoped rather than implying a global Inbox mutation.
+
+## Layer 4 — Semantic overloading
+
+| Term | Meaning | Verdict |
+| --------------- | -------------------------------------------------------------- | ----------------------------------------------------------- |
+| mention | Explicit active-org member UUID attached to a comment | Never inferred from display text. |
+| read | Receipt for one authenticated viewer and one mentioned comment | Separate from comment resolution or Session state. |
+| unread count | Full eligible mention total outside the current page | Owned by the server response, not derived from loaded rows. |
+| member identity | Stable user UUID with roster-projected display name | IDs persist; names may change without rewriting history. |
+
+## Layer 5 — Default branch analysis
+
+- Old cloud deployments report no `teamInboxMentions` capability, so the structured picker stays hidden.
+- Comment adds without mentions retain the legacy RPC; adds with mentions require the atomic 0010 RPC and never silently drop recipients.
+- The view owns optimistic read/unread presentation and per-item rollback generations. The data source serializes the corresponding durable mutations through a bounded queue, so rapid opposite actions cannot commit out of order.
+- Empty, loading, pagination, filtered, and partially loaded Inbox states preserve the server unread total.
+
+## Layer 6 — Cross-domain concept leakage
+
+- PostgreSQL owns durable receipts, recipient validation, visibility, retention, and authoritative totals.
+- Org2Cloud clients own wire validation and transport retry only.
+- Team Inbox owns list/filter/optimistic presentation, not receipt persistence.
+- Session comments own member selection and mention rendering.
+- Work Item components own assignee/reviewer/history identity presentation.
+
+## Layer 7 — New developer confusion test
+
+- No caller supplies a viewer ID to receipt RPCs; `auth.uid()` is always authoritative.
+- The server accepts recipient UUIDs only after validating active membership in the target org.
+- The capability flag documents the required server/client rollout order.
+- Local single-user assigned items and cloud mention items remain distinct data-source branches with one normalized Inbox model.
+
+## Layer 8 — Wire protocol and serialization
+
+- `cloud_add_session_comment_with_mentions` atomically writes the comment and its deduplicated recipient UUIDs.
+- Existing `cloud_list_session_comments` keeps its signature and legacy keys, adding `mentionedUserIds`.
+- Mention list rows add `readAt`; the page adds `unreadCount` and a keyset `nextCursor`.
+- Receipt mutations return both the resulting `readAt` and a fresh authoritative `unreadCount`.
+- Zod schemas reject malformed wire state before it enters UI state.
+
+## Layer 9 — Init parity
+
+- Initial Inbox load and pagination both use the same mention projection; only the first page replaces the authoritative count.
+- The initial cloud projection is capability-gated. A pre-0010 backend keeps local assigned items available without attempting a missing RPC.
+- Reopened comment surfaces load persisted recipient IDs from the ordinary comment list.
+- Roster loading is keyed by endpoint/account/org/revision and discards stale identity results.
+- Account/org changes evict the previous projection in a layout effect before paint; page and mutation completions carry a load generation and cannot repopulate the new identity with old rows.
+- Both primary and secondary desktop instances exercise the production UI/data paths in the extended E2E scenario.
+
+## Layer 10 — Resolver symmetry
+
+- Owner, assignee, reviewer, comment author, and mentioned recipient all resolve through the active org roster.
+- Mark-read, mark-unread, and mark-all share the same eligibility rules as list/count: membership, retention, deletion, visibility, and active sharing.
+- Restricted Sessions are visible only to owner or active grantees across both list and count paths.
+- The owner does not receive another member's targeted mention projection unless explicitly included as a recipient.
+
+## Completion verdict
+
+- Architecture verdict: pass for Layers 1–10 in the implemented scope.
+- Deployment gate: apply cloud migration `0010_team_inbox_mentions.sql` before shipping the desktop capability-enabled experience.
+- Remaining production proof: run the managed-cloud two-account E2E after the migration is applied.
diff --git a/docs/architecture-audit-2026-07-27/TeamInboxThread.md b/docs/architecture-audit-2026-07-27/TeamInboxThread.md
new file mode 100644
index 0000000000..dc306ab99e
--- /dev/null
+++ b/docs/architecture-audit-2026-07-27/TeamInboxThread.md
@@ -0,0 +1,98 @@
+# Architecture Audit — Team Inbox Thread and Kanban Refresh
+
+**Scope:** Team Inbox full Work Item loading/editing, shared Work Item presentation policy, canonical Start Agent handoff, Session-tab navigation, and local/cloud Kanban manual refresh.
+**Date:** 2026-07-27
+
+## Layer 1 — Compilation correctness
+
+- Focused Vitest suites: passed.
+- TypeScript `tsc --noEmit`: passed.
+- Focused ESLint: passed.
+
+## Layer 2 — Dead code and structural deduplication
+
+- Removed the body-only `useTeamInboxWorkItemBody` path.
+- `useTeamInboxWorkItem` now resolves the full canonical item used by both `WorkItemContent` and `WorkItemProperties`.
+- Moved `toWorkItemPartialUpdate` out of `WorkItemPanelView` so the Chat Panel and Team Inbox share one write-payload mapper.
+- The ordinary Work Item view and Team Inbox both use one `WorkItemContent`; only an explicit presentation policy differs.
+- `WorkItemThreadLayout` now owns the centered reading frame and metadata-band composition; `WorkItemThreadSection` owns the static card shell.
+- To-Do and Workflow share `WORK_ITEM_THREAD_TOKENS`, while Workflow retains the existing `CollapsibleSection` state owner rather than introducing a second collapsible abstraction.
+- Thread-only To-Do draft state is component-local and is never persisted until a non-empty item is committed.
+- `ChatPanelWorkItemActionRequest` is a transient one-slot command envelope. It carries intent only; the canonical Work Item orchestrator remains the sole execution owner.
+
+## Layer 3 — Naming consistency
+
+- Added `presentation: "default" | "thread"` rather than an ambiguous boolean such as `hideSessions`.
+- `start_agent` is named as a navigation action request instead of overloading ordinary `open_work_item`.
+- `usePendingWorkItemAction` names the only bridge from the transient request to the canonical Work Item start command.
+- Added a dedicated `open_session` navigation intent. Opening a Session no longer overloads `open_session_comment` with empty comment/thread IDs.
+- `refreshKanbanSources` names the local/cloud fan-out without claiming ownership of either cache.
+
+## Layer 4 — Semantic overloading
+
+| Term | Meaning | Verdict |
+| ------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| thread | One Work Item activity flow containing workflow/session cards and history | Distinct from a Session comment thread; scoped to `WorkItemContent` presentation. |
+| thread layout | Stateless Work Item-domain presentation primitives | Owns composition/tokens only; it does not own persistence, collapse state, or orchestration. |
+| Session open | Open/focus a Session Chat Panel tab | Explicit `open_session`; comment anchoring remains `open_session_comment`. |
+| refresh | User-triggered authoritative revalidation | Local roster and cloud teammate snapshots keep their own identity/single-flight owners. |
+| start request | One-shot UI intent for the matching canonical Work Item | Not workflow state and not persisted in the tab; claimed before async orchestration begins. |
+
+## Layer 5 — Default branch analysis
+
+- `resolveWorkItemContentSectionPolicy` handles both closed presentation variants and is unit-tested.
+- `default` preserves the legacy tabs plus linked-Session table for existing consumers.
+- `thread` omits that table, renders workflow/history inline, and renders output only when proof of work exists.
+- Thread description transitions are explicit: read → editing → dirty → saved/cancelled. Save is disabled in editing/clean state.
+- Start transitions are explicit: Inbox idle action → resolve/open canonical Work Item → publish matching request → atomically claim request → existing orchestrator validates configuration/locks and starts or reports failure.
+- A claimed request is cleared before the async call, so remounts and repeated React effects cannot replay it. A non-matching Work Item cannot claim it.
+- The transient channel holds at most one unclaimed request. A newer navigation intent supersedes an older unclaimed intent, preventing a hidden tab from starting unexpectedly when visited later.
+- Read/update failures are explicit UI states; they do not fall back to fabricated data.
+
+## Layer 6 — Cross-domain concept leakage
+
+- Project persistence stays behind `projectApi` and the shared Work Item payload mapper.
+- Team Inbox owns selection and presentation only.
+- Thread primitives live under the Work Item component domain rather than a global shared package because the reading width, metadata band, and density are Work Item-specific.
+- Agent execution remains exclusively owned by the canonical Work Item surface. Team Inbox publishes intent but does not mount a second orchestrator (which would duplicate collaboration-lock, auto-review, and stale-session lifecycles).
+- Chat Panel atoms remain the sole owner of Session tab creation/focus.
+- Kanban composes refresh callbacks but does not take ownership of session/cloud caches.
+
+## Layer 7 — New developer confusion test
+
+- The presentation policy documents exactly which legacy elements are absent.
+- The thread layout API uses semantic slots (`path`, `properties`, `title`, `meta`, `action`) instead of exposing consumer-defined class bags.
+- Static versus collapsible cards remain visibly consistent through one token source, while their interaction semantics stay explicit in their owning components.
+- The full Work Item hook exposes `loading / ready / error` rather than conflating missing data with loading.
+- Standalone items remain readable but do not expose non-functional edit controls.
+- Project-scoped items expose compact shared property pills; the full property editor remains available through the canonical Work Item surface.
+
+## Layer 8 — Wire protocol and serialization
+
+- No new wire format was introduced.
+- The extracted presentation primitives are stateless and introduce no new IPC, persistence, cache, subscription, timer, or request lifecycle.
+- The start request is process-local transient UI state; it never enters tab persistence, project persistence, IPC, or the Agent wire payload.
+- Work Item writes reuse the existing `WorkItemPartialUpdate` contract.
+- To-Do drafts never cross that boundary; only normalized committed rows are serialized.
+- Team/shared `+/-` impact is not synthesized: Kanban continues to consume authoritative local impact and cloud session metadata only.
+
+## Layer 9 — Init parity
+
+- No Agent initialization entry point changed. The request terminates at the same `handleStartAgent` used by the existing Work Item button.
+- Manual refresh uses the same production local roster coordinator and cloud remote-session hook used by initial demand/realtime recovery.
+- Tests call the source-composition helper only; rendered acceptance must still drive the real button.
+
+## Layer 10 — Resolver symmetry
+
+- Project-scoped reads resolve Work Item plus project metadata/repo identity; standalone reads use the standalone API and stay read-only.
+- Local and cloud Kanban sources are both invoked by the manual action, while each source preserves its own scope/identity rules.
+- Existing Session tabs are focused; missing tabs are created through the same open-or-focus atom for both Session cards and mention navigation.
+- Work Item action resolution is symmetric for newly created and already-open tabs: both are activated first, then receive the same keyed one-shot request.
+
+## Completion verdict
+
+- One persistent Work Item owner, one Agent start dispatcher, one Session-tab dispatcher, and one cache owner per Kanban source.
+- The Team Inbox navigation wrapper now forwards explicit child intents, so Session cards no longer collapse back to the selected row's generic Work Item destination.
+- Stale Work Item reads are cancelled on selection change; overlapping writes use a monotonic generation before replacing UI state.
+- Manual workflow refresh preserves the currently rendered Work Item on read failure and exposes the error banner; it does not replace success data with a transient empty state.
+- Architecture verdict: pass for Layers 1–10 in the changed scope.
diff --git a/docs/frontend-ui-audit-2026-07-27/TeamInboxCollaboration.md b/docs/frontend-ui-audit-2026-07-27/TeamInboxCollaboration.md
new file mode 100644
index 0000000000..b2793b70c0
--- /dev/null
+++ b/docs/frontend-ui-audit-2026-07-27/TeamInboxCollaboration.md
@@ -0,0 +1,51 @@
+# Frontend UI Audit — Team Inbox Multi-User Collaboration
+
+**Files:** `src/features/Org2Cloud/SessionComments/*.tsx`, `src/modules/MainApp/TeamInbox/**/*.tsx`, `src/modules/ProjectManager/WorkItems/components/WorkItemContent/*.tsx`
+**Date:** 2026-07-27
+**Auditor:** Codex implementation session
+
+## D1 — Raw HTML vs Design System
+
+| Line | Element | Verdict | Reason | Suggested change |
+| ---------------------------- | ------------------------------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `CommentThreadList.tsx` | member mention picker | fix | A collaboration action needs the same keyboard/search/selection behavior as other menus. | Reused the shared `Dropdown` in multiple-selection mode and the shared tertiary `Button`; no bespoke popover was introduced. |
+| `CommentThreadList.tsx` | selected and persisted mention chips | abstract | Composer selections and rendered comments initially repeated the same identity pill styling and ID-to-name resolution. | Added one `resolveMentions` projection and one `MemberMentionChip` presentation primitive within the owning comment domain. |
+| `AssignedWorkItemDetail.tsx` | assignee/reviewer presentation | fix | Showing only a raw assignee UUID made team ownership ambiguous and omitted reviewer state. | Reused the Work Item property surface with the complete active roster so assignee and reviewer resolve to member display names. |
+| `TeamInboxList.tsx` | mark-all-read action | keep with reason | This is a standard labeled command, already implemented with the shared Button and now receives only a stable test hook. | — |
+| `TeamInboxRow.tsx` | unread row | keep with reason | The existing row owns selection, unread emphasis, and keyboard activation; the change adds semantic test/state attributes without duplicating it. | — |
+
+## D2 — Arbitrary Tailwind Value vs Token
+
+| Line | Value | Verdict | Reason | Suggested change |
+| ----------------------- | ------------------------------ | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `CommentThreadList.tsx` | `max-w-[160px]`, `text-[10px]` | keep with reason | These match the established compact comment-meta density and bound long member names. The values are centralized in `MemberMentionChip`. | Promote a global identity-chip token only if a second product domain needs the same compact treatment. |
+| changed files | colors | keep with reason | All new color usage is expressed through semantic primary/background/text/border tokens. No raw color literals were added. | — |
+
+## D3 — Hardcoded Sizes / Colors
+
+| Line | Value | Verdict | Reason | Suggested change |
+| ----------------------- | ---------------------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| `CommentThreadList.tsx` | mention pill width cap | keep with reason | The cap prevents a single member name from consuming the composer action row while preserving the full identity in the searchable picker. | Add a tooltip only if real rosters show frequent ambiguous truncation. |
+| `TeamInboxView.tsx` | no new fixed geometry | keep with reason | Optimistic state and authoritative counts change behavior only; the existing compact Inbox layout is preserved. | — |
+
+## D4 — Accessibility
+
+| Line | Element | Verdict | Reason | Suggested change |
+| ----------------------- | --------------------- | ---------------- | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `CommentThreadList.tsx` | mention member action | fix | The action must be keyboard reachable and expose a visible label. | Shared Button renders the translated “Mention” label; shared Dropdown provides search and selection keyboard behavior. |
+| `TeamInboxList.tsx` | mark all as read | keep with reason | The action already has a translated visible label and native Button semantics. | — |
+| `TeamInboxRow.tsx` | unread state | fix | Visual emphasis alone is insufficient for deterministic behavioral verification. | Added stable row identity and `data-unread` state; existing visible unread indicator remains unchanged. |
+
+## D5 — Visual Patterns Observed
+
+- Member identity is selected from the authoritative active roster and persisted as UUIDs; display names are a rendering projection.
+- Mention chips share one product-domain component across draft and persisted states.
+- Team Inbox keeps the existing unified thread hierarchy; collaboration adds data and state, not a second detail layout.
+- Reviewer and assignee reuse the canonical Work Item property UI instead of introducing Inbox-only badges.
+- The picker is capability-gated, so older cloud deployments do not render a control whose RPC is unavailable.
+
+## Summary
+
+- 5 fixes completed
+- 5 kept with documented reason
+- 1 abstract candidate completed
diff --git a/docs/frontend-ui-audit-2026-07-27/TeamInboxResponsive.md b/docs/frontend-ui-audit-2026-07-27/TeamInboxResponsive.md
new file mode 100644
index 0000000000..d32b9a04f6
--- /dev/null
+++ b/docs/frontend-ui-audit-2026-07-27/TeamInboxResponsive.md
@@ -0,0 +1,48 @@
+# Frontend UI Audit — Team Inbox Responsive Detail
+
+**Files:** `src/modules/MainApp/TeamInbox/TeamInboxView.tsx`, `src/modules/MainApp/TeamInbox/components/AssignedWorkItemDetail.tsx`, `src/modules/ProjectManager/WorkItems/components/WorkItemProperties/index.tsx`
+**Date:** 2026-07-27
+**Auditor:** Codex
+
+## D1 — Raw HTML vs Design System
+
+| Line | Element | Verdict | Reason | Suggested change |
+| -------------------------------------- | ---------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------- |
+| WorkItemProperties: 301 | More-properties action | keep with reason | Uses the shared `Button` component with the established circular secondary treatment. | — |
+| TeamInboxView / AssignedWorkItemDetail | Interactive controls | keep with reason | All controls are delegated to shared `SplitViewLayout`, `WorkItemProperties`, and detail components; no new raw interactive HTML was introduced. | — |
+
+## D2 — Arbitrary Tailwind Value vs Token
+
+| Line | Value | Verdict | Reason | Suggested change |
+| ---------------------- | -------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
+| WorkItemProperties: 42 | `bg-[var(--cm-editor-background,...)]` | fix candidate | Pre-existing project-owned surface token; the repo sweep finds three direct uses. This is outside the responsive fix and should be handled once as a token-mapping sweep. | Add a semantic Tailwind surface mapping, then replace all three sites together. |
+
+## D3 — Hardcoded Sizes / Colors
+
+| Line | Value | Verdict | Reason | Suggested change |
+| ---------------------- | --------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ---------------- |
+| TeamInboxView: 406–407 | `listWidth={200}`, `minListWidth={160}` | keep with reason | Existing resizable master-list bounds; detail responsiveness is owned by the remaining flex width and wrapping property layout. | — |
+| WorkItemProperties: 44 | `text-[13px]` | keep with reason | Existing dense property typography, repeated consistently throughout Work Items; changing one header would reduce local consistency. | — |
+
+## D4 — Accessibility
+
+| Line | Element | Verdict | Reason | Suggested change |
+| ----------------------------- | ---------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------- |
+| AssignedWorkItemDetail: 63–76 | Responsive property controls | keep with reason | Wrapping changes visual flow only; shared fields retain native button semantics, accessible names, keyboard handling, and portalled menus. | — |
+| TeamInboxView: 404–412 | Split-view header policy | keep with reason | Removing the unrelated global breadcrumb also removes a misleading navigation announcement from the Team Inbox reading order. | — |
+
+## D5 — Visual Patterns Observed
+
+- Responsive pill layout is implemented once in shared `WorkItemProperties` through an explicit `pillLayout` policy.
+- Team Inbox opts into wrapping; existing inline-create hosts preserve their compact single-row behavior.
+- No new repeated visual pattern or abstraction candidate was introduced.
+
+## Next-refactor candidates
+
+- Sweep the three `bg-[var(--cm-editor-background,...)]` uses into one semantic Tailwind surface token rather than changing only this component.
+
+## Summary
+
+- 1 fix candidate, intentionally deferred to a repository-wide token sweep
+- 4 kept with documented reason
+- 0 new abstract candidates
diff --git a/docs/frontend-ui-audit-2026-07-27/TeamInboxThread.md b/docs/frontend-ui-audit-2026-07-27/TeamInboxThread.md
new file mode 100644
index 0000000000..1989d8c3b4
--- /dev/null
+++ b/docs/frontend-ui-audit-2026-07-27/TeamInboxThread.md
@@ -0,0 +1,61 @@
+# Frontend UI Audit — Team Inbox Work Item Thread and Kanban Refresh
+
+**Files:** `src/modules/MainApp/TeamInbox/components/*.tsx`, `src/modules/ProjectManager/WorkItems/components/WorkItemContent/*.tsx`, `src/modules/ProjectManager/WorkItems/components/AgentWorkflow/*.tsx`, `src/modules/shared/components/ActivityTimeline/index.tsx`, `src/features/TaskKanban/**/*.tsx`
+**Date:** 2026-07-27
+**Auditor:** Codex implementation session
+
+## D1 — Raw HTML vs Design System
+
+| Line | Element | Verdict | Reason | Suggested change |
+| ---------------------------------------- | ------------------------------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `AssignedWorkItemDetail.tsx` | Work Item content/property controls | fix | The initial unified version still placed two heavy property cards in a competing right rail. | Reused `WorkItemProperties` in pill mode inside one compact metadata band and removed the Team Inbox-only rail. |
+| `WorkItemContent/index.tsx` | always-mounted description editor | fix | Preview/Raw controls and a 200px editor made reading a short Inbox item feel like editing a full database record. | Thread mode now renders natural-height Markdown and demand-mounts the shared editor after an explicit Edit action. |
+| `ThreadTodoChecklist.tsx` | empty To-Do editor | fix | The generic checklist immediately persisted an empty row and exposed an input before user intent. | Added a thread-specific demand composer that commits only trimmed, non-empty items and reuses Button/Input/Checkbox. |
+| `HistoryTab.tsx` | disconnected subscription/avatar row | fix | Subscription, avatar, history, composer, and submit were visually unrelated. | Grouped subscription with the Activity heading and attached the avatar to the outlined comment composer. |
+| `AssignedWorkItemDetail.tsx` | missing idle Agent Workflow action | fix | Removing the previous no-op callback also removed the visible primary action, leaving actionable copy without a control. | Restored the shared Agent Workflow `Button`; it forwards a one-shot start intent to the canonical Work Item surface. |
+| `ThreadTodoChecklist.tsx` | empty-state full-row action | fix | The full-width empty-state hit area is still a standard labeled action. | Reused the shared Button in long/ghost form with right-side icon instead of maintaining raw button styling. |
+| `WorkItemThread/index.tsx` | repeated thread card/layout shells | abstract | The centered reading column, metadata band, and card header/body treatment were repeated or assembled at consumer sites, making future thread surfaces likely to drift. | Added Work Item-owned `WorkItemThreadLayout` / `WorkItemThreadSection`; collapsible Workflow consumes the same token set while retaining `CollapsibleSection` semantics. |
+| `KanbanHeaderTrailingControls/index.tsx` | refresh action | fix | Kanban had no manual refresh control. | Added the shared `Button` tertiary/ghost treatment, `WorkstationToolbarTooltip`, and `useRefreshSpin`. |
+| `TaskKanban/index.tsx:396` | raw circular add-session `` | keep with reason | Existing bottom-overlay control has a specialized floating circular hit area and positioning contract; it is unrelated to the new header refresh action and was not reimplemented in this change. | Consider a separate `IconButton` sweep for floating Work Management actions. |
+
+## D2 — Arbitrary Tailwind Value vs Token
+
+| Line | Value | Verdict | Reason | Suggested change |
+| ----------------------------------------------- | ------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
+| Work Item thread files | `text-[11px]`, `text-[13px]`, `text-[14px]` | keep with reason | These values match the established Work Item property, timeline, and editor density. They are typography roles, not arbitrary spatial geometry or raw colors. | — |
+| `KanbanHeaderTrailingControls/index.tsx:95,106` | `text-[12px]` | keep with reason | Existing compact Select triggers require the 12px toolbar density; the new refresh control uses shared button sizing and adds no arbitrary typography. | — |
+
+## D3 — Hardcoded Sizes / Colors
+
+| Line | Value | Verdict | Reason | Suggested change |
+| ---------------------------------- | --------------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
+| `WorkItemContent/index.tsx` | 920px thread maximum width | keep with reason | A bounded reading measure prevents long Markdown/activity lines on wide desktop windows while still fitting the property-pill row. It uses the existing detail-panel width family. | — |
+| `ProjectContentEditor` thread mode | 120px / 360px editor limits | keep with reason | Interaction bounds apply only after explicit Edit: enough space for useful authoring without recreating the oversized always-on editor. | — |
+| changed files | colors | keep with reason | All added colors use semantic danger/background/text/border tokens. No raw hex/rgb/hsl colors were added. | — |
+
+## D4 — Accessibility
+
+| Line | Element | Verdict | Reason | Suggested change |
+| ---------------------------------------- | ------------------------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| `KanbanHeaderTrailingControls/index.tsx` | icon-only refresh | fix | New action needs an accessible name and visible hover explanation. | Added translated `aria-label` plus shared toolbar tooltip; spinner icon is `aria-hidden`. |
+| `AssignedWorkItemDetail.tsx` | `Start Agent` action | fix | The idle workflow copy must have an operable, keyboard-accessible primary action rather than a visually implied action. | Reused the existing named primary Button and its disabled/loading policy. |
+| `TaskKanban/index.tsx` | refresh failure banner | fix | Async failure must be announced without removing the board. | Added a tokenized `role="status"` banner while retaining existing cards. |
+| Session run cards | open/focus Session action | keep with reason | Existing Session-card buttons provide visible labels (`View live chat` / `View conversation`) and use the canonical navigation callback. | — |
+| `WorkItemContent/index.tsx` | Edit/Save/Cancel description controls | fix | Editing needs an explicit entry state and disabled Save before changes. | Added named Edit action, disabled-until-dirty Save, Cancel restoration, and compact editor bounds. |
+| `ThreadTodoChecklist.tsx` | icon-only delete/cancel actions | fix | Icon-only actions require accessible names and visible keyboard focus behavior. | Added translated `aria-label`; delete is revealed on hover or `focus-visible`. |
+
+## D5 — Visual Patterns Observed
+
+- Work Item persistence, properties, workflow/session cards, and activity reuse their existing owning components. The only Inbox-specific component is the deliberately different demand-commit To-Do interaction.
+- Refresh visuals reuse the established tertiary button + `useRefreshSpin` pattern already used by Work Item workflow and shared panel headers.
+- The Team Inbox-only thread mode remains an explicit presentation policy on the shared Work Item component, not a second persistence/detail hierarchy.
+- The restored Start Agent affordance reuses the shared Agent Workflow control; Inbox contributes only navigation intent and no duplicate button styling.
+- Description edit actions extend the shared `TimelineCard` action slot, so other timeline surfaces can adopt the same header composition without copying markup.
+- The repeated shell is abstracted inside the Work Item domain rather than promoted to a global design-system Card: its 920px reading measure, metadata pills, and thread density are product-specific.
+- Static To-Do sections use `WorkItemThreadSection`; the stateful Workflow continues to use shared `CollapsibleSection` with `WORK_ITEM_THREAD_TOKENS`, avoiding a second collapse implementation.
+
+## Summary
+
+- 13 fixes completed
+- 7 kept with documented reason
+- 1 abstract candidate completed
diff --git a/docs/org2-performance-guard-2026-07-27/TeamInboxCollaboration.md b/docs/org2-performance-guard-2026-07-27/TeamInboxCollaboration.md
new file mode 100644
index 0000000000..0e9114da9c
--- /dev/null
+++ b/docs/org2-performance-guard-2026-07-27/TeamInboxCollaboration.md
@@ -0,0 +1,25 @@
+# ORG2 Performance Guard — Team Inbox Multi-User Collaboration
+
+**Date:** 2026-07-27
+
+| Lifecycle / area | Active | Idle / hidden | Repeated open/close | Verdict and verification |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------- |
+| Roster loading | One demand read through the shared endpoint/account/org/revision coordinator. | No polling, timer, subscription, or worker added. | Cached coordinator result is reused; late identity responses are discarded and effects cancel commits after unmount. | pass — code trace, ESLint, typecheck |
+| Inbox listing | Keyset pages are bounded to 100 rows; full unread total is computed server-side. | No background pagination or retained scan. | Cache replaces the first page and appends later pages without duplicating authoritative counts. | pass — client unit tests and SQL review |
+| Read mutations | User-triggered, idempotent upsert/delete; optimistic UI is generation guarded and durable writes are serialized through a queue capped at 100 pending actions. | No retry loop beyond the existing bounded transport retry. | Account/org generation rejects late completions; server totals repair count state; receipts remain one row per viewer/comment. | pass — focused client tests, typecheck, lifecycle trace |
+| Mark all | One explicit bulk upsert for currently eligible mentions. | Does not run automatically. | Primary key prevents growth from repeated invocation; returned count is recomputed to include concurrent mentions. | pass — SQL lifecycle review |
+| Comment mentions | At most 50 deduplicated member UUIDs per new comment. | No retained composer data after successful submit. | Failed submit preserves only local draft state; no duplicate background writer. | pass — client unit tests and SQL validation |
+| Database access | GIN lookup uses `mentioned_user_ids @> array[viewer]`; row ordering uses `(org_id, created_at desc, id desc)`. | No database work without a request. | Receipt lookup is primary-key/index backed; per-page thread counts are bounded by the page limit. | pass with live-query-plan follow-up after deployment |
+| Identity switch | The active endpoint/account/org is part of the request key and every async path captures a load generation. | Previous rows/counts are evicted in a layout effect before paint. | Late initial-page, pagination, and receipt completions are discarded after a scope switch. | pass — code trace, typecheck |
+
+## Rejection-rule review
+
+- No polling, timer, streaming loop, worker, unbounded cache, or cross-instance singleton was added.
+- No scan is initiated while the Inbox is hidden.
+- Viewer identity and org scope are part of every cache/request boundary, and prior-scope rows are cleared before paint.
+- The only potentially growing state is durable receipt data, bounded to one row per mentioned viewer/comment and cascade-deleted with its org/comment.
+
+## Verdict
+
+- Performance verdict: pass.
+- Deployment follow-up: capture `EXPLAIN (ANALYZE, BUFFERS)` for mention list/count on production-like cardinality after applying migration 0010.
diff --git a/docs/org2-performance-guard-2026-07-27/TeamInboxKanban.md b/docs/org2-performance-guard-2026-07-27/TeamInboxKanban.md
new file mode 100644
index 0000000000..257dd3e46c
--- /dev/null
+++ b/docs/org2-performance-guard-2026-07-27/TeamInboxKanban.md
@@ -0,0 +1,12 @@
+# ORG2 Performance Guard — Team Inbox Thread and Kanban Refresh
+
+**Date:** 2026-07-27
+
+| Area | Verdict | Evidence | Change or reason kept | Verification |
+| ------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| Background work | keep | No timer, polling loop, or retained subscription was added. The To-Do composer uses one `requestAnimationFrame` only after a successful commit to restore focus. | Full Work Item load is selection-driven; Kanban refresh is user-driven. Team Inbox publishes a one-shot start intent but deliberately does not mount `useWorkItemOrchestrator`, avoiding duplicate collaboration-lock, auto-review, and stale-session lifecycles. | Call-chain/lifecycle trace; focused tests |
+| Memory | keep | The new action atom retains at most one small request and is cleared synchronously when its matching Work Item claims it. | It is transient process state, excluded from persisted Chat Panel tabs, and cannot grow with repeated actions. A newer unclaimed intent supersedes the older one instead of leaving a delayed action behind. | Exact-once, supersession, mismatch-isolation, and remount tests |
+| Scope/isolation | keep | Cloud refresh stays keyed by authenticated identity + org; local refresh uses the process-wide roster coordinator | Manual action composes existing source owners and does not introduce a cross-identity cache | Existing remote-session identity/generation guards; typecheck |
+| Rendering/hot path | keep | Existing cards remain mounted during refresh; Work Item thread loads full detail only after selection; description editor and To-Do composer mount only after explicit intent | The Start Agent handoff adds one atom read on the canonical Work Item panel and performs no work while no matching request exists. No eager scan, clone, or duplicate orchestrator was added. | Focused Work Item/Inbox/Kanban/action tests; ESLint; typecheck |
+
+- Performance verdict: pass.
From 345943b6119f22a9af7496998de6c28a7819b6a1 Mon Sep 17 00:00:00 2001
From: hanafish <1106510024@qq.com>
Date: Mon, 27 Jul 2026 23:48:10 +0800
Subject: [PATCH 05/11] docs(audit): record merged validation count
---
docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md b/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md
index 0d9af282b0..99aed8d570 100644
--- a/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md
+++ b/docs/architecture-audit-2026-07-27/TeamInboxCollaboration.md
@@ -7,7 +7,7 @@
- TypeScript `tsc --noEmit`: passed.
- Focused ESLint over all changed collaboration/UI files: passed.
-- Twenty-four focused Vitest files: 230 tests passed after the capability-gate regression cases were added.
+- Twenty-four focused Vitest files: 229 tests passed after rebasing onto the latest `develop` and adding capability-gate regression coverage.
- Cloud migration was statically reviewed; live apply and live two-account E2E remain deployment validation.
## Layer 2 — Dead code and structural deduplication
From 0133aef5c5d7fa5f2539f8ebb106a96bc52bc279 Mon Sep 17 00:00:00 2001
From: hanafish <1106510024@qq.com>
Date: Tue, 28 Jul 2026 12:55:14 +0800
Subject: [PATCH 06/11] feat(team-inbox): unify collaborative work item threads
Pre-commit hook ran. Total eslint: 2, total circular: 0
---
.../src/projects/io/work_items/atomic.rs | 73 +-
.../projects/io/work_items/atomic_tests.rs | 77 +-
.../src/projects/io/work_items/history.rs | 24 +-
.../src/projects/types/work_items.rs | 11 +
src/api/http/project/types/workItems.ts | 7 +
src/components/ComposerShell/index.tsx | 7 +-
.../ChatPanel/panels/ProjectPanelView.tsx | 15 +-
.../ChatPanel/panels/WorkItemPanelView.tsx | 187 ++--
.../Org2Cloud/org2CloudCapabilities.ts | 8 +-
src/features/Org2Cloud/org2CloudClient.ts | 15 +-
.../Org2Cloud/teamInboxMentionsClient.test.ts | 19 +
.../Org2Cloud/teamInboxMentionsClient.ts | 109 ++-
.../project/useCurrentUserMemberId.test.ts | 162 ++++
src/hooks/project/useCurrentUserMemberId.ts | 165 +++-
src/i18n/locales/en/common.json | 16 +-
src/i18n/locales/zh/common.json | 15 +-
.../TeamInbox/ConnectedTeamInboxView.tsx | 10 +-
src/modules/MainApp/TeamInbox/TEST_CASES.md | 44 +-
.../MainApp/TeamInbox/TeamInboxView.tsx | 303 +++---
.../__tests__/AssignedWorkItemDetail.test.ts | 56 +-
.../MainApp/TeamInbox/__tests__/TEST_CASES.md | 38 +-
.../TeamInbox/__tests__/TeamInboxList.test.ts | 44 +
.../TeamInbox/__tests__/TeamInboxRow.test.ts | 112 +++
.../__tests__/TeamInboxView.layout.test.ts | 150 ++-
.../__tests__/teamInboxCoordinator.test.ts | 385 ++++++++
.../__tests__/useTeamInboxWorkItem.test.ts | 206 ++++
src/modules/MainApp/TeamInbox/api.ts | 2 +-
.../components/AssignedWorkItemDetail.tsx | 94 +-
.../components/CommentMentionDetail.tsx | 17 +-
.../TeamInbox/components/TeamInboxList.tsx | 74 +-
.../TeamInbox/components/TeamInboxRow.tsx | 57 +-
src/modules/MainApp/TeamInbox/domain/index.ts | 2 +
src/modules/MainApp/TeamInbox/domain/types.ts | 22 +
src/modules/MainApp/TeamInbox/store.ts | 5 +-
.../MainApp/TeamInbox/teamInboxCoordinator.ts | 884 ++++++++++++++++++
.../TeamInbox/useTeamInboxDataSource.ts | 739 ++++-----------
.../TeamInbox/useTeamInboxNavigation.ts | 33 +-
.../MainApp/TeamInbox/useTeamInboxWorkItem.ts | 142 ++-
...ProjectWorkItemsTabContentInteractions.tsx | 15 +-
.../__tests__/workItemPartialUpdate.test.ts | 26 +-
.../components/WorkItemContent/HistoryTab.tsx | 130 ++-
.../__tests__/HistoryTab.test.ts | 197 ++++
.../WorkItemContent/__tests__/TEST_CASES.md | 29 +
.../WorkItemDescriptionEditing.test.ts | 68 ++
.../__tests__/useWorkItemTimeline.test.ts | 18 +-
.../WorkItemContent/descriptionMarkdown.ts | 23 +
.../hooks/useWorkItemContentState.tsx | 34 +-
.../components/WorkItemContent/index.tsx | 11 +-
.../components/WorkItemContent/types.ts | 2 +
.../WorkItemContent/useWorkItemTimeline.ts | 18 +-
.../components/WorkItemProperties/index.tsx | 15 +
.../__tests__/WorkItemThreadSurface.test.ts | 95 ++
.../WorkItemThreadSurface/index.tsx | 57 ++
.../WorkItems/components/index.ts | 6 +-
.../WorkItems/hooks/useWorkItemsData.ts | 97 +-
.../WorkItems/workItemPartialUpdate.ts | 31 +-
.../components/ProjectContentEditor/index.tsx | 3 +
.../layouts/blocks/CollapsibleSection.tsx | 1 +
58 files changed, 3836 insertions(+), 1369 deletions(-)
create mode 100644 src/hooks/project/useCurrentUserMemberId.test.ts
create mode 100644 src/modules/MainApp/TeamInbox/__tests__/TeamInboxList.test.ts
create mode 100644 src/modules/MainApp/TeamInbox/__tests__/TeamInboxRow.test.ts
create mode 100644 src/modules/MainApp/TeamInbox/__tests__/teamInboxCoordinator.test.ts
create mode 100644 src/modules/MainApp/TeamInbox/__tests__/useTeamInboxWorkItem.test.ts
create mode 100644 src/modules/MainApp/TeamInbox/teamInboxCoordinator.ts
create mode 100644 src/modules/ProjectManager/WorkItems/components/WorkItemContent/__tests__/HistoryTab.test.ts
create mode 100644 src/modules/ProjectManager/WorkItems/components/WorkItemContent/descriptionMarkdown.ts
create mode 100644 src/modules/ProjectManager/WorkItems/components/WorkItemThreadSurface/__tests__/WorkItemThreadSurface.test.ts
create mode 100644 src/modules/ProjectManager/WorkItems/components/WorkItemThreadSurface/index.tsx
diff --git a/src-tauri/crates/project-management/src/projects/io/work_items/atomic.rs b/src-tauri/crates/project-management/src/projects/io/work_items/atomic.rs
index 19065e9708..52d1110a0c 100644
--- a/src-tauri/crates/project-management/src/projects/io/work_items/atomic.rs
+++ b/src-tauri/crates/project-management/src/projects/io/work_items/atomic.rs
@@ -78,7 +78,13 @@ where
F: FnOnce(&mut WorkItemFrontmatter, &mut String) -> Result,
{
let (value, changed_fields, payload_tail_changed) =
- update_work_item_atomic_with_revisions(project_slug, short_id, HashMap::new(), mutator)?;
+ update_work_item_atomic_with_revisions(
+ project_slug,
+ short_id,
+ HashMap::new(),
+ None,
+ mutator,
+ )?;
if !changed_fields.is_empty() {
// Re-read the work item to build the outbox payload. The read
// is one extra round trip but keeps the closure-form API
@@ -135,6 +141,7 @@ pub fn update_work_item_atomic_with_revisions(
project_slug: &str,
short_id: &str,
override_revisions: HashMap,
+ actor: Option<&crate::projects::types::WorkItemMutationActor>,
mutator: F,
) -> Result<(T, Vec<&'static str>, bool), String>
where
@@ -244,6 +251,12 @@ where
let result = mutator(&mut frontmatter, &mut body)?;
let changed_fields = before.diff(&frontmatter, &body);
+ let assignment_changed =
+ core.assignee != frontmatter.assignee || core.assignee_type != frontmatter.assignee_type;
+ let assigned_human_id = human_assignee_id(
+ frontmatter.assignee.as_deref(),
+ frontmatter.assignee_type.as_deref(),
+ );
let payload_tail_changed = payload_tail_fingerprint(&frontmatter) != tail_before;
let scheduler_changed = scheduler_before
!= (
@@ -317,16 +330,17 @@ where
priority = ?4,
assignee = ?5,
assignee_type = ?6,
- milestone = ?7,
- parent = ?8,
- start_date = ?9,
- target_date = ?10,
- org_id = ?11,
- project_id = ?12,
- created_at = ?13,
- updated_at = ?14,
- local_version = ?15
- WHERE id = ?16",
+ assigned_human_id = ?7,
+ milestone = ?8,
+ parent = ?9,
+ start_date = ?10,
+ target_date = ?11,
+ org_id = ?12,
+ project_id = ?13,
+ created_at = ?14,
+ updated_at = ?15,
+ local_version = ?16
+ WHERE id = ?17",
params![
frontmatter.title,
body,
@@ -334,6 +348,7 @@ where
frontmatter.priority,
frontmatter.assignee,
frontmatter.assignee_type,
+ assigned_human_id,
frontmatter.milestone,
frontmatter.parent,
frontmatter.start_date,
@@ -347,6 +362,17 @@ where
],
))?;
+ if assignment_changed {
+ // A receipt acknowledges one assignment episode, not the Work Item for
+ // all time. Clear every viewer's old episode in the same transaction as
+ // the assignee write so reassignment can never commit half-way.
+ map_db(tx.execute(
+ "DELETE FROM team_inbox_read_receipts
+ WHERE source_kind = 'work_item_assigned' AND source_id = ?1",
+ params![&core.work_item_id],
+ ))?;
+ }
+
// Replace label set.
map_db(tx.execute(
"DELETE FROM workitem_labels WHERE work_item_id = ?1",
@@ -372,7 +398,13 @@ where
// revision, regardless of whether the value diffed. This is
// what lets the merge cycle pin watermarks for fields where the
// resolver-adopted value happens to equal the pre-mutator value.
- append_mutation_event(&history_before, &mut frontmatter, &body, &to_iso8601(now));
+ append_mutation_event(
+ &history_before,
+ &mut frontmatter,
+ &body,
+ &to_iso8601(now),
+ actor,
+ );
let mut next_extras = ExtrasPayload::from_frontmatter(&frontmatter);
next_extras.field_revisions = extras.field_revisions.clone();
@@ -551,6 +583,7 @@ pub fn update_work_item_partial_with_revisions(
project_slug,
short_id,
override_revisions,
+ updates.actor.as_ref(),
|fm, body| {
let now_iso = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
@@ -719,6 +752,22 @@ fn slices_equal_unordered(left: &[String], right: &[String]) -> bool {
left_sorted == right_sorted
}
+fn human_assignee_id(
+ assignee: Option<&str>,
+ assignee_type: Option<&str>,
+) -> Option {
+ let assignee = assignee?.trim();
+ if assignee.is_empty() {
+ return None;
+ }
+ let is_human = assignee_type
+ .map(str::trim)
+ .filter(|value| !value.is_empty())
+ .map(|value| value.eq_ignore_ascii_case("member") || value.eq_ignore_ascii_case("human"))
+ .unwrap_or(true);
+ is_human.then(|| assignee.to_string())
+}
+
struct AtomicCore {
work_item_id: String,
short_id: String,
diff --git a/src-tauri/crates/project-management/src/projects/io/work_items/atomic_tests.rs b/src-tauri/crates/project-management/src/projects/io/work_items/atomic_tests.rs
index 23fec34867..51d8d55409 100644
--- a/src-tauri/crates/project-management/src/projects/io/work_items/atomic_tests.rs
+++ b/src-tauri/crates/project-management/src/projects/io/work_items/atomic_tests.rs
@@ -5,7 +5,7 @@ use crate::projects::io::projects::write_project;
use crate::projects::io::work_items::{read_standalone_work_item, read_work_item, write_work_item};
use crate::projects::types::{
CommentEntry, ProjectMeta, TodoEntry, WorkItemHistoryAction, WorkItemPartialUpdate,
- WorkItemSchedule,
+ WorkItemMutationActor, WorkItemSchedule,
};
use test_helpers::test_env;
@@ -129,6 +129,8 @@ fn partial_update_records_property_and_body_history() {
.changes
.iter()
.any(|change| change.field == "priority"));
+ assert_eq!(event.actor_id, None);
+ assert_eq!(event.actor_name, None);
}
#[test]
@@ -139,10 +141,14 @@ fn partial_update_records_comment_history_event() {
let updates = WorkItemPartialUpdate {
comments: Some(vec![CommentEntry {
id: "c1".to_string(),
- author: "Ada".to_string(),
+ author: "member-1".to_string(),
content: "Looks good".to_string(),
created_at: "2026-01-01T00:00:00Z".to_string(),
}]),
+ actor: Some(WorkItemMutationActor {
+ id: "member-1".to_string(),
+ name: "Ada".to_string(),
+ }),
..Default::default()
};
update_work_item_partial("demo", "AAA-0001", &updates).expect("update");
@@ -150,6 +156,8 @@ fn partial_update_records_comment_history_event() {
let after = read_work_item("demo", "AAA-0001").expect("read");
let event = after.frontmatter.history.last().expect("history event");
assert_eq!(event.action, WorkItemHistoryAction::Commented);
+ assert_eq!(event.actor_id.as_deref(), Some("member-1"));
+ assert_eq!(event.actor_name.as_deref(), Some("Ada"));
assert_eq!(event.changes.len(), 1);
assert_eq!(event.changes[0].field, "comments");
}
@@ -312,6 +320,71 @@ fn partial_clears_assignee_with_some_none() {
assert!(result.frontmatter.assignee.is_none(), "assignee cleared");
}
+#[test]
+fn assignee_change_atomically_resets_team_inbox_receipts() {
+ let _sandbox = test_env::sandbox();
+ seed("demo", "p1");
+
+ let mut assign_alice = WorkItemPartialUpdate::default();
+ assign_alice.assignee = Some(Some("member-alice".to_string()));
+ assign_alice.assignee_type = Some(Some("member".to_string()));
+ update_work_item_partial("demo", "AAA-0001", &assign_alice).expect("assign alice");
+
+ let connection = conn().expect("conn");
+ connection
+ .execute(
+ "INSERT INTO team_inbox_read_receipts
+ (viewer_member_id, source_kind, source_id, read_at)
+ VALUES (?1, 'work_item_assigned', 'w1', 42)",
+ ["member-alice"],
+ )
+ .expect("seed read receipt");
+ drop(connection);
+
+ let mut assign_bob = WorkItemPartialUpdate::default();
+ assign_bob.assignee = Some(Some("member-bob".to_string()));
+ update_work_item_partial("demo", "AAA-0001", &assign_bob).expect("assign bob");
+
+ let connection = conn().expect("conn");
+ let (assigned_human_id, receipt_count): (Option, i64) = connection
+ .query_row(
+ "SELECT w.assigned_human_id,
+ (SELECT COUNT(*) FROM team_inbox_read_receipts r
+ WHERE r.source_kind = 'work_item_assigned'
+ AND r.source_id = w.id)
+ FROM workitems w WHERE w.id = 'w1'",
+ [],
+ |row| Ok((row.get(0)?, row.get(1)?)),
+ )
+ .expect("assignment projection");
+ assert_eq!(assigned_human_id.as_deref(), Some("member-bob"));
+ assert_eq!(
+ receipt_count, 0,
+ "the old assignment episode must not stay read"
+ );
+}
+
+#[test]
+fn non_human_assignee_is_excluded_from_assigned_human_projection() {
+ let _sandbox = test_env::sandbox();
+ seed("demo", "p1");
+
+ let mut assign_agent = WorkItemPartialUpdate::default();
+ assign_agent.assignee = Some(Some("agent-1".to_string()));
+ assign_agent.assignee_type = Some(Some("agent".to_string()));
+ update_work_item_partial("demo", "AAA-0001", &assign_agent).expect("assign agent");
+
+ let connection = conn().expect("conn");
+ let assigned_human_id: Option = connection
+ .query_row(
+ "SELECT assigned_human_id FROM workitems WHERE id = 'w1'",
+ [],
+ |row| row.get(0),
+ )
+ .expect("assigned_human_id");
+ assert_eq!(assigned_human_id, None);
+}
+
#[test]
fn partial_nullable_fields_json_null_deserializes_as_explicit_clear() {
let updates: WorkItemPartialUpdate = serde_json::from_value(serde_json::json!({
diff --git a/src-tauri/crates/project-management/src/projects/io/work_items/history.rs b/src-tauri/crates/project-management/src/projects/io/work_items/history.rs
index 8f79925441..650499156a 100644
--- a/src-tauri/crates/project-management/src/projects/io/work_items/history.rs
+++ b/src-tauri/crates/project-management/src/projects/io/work_items/history.rs
@@ -3,7 +3,7 @@ use serde_json::Value as JsonValue;
use crate::projects::types::{
CommentEntry, WorkItemFrontmatter, WorkItemHistoryAction, WorkItemHistoryChange,
- WorkItemHistoryEvent,
+ WorkItemHistoryEvent, WorkItemMutationActor,
};
pub(super) fn ensure_created_event(frontmatter: &mut WorkItemFrontmatter, timestamp: &str) {
@@ -34,8 +34,8 @@ pub(super) fn append_deleted_event(frontmatter: &mut WorkItemFrontmatter, timest
id: history_event_id(frontmatter, WorkItemHistoryAction::Deleted, timestamp),
action: WorkItemHistoryAction::Deleted,
timestamp: timestamp.to_string(),
- actor_id: frontmatter.created_by.clone(),
- actor_name: frontmatter.created_by.clone(),
+ actor_id: None,
+ actor_name: None,
changes: Vec::new(),
summary: Some("Deleted item".to_string()),
});
@@ -46,8 +46,8 @@ pub(super) fn append_restored_event(frontmatter: &mut WorkItemFrontmatter, times
id: history_event_id(frontmatter, WorkItemHistoryAction::Restored, timestamp),
action: WorkItemHistoryAction::Restored,
timestamp: timestamp.to_string(),
- actor_id: frontmatter.created_by.clone(),
- actor_name: frontmatter.created_by.clone(),
+ actor_id: None,
+ actor_name: None,
changes: Vec::new(),
summary: Some("Restored item".to_string()),
});
@@ -58,6 +58,7 @@ pub(super) fn append_mutation_event(
frontmatter: &mut WorkItemFrontmatter,
body: &str,
timestamp: &str,
+ actor: Option<&WorkItemMutationActor>,
) {
let mut changes = before.diff(frontmatter, body);
if changes.is_empty() {
@@ -91,12 +92,21 @@ pub(super) fn append_mutation_event(
| WorkItemHistoryAction::Restored => None,
};
+ let actor_id = actor
+ .map(|value| value.id.trim())
+ .filter(|value| !value.is_empty())
+ .map(str::to_string);
+ let actor_name = actor
+ .map(|value| value.name.trim())
+ .filter(|value| !value.is_empty())
+ .map(str::to_string);
+
frontmatter.history.push(WorkItemHistoryEvent {
id: history_event_id(frontmatter, action.clone(), timestamp),
action,
timestamp: timestamp.to_string(),
- actor_id: frontmatter.created_by.clone(),
- actor_name: frontmatter.created_by.clone(),
+ actor_id,
+ actor_name,
changes,
summary,
});
diff --git a/src-tauri/crates/project-management/src/projects/types/work_items.rs b/src-tauri/crates/project-management/src/projects/types/work_items.rs
index edff838789..bad4105444 100644
--- a/src-tauri/crates/project-management/src/projects/types/work_items.rs
+++ b/src-tauri/crates/project-management/src/projects/types/work_items.rs
@@ -383,6 +383,13 @@ where
/// All fields are optional — only provided fields will be updated.
/// This enables atomic read-modify-write in Rust, eliminating
/// multiple IPC calls and JS-side type conversions.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkItemMutationActor {
+ pub id: String,
+ pub name: String,
+}
+
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkItemPartialUpdate {
@@ -469,6 +476,10 @@ pub struct WorkItemPartialUpdate {
pub close_out: Option>,
#[serde(skip_serializing_if = "Option::is_none")]
pub work_products: Option>,
+ /// Request metadata used to attribute the generated history event.
+ /// This is never copied into Work Item frontmatter as mutable item data.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub actor: Option,
}
// ============================================
diff --git a/src/api/http/project/types/workItems.ts b/src/api/http/project/types/workItems.ts
index 34cd8b987a..4000794494 100644
--- a/src/api/http/project/types/workItems.ts
+++ b/src/api/http/project/types/workItems.ts
@@ -223,6 +223,13 @@ export interface WorkItemPartialUpdate {
executionLock?: WorkItemExecutionLock | null;
closeOut?: WorkItemCloseOut | null;
workProducts?: WorkItemWorkProduct[];
+ /** Identity of the user initiating this mutation; used only for history attribution. */
+ actor?: WorkItemMutationActor;
+}
+
+export interface WorkItemMutationActor {
+ id: string;
+ name: string;
}
export interface ResolvedPerson {
diff --git a/src/components/ComposerShell/index.tsx b/src/components/ComposerShell/index.tsx
index 5b7a954961..6d63274e73 100644
--- a/src/components/ComposerShell/index.tsx
+++ b/src/components/ComposerShell/index.tsx
@@ -11,6 +11,7 @@
* • "default" — session creator, standalone (bg-chat-input)
* • "embedded" — chat panel embedded in conversation (bg-chat-input)
* • "pill" — compact single-row capsule (rounded-full, same padding)
+ * • "comment" — compact avatar-adjacent comment input
* • "edit" — queued-message edit box (label strip + inner editor card)
* • "historyEdit" — sent-message edit box (single layer, same token as normal input)
*/
@@ -22,6 +23,7 @@ export type ComposerShellVariant =
| "default"
| "embedded"
| "pill"
+ | "comment"
| "edit"
| "historyEdit";
@@ -45,6 +47,7 @@ const VARIANT_CLASSES: Record = {
default: `${INPUT_AREA.borderRadiusClass} px-1.5 pt-2.5 pb-1.5 gap-2`,
embedded: `${INPUT_AREA.borderRadiusClass} px-1.5 pt-2.5 pb-1.5 gap-2`,
pill: "rounded-full p-1.5 gap-2",
+ comment: `${INPUT_AREA.borderRadiusClass} px-1.5 py-1.5 gap-1.5`,
// `edit` is the OUTER label strip — the inner editor card is rendered as
// a separately-styled child (see `InputArea`). The strip itself is just
// a padded container that hosts the label row + the inner card.
@@ -56,6 +59,7 @@ const VARIANT_BG_CLASS: Record = {
default: INPUT_AREA.backgroundDefaultClass,
embedded: INPUT_AREA.backgroundChatPanelClass,
pill: INPUT_AREA.backgroundChatPanelClass,
+ comment: INPUT_AREA.backgroundChatPanelClass,
// The outer edit strip sits on `bg-fill-2` so it reads as a distinct card
// that wraps the header row + inner editor card (`bg-fill-1`).
edit: "bg-fill-2",
@@ -69,6 +73,7 @@ const VARIANT_INTERACTION_CLASSES: Record = {
default: INPUT_AREA.shellInteractionClasses,
embedded: INPUT_AREA.shellInteractionClasses,
pill: INPUT_AREA.shellInteractionClasses,
+ comment: INPUT_AREA.shellInteractionClasses,
edit: INPUT_AREA.borderClass,
historyEdit: INPUT_AREA.shellEditInteractionClasses,
};
@@ -92,7 +97,7 @@ const ComposerShell = forwardRef(
return (
= ({
}
return [...people.values()];
}, [workItems]);
- const { memberIds: currentUserMemberIds } =
+ const { currentUser, memberIds: currentUserMemberIds } =
useCurrentUserMemberIds(workItemPeople);
const pinnedKanbanColumnIds = useMemo(
() => [...currentUserMemberIds].map((memberId) => `person:${memberId}`),
@@ -473,15 +474,7 @@ export const ProjectPanelView: React.FC
= ({
const shortId = getWorkItemShortId(workItemId);
if (!shortId) return;
- const payload = {} as Parameters<
- typeof projectApi.updateWorkItemPartial
- >[2];
- if (updates.name !== undefined) payload.title = updates.name;
- if (updates.spec !== undefined) payload.body = updates.spec;
- if (updates.workItemStatus !== undefined) {
- payload.status = updates.workItemStatus;
- }
- if (updates.priority !== undefined) payload.priority = updates.priority;
+ const payload = toWorkItemPartialUpdate(updates, currentUser);
if (Object.keys(payload).length === 0) return;
const updated = await projectApi.updateWorkItemPartial(
@@ -496,7 +489,7 @@ export const ProjectPanelView: React.FC = ({
)
);
},
- [getWorkItemShortId, projectSlug]
+ [currentUser, getWorkItemShortId, projectSlug, setWorkItems]
);
const handleAddKanbanTask = useCallback(
diff --git a/src/engines/ChatPanel/panels/WorkItemPanelView.tsx b/src/engines/ChatPanel/panels/WorkItemPanelView.tsx
index 894a1594bc..ed9612a3da 100644
--- a/src/engines/ChatPanel/panels/WorkItemPanelView.tsx
+++ b/src/engines/ChatPanel/panels/WorkItemPanelView.tsx
@@ -1,6 +1,6 @@
import { emit } from "@tauri-apps/api/event";
import { useAtomValue, useSetAtom } from "jotai";
-import { ExternalLink, Info, ListChecks, Trash2, X } from "lucide-react";
+import { ExternalLink, ListChecks, Trash2, X } from "lucide-react";
import React, { useCallback, useEffect, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
@@ -18,17 +18,12 @@ import { HEADER_ICON_SIZE } from "@src/config/workstation/tokens";
import { usePublishChatPanelHeader } from "@src/engines/ChatPanel/header";
import { createLogger } from "@src/hooks/logger";
import { useProjectDataChanged } from "@src/hooks/project";
-import { useResizeHandle } from "@src/hooks/ui/useResizeHandle";
-import {
- WorkItemContent,
- WorkItemProperties,
-} from "@src/modules/ProjectManager/WorkItems/components";
+import { useCurrentUserMemberIds } from "@src/hooks/project/useCurrentUserMemberId";
+import { WorkItemThreadSurface } from "@src/modules/ProjectManager/WorkItems/components";
import { WorkItemDetailHeaderBreadcrumb } from "@src/modules/ProjectManager/WorkItems/components/WorkItemDetail/WorkItemDetailHeader";
import { useWorkItemOrchestrator } from "@src/modules/ProjectManager/WorkItems/hooks";
import { toWorkItemPartialUpdate } from "@src/modules/ProjectManager/WorkItems/workItemPartialUpdate";
-import { PropertiesRailFrame } from "@src/modules/ProjectManager/shared";
import { WorkstationToolbarTooltip } from "@src/modules/WorkStation/shared";
-import { VerticalResizeHandle } from "@src/scaffold/Resize";
import { closeWorkItemChatPanelTabAtom } from "@src/store/chatPanel/chatPanelTabsAtom";
import { activeSessionIdAtom } from "@src/store/session";
import {
@@ -44,9 +39,6 @@ import { usePendingWorkItemAction } from "./usePendingWorkItemAction";
const logger = createLogger("WorkItemPanelView");
const saveNoPendingWorkItemChanges = async (): Promise => undefined;
-const WORK_ITEM_INFO_PANEL_DEFAULT_WIDTH = 240;
-const WORK_ITEM_INFO_PANEL_MIN_WIDTH = 200;
-const WORK_ITEM_INFO_PANEL_MAX_WIDTH = 280;
interface WorkItemPanelViewProps {
selectedWorkItem: ChatPanelSelectedWorkItem;
@@ -118,21 +110,23 @@ export const WorkItemPanelView: React.FC = ({
const [floatingSessionId, setFloatingSessionId] = useState(
null
);
- const [propertiesOpen, setPropertiesOpen] = useState(true);
- const [infoPanelWidth, setInfoPanelWidth] = useState(
- WORK_ITEM_INFO_PANEL_DEFAULT_WIDTH
- );
const [projectSyncAdapter, setProjectSyncAdapter] = useState<{
projectSlug: string;
adapterId: string | null;
} | null>(null);
- const { handleMouseDown: handleInfoPanelResize, isResizing } =
- useResizeHandle(infoPanelWidth, setInfoPanelWidth, {
- direction: "horizontal",
- minSize: WORK_ITEM_INFO_PANEL_MIN_WIDTH,
- maxSize: WORK_ITEM_INFO_PANEL_MAX_WIDTH,
- isReversed: true,
- });
+ const workItemMembers = useMemo(
+ () => [
+ ...(selectedWorkItem.sourceProject?.project.members ?? []),
+ ...(selectedWorkItem.workItem.assignee
+ ? [selectedWorkItem.workItem.assignee]
+ : []),
+ ],
+ [
+ selectedWorkItem.sourceProject?.project.members,
+ selectedWorkItem.workItem.assignee,
+ ]
+ );
+ const { currentUser } = useCurrentUserMemberIds(workItemMembers);
useEffect(() => {
const projectSlug = selectedWorkItem.projectSlug;
@@ -168,7 +162,7 @@ export const WorkItemPanelView: React.FC = ({
}
try {
- const payload = toWorkItemPartialUpdate(updates);
+ const payload = toWorkItemPartialUpdate(updates, currentUser);
if (Object.keys(payload).length === 0) return;
if (selectedWorkItem.projectSlug) {
@@ -210,7 +204,7 @@ export const WorkItemPanelView: React.FC = ({
logger.error("Failed to update chat panel work item", error);
}
},
- [onUpdateWorkItem, selectedWorkItem, setSelectedWorkItem]
+ [currentUser, onUpdateWorkItem, selectedWorkItem, setSelectedWorkItem]
);
const refreshSelectedWorkItem = useCallback(async () => {
@@ -394,11 +388,11 @@ export const WorkItemPanelView: React.FC = ({
}, [closeWorkItemTab, selectedWorkItem, t]);
const headerActions = useMemo(
- () => (
-
- {selectedWorkItem.projectSlug &&
- projectSyncAdapterId !== undefined &&
- !isGitHubSyncedProject ? (
+ () =>
+ selectedWorkItem.projectSlug &&
+ projectSyncAdapterId !== undefined &&
+ !isGitHubSyncedProject ? (
+
@@ -413,40 +407,12 @@ export const WorkItemPanelView: React.FC = ({
icon={
- ) : null}
-
- setPropertiesOpen((current) => !current)}
- aria-label={
- propertiesOpen
- ? t("projects:workItems.hideProperties")
- : t("projects:workItems.showProperties")
- }
- aria-pressed={propertiesOpen}
- data-testid="chat-panel-work-item-properties-toggle"
- icon={
-
- ),
+
= ({
content: { content: headerContent, trailing: headerActions },
});
- const propertiesContent = (
-
-
-
-
- {propertiesOpen ? (
- <>
-
-
- {propertiesContent}
-
-
- ) : null}
+
+
{floatingSessionId && (
{
- const payload = await getCloudCapabilitiesRaw(accessToken);
+ const payload = await runCloudRequestWithTimeout(
+ (signal) => getCloudCapabilitiesRaw(accessToken, signal),
+ CLOUD_CAPABILITIES_TIMEOUT_MS
+ );
const parsed = CloudCapabilitiesWireSchema.safeParse(payload);
if (payload === null || !parsed.success) {
// 404 (pre-0005) and transient failures are indistinguishable here, so
diff --git a/src/features/Org2Cloud/org2CloudClient.ts b/src/features/Org2Cloud/org2CloudClient.ts
index eda9218949..8940b02cfa 100644
--- a/src/features/Org2Cloud/org2CloudClient.ts
+++ b/src/features/Org2Cloud/org2CloudClient.ts
@@ -98,7 +98,8 @@ async function callRpc(
functionName: string,
accessToken?: string,
body?: Record
,
- endpoint: CloudRpcEndpoint = getCloudEndpoint()
+ endpoint: CloudRpcEndpoint = getCloudEndpoint(),
+ signal?: AbortSignal
): Promise {
try {
const response = await fetchWithTransportRetry(
@@ -107,6 +108,7 @@ async function callRpc(
method: "POST",
headers: rpcHeaders(accessToken, endpoint),
body: JSON.stringify(body ?? {}),
+ signal,
}
);
if (!response.ok) {
@@ -132,9 +134,16 @@ export async function schemaVersion(): Promise {
* transport failure. Interpretation/caching live in `org2CloudCapabilities`.
*/
export async function getCloudCapabilitiesRaw(
- accessToken: string
+ accessToken: string,
+ signal?: AbortSignal
): Promise {
- return callRpc("get_cloud_capabilities", accessToken);
+ return callRpc(
+ "get_cloud_capabilities",
+ accessToken,
+ undefined,
+ getCloudEndpoint(),
+ signal
+ );
}
/**
diff --git a/src/features/Org2Cloud/teamInboxMentionsClient.test.ts b/src/features/Org2Cloud/teamInboxMentionsClient.test.ts
index 680cdc480f..e60b640608 100644
--- a/src/features/Org2Cloud/teamInboxMentionsClient.test.ts
+++ b/src/features/Org2Cloud/teamInboxMentionsClient.test.ts
@@ -238,6 +238,25 @@ describe("listTeamInboxMentions", () => {
expect(error).toMatchObject({ code: "ORG2_MEMBER_REQUIRED", status: 403 });
expect(fetchMock).toHaveBeenCalledTimes(1);
});
+
+ it("cancels an in-flight RPC when its owning Inbox scope is disposed", async () => {
+ fetchMock.mockImplementationOnce(
+ () => new Promise(() => undefined)
+ );
+ const controller = new AbortController();
+
+ const request = listTeamInboxMentions(
+ "jwt-viewer",
+ "org-1",
+ null,
+ 25,
+ controller.signal
+ );
+ controller.abort();
+
+ await expect(request).rejects.toMatchObject({ name: "AbortError" });
+ expect((lastCall().init.signal as AbortSignal).aborted).toBe(true);
+ });
});
describe("Team Inbox read receipts", () => {
diff --git a/src/features/Org2Cloud/teamInboxMentionsClient.ts b/src/features/Org2Cloud/teamInboxMentionsClient.ts
index 9b4af2ee56..6a87fa44ce 100644
--- a/src/features/Org2Cloud/teamInboxMentionsClient.ts
+++ b/src/features/Org2Cloud/teamInboxMentionsClient.ts
@@ -3,12 +3,16 @@ import { z } from "zod/v4";
import { ORG2_CLOUD_POSTGREST_SCHEMA, getCloudEndpoint } from "./config";
import { getCloudCapabilities } from "./org2CloudCapabilities";
import { Org2CloudCommentError } from "./org2CloudCommentsClient";
-import { fetchWithTransportRetry } from "./org2CloudFetchRetry";
+import {
+ fetchWithTransportRetry,
+ runCloudRequestWithTimeout,
+} from "./org2CloudFetchRetry";
const TEAM_INBOX_MENTIONS_RPC = "cloud_list_team_inbox_mentions";
const SET_TEAM_INBOX_MENTION_READ_RPC = "cloud_set_team_inbox_mention_read";
const MARK_ALL_TEAM_INBOX_MENTIONS_READ_RPC =
"cloud_mark_all_team_inbox_mentions_read";
+const TEAM_INBOX_REQUEST_TIMEOUT_MS = 15_000;
const TeamInboxMentionRequestSchema = z.object({
orgId: z.string().min(1),
@@ -74,39 +78,47 @@ export interface TeamInboxReadMutation {
async function callTeamInboxRpc(
functionName: string,
accessToken: string,
- body: Record
+ body: Record,
+ sourceSignal?: AbortSignal
): Promise {
const endpoint = getCloudEndpoint();
- const response = await fetchWithTransportRetry(
- `${endpoint.supabaseUrl}/rest/v1/rpc/${functionName}`,
- {
- method: "POST",
- headers: {
- apikey: endpoint.anonKey,
- authorization: `Bearer ${accessToken}`,
- "content-type": "application/json",
- "content-profile": ORG2_CLOUD_POSTGREST_SCHEMA,
- },
- body: JSON.stringify(body),
- }
+ return runCloudRequestWithTimeout(
+ async (signal) => {
+ const response = await fetchWithTransportRetry(
+ `${endpoint.supabaseUrl}/rest/v1/rpc/${functionName}`,
+ {
+ method: "POST",
+ headers: {
+ apikey: endpoint.anonKey,
+ authorization: `Bearer ${accessToken}`,
+ "content-type": "application/json",
+ "content-profile": ORG2_CLOUD_POSTGREST_SCHEMA,
+ },
+ body: JSON.stringify(body),
+ signal,
+ }
+ );
+
+ const text = await response.text();
+ let payload: unknown = null;
+ try {
+ payload = text ? JSON.parse(text) : null;
+ } catch {
+ payload = null;
+ }
+
+ if (!response.ok) {
+ const message =
+ payload && typeof payload === "object" && "message" in payload
+ ? String((payload as { message: unknown }).message)
+ : `org2_cloud rpc ${functionName} failed with ${response.status}`;
+ throw new Org2CloudCommentError(message, response.status);
+ }
+ return payload;
+ },
+ TEAM_INBOX_REQUEST_TIMEOUT_MS,
+ sourceSignal
);
-
- const text = await response.text();
- let payload: unknown = null;
- try {
- payload = text ? JSON.parse(text) : null;
- } catch {
- payload = null;
- }
-
- if (!response.ok) {
- const message =
- payload && typeof payload === "object" && "message" in payload
- ? String((payload as { message: unknown }).message)
- : `org2_cloud rpc ${functionName} failed with ${response.status}`;
- throw new Org2CloudCommentError(message, response.status);
- }
- return payload;
}
/**
@@ -120,14 +132,20 @@ export async function listTeamInboxMentions(
accessToken: string,
orgId: string,
cursor: string | null,
- limit: number
+ limit: number,
+ signal?: AbortSignal
): Promise {
const input = TeamInboxMentionRequestSchema.parse({ orgId, cursor, limit });
- const payload = await callTeamInboxRpc(TEAM_INBOX_MENTIONS_RPC, accessToken, {
- p_org_id: input.orgId,
- p_cursor: input.cursor,
- p_limit: input.limit,
- });
+ const payload = await callTeamInboxRpc(
+ TEAM_INBOX_MENTIONS_RPC,
+ accessToken,
+ {
+ p_org_id: input.orgId,
+ p_cursor: input.cursor,
+ p_limit: input.limit,
+ },
+ signal
+ );
return TeamInboxMentionsPageSchema.parse(payload);
}
@@ -139,13 +157,14 @@ export async function listTeamInboxMentions(
export async function listInitialTeamInboxMentions(
accessToken: string,
orgId: string,
- limit = 50
+ limit = 50,
+ signal?: AbortSignal
): Promise {
const capabilities = await getCloudCapabilities(accessToken);
if (!capabilities.teamInboxMentions) {
return EMPTY_TEAM_INBOX_MENTIONS_PAGE;
}
- return listTeamInboxMentions(accessToken, orgId, null, limit);
+ return listTeamInboxMentions(accessToken, orgId, null, limit, signal);
}
/** Persists one viewer-scoped mention receipt. The viewer comes from JWT. */
@@ -153,7 +172,8 @@ export async function setTeamInboxMentionRead(
accessToken: string,
orgId: string,
commentId: string,
- read: boolean
+ read: boolean,
+ signal?: AbortSignal
): Promise {
const payload = await callTeamInboxRpc(
SET_TEAM_INBOX_MENTION_READ_RPC,
@@ -162,7 +182,8 @@ export async function setTeamInboxMentionRead(
p_org_id: z.string().min(1).parse(orgId),
p_comment_id: z.string().min(1).parse(commentId),
p_read: read,
- }
+ },
+ signal
);
return TeamInboxReadMutationSchema.parse(payload);
}
@@ -170,12 +191,14 @@ export async function setTeamInboxMentionRead(
/** Marks every currently visible mention read, including unloaded pages. */
export async function markAllTeamInboxMentionsRead(
accessToken: string,
- orgId: string
+ orgId: string,
+ signal?: AbortSignal
): Promise {
const payload = await callTeamInboxRpc(
MARK_ALL_TEAM_INBOX_MENTIONS_READ_RPC,
accessToken,
- { p_org_id: z.string().min(1).parse(orgId) }
+ { p_org_id: z.string().min(1).parse(orgId) },
+ signal
);
return TeamInboxReadMutationSchema.parse(payload);
}
diff --git a/src/hooks/project/useCurrentUserMemberId.test.ts b/src/hooks/project/useCurrentUserMemberId.test.ts
new file mode 100644
index 0000000000..c51ecfc5d5
--- /dev/null
+++ b/src/hooks/project/useCurrentUserMemberId.test.ts
@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+
+import type { IUserInfo } from "@src/types/core/user";
+
+import {
+ findMemberIdsByUser,
+ resolveCurrentUserIdentity,
+} from "./useCurrentUserMemberId";
+
+function user(overrides: Partial = {}): IUserInfo {
+ return {
+ uuid: "",
+ name: "",
+ authing_id: "",
+ profile: "",
+ picture: "",
+ profile_image_url: "",
+ openai_api_key: "",
+ deepseek_api_key: "",
+ git_user_name: "",
+ git_user_email: "",
+ github_infos: [],
+ gitlab_infos: [],
+ ...overrides,
+ };
+}
+
+describe("current Work Item identity", () => {
+ it("uses the project member identity for a consistent name and avatar", () => {
+ const members = [
+ {
+ id: "user-ea821852",
+ name: "hanafish",
+ email: "hanafish@example.com",
+ avatar: "https://example.com/hanafish.png",
+ color: "#1677ff",
+ },
+ ];
+ const account = user({
+ uuid: "user-ea821852",
+ name: "Account fallback",
+ git_user_email: "hanafish@example.com",
+ });
+ const memberIds = findMemberIdsByUser(members, account);
+
+ expect(
+ resolveCurrentUserIdentity(members, memberIds, account, null)
+ ).toEqual({
+ id: "user-ea821852",
+ name: "hanafish",
+ email: "hanafish@example.com",
+ avatar: "https://example.com/hanafish.png",
+ color: "#1677ff",
+ });
+ });
+
+ it("falls back to the signed-in profile instead of the generic You label", () => {
+ const account = user({
+ uuid: "user-ea821852",
+ name: "hanafish",
+ profile_image_url: "https://example.com/hanafish.png",
+ });
+
+ expect(
+ resolveCurrentUserIdentity([], new Set(), account, null)
+ ).toMatchObject({
+ id: "user-ea821852",
+ name: "hanafish",
+ avatar: "https://example.com/hanafish.png",
+ });
+ });
+
+ it("enriches an opaque member record with the signed-in profile", () => {
+ const account = user({
+ uuid: "user-ea821852",
+ name: "Yuki",
+ profile_image_url: "https://example.com/yuki.png",
+ });
+
+ expect(
+ resolveCurrentUserIdentity(
+ [{ id: "user-ea821852", name: "user-ea821852" }],
+ new Set(),
+ account,
+ null
+ )
+ ).toMatchObject({
+ id: "user-ea821852",
+ name: "Yuki",
+ avatar: "https://example.com/yuki.png",
+ });
+ });
+
+ it("returns no actor when neither account nor git identity is trustworthy", () => {
+ expect(resolveCurrentUserIdentity([], new Set(), user(), null)).toBeNull();
+ });
+
+ it("does not merge different people who share an email local-part", () => {
+ const members = [
+ {
+ id: "member-company-alice",
+ name: "Alice Company",
+ email: "alice@company.example",
+ },
+ {
+ id: "member-personal-alice",
+ name: "Alice Personal",
+ email: "alice@personal.example",
+ },
+ ];
+
+ expect(
+ findMemberIdsByUser(
+ members,
+ user({ git_user_email: "alice@company.example" })
+ )
+ ).toEqual(new Set(["member-company-alice"]));
+ });
+
+ it("does not infer a member id from a non-unique display name", () => {
+ const members = [
+ {
+ id: "member-1",
+ name: "Alex",
+ email: "alex-one@example.com",
+ },
+ {
+ id: "member-2",
+ name: "Alex",
+ email: "alex-two@example.com",
+ },
+ ];
+
+ expect(findMemberIdsByUser(members, user({ name: "Alex" }))).toEqual(
+ new Set()
+ );
+ });
+
+ it("matches exact account ids and verified linked emails", () => {
+ const members = [
+ {
+ id: "account-1",
+ name: "Account member",
+ },
+ {
+ id: "member-linked",
+ name: "Linked member",
+ linked_emails: [{ email: "linked@example.com" }],
+ },
+ ];
+
+ expect(
+ findMemberIdsByUser(
+ members,
+ user({
+ uuid: "account-1",
+ git_user_email: "linked@example.com",
+ })
+ )
+ ).toEqual(new Set(["account-1", "member-linked"]));
+ });
+});
diff --git a/src/hooks/project/useCurrentUserMemberId.ts b/src/hooks/project/useCurrentUserMemberId.ts
index e4cfe9c9b5..f898e2a008 100644
--- a/src/hooks/project/useCurrentUserMemberId.ts
+++ b/src/hooks/project/useCurrentUserMemberId.ts
@@ -3,15 +3,16 @@
*
* Resolves the current user's project member ID(s) by matching against
* all known user identities:
- * - Local git config user.email (from Tauri command — most reliable)
- * - Local git config user.name (fallback)
+ * - Stable account/member IDs
+ * - Local git config user.email (from Tauri command)
* - userAtom.git_user_email (if populated)
- * - github_infos / gitlab_infos usernames (matched against email prefix)
+ * - Exact GitHub/GitLab usernames when a member carries that provider field
*
* A single person often has multiple member entries (from git shortlog)
* because they commit with different emails. This hook returns ALL
- * matching member IDs so assignment notifications work regardless of
- * which member entry was used.
+ * exact matching member IDs so assignment notifications work regardless of
+ * which verified member entry was used. Display names and email local-parts
+ * are deliberately excluded because they are not unique identities.
*/
import { invoke } from "@tauri-apps/api/core";
import { useAtomValue } from "jotai";
@@ -19,13 +20,14 @@ import { useEffect, useMemo, useRef, useState } from "react";
import type { MemberEntry } from "@src/api/http/project";
import { userAtom } from "@src/store/user/userAtom";
+import type { Person } from "@src/types/core/shared";
import type { IUserInfo } from "@src/types/core/user";
// ============================================
// Git identity from Tauri
// ============================================
-interface GitUserIdentity {
+export interface GitUserIdentity {
email: string | null;
name: string | null;
/** GitHub username from gh CLI config (~/.config/gh/hosts.yml) */
@@ -72,7 +74,80 @@ export function resetGitIdentityCache() {
interface UserIdentities {
emails: string[];
- userName: string;
+ accountIds: string[];
+ usernames: string[];
+}
+
+export type MemberIdentity = Pick<
+ MemberEntry,
+ "id" | "name" | "email" | "avatar" | "github_username" | "linked_emails"
+> & {
+ color?: string;
+};
+
+export function resolveCurrentUserIdentity(
+ members: readonly MemberIdentity[],
+ memberIds: ReadonlySet,
+ user: IUserInfo,
+ gitIdentity: GitUserIdentity | null
+): Person | null {
+ const accountIds = new Set(
+ [user.uuid, user.authing_id].map((value) => value.trim()).filter(Boolean)
+ );
+ const currentMember = members.find(
+ (member) => memberIds.has(member.id) || accountIds.has(member.id)
+ );
+ if (currentMember) {
+ const memberName = currentMember.name.trim();
+ const accountName = (
+ user.name ||
+ gitIdentity?.name ||
+ user.git_user_name ||
+ ""
+ ).trim();
+ const memberNameIsOpaque =
+ !memberName ||
+ memberName === currentMember.id ||
+ /^user-[a-z0-9]+$/i.test(memberName);
+
+ return {
+ id: currentMember.id,
+ name:
+ memberNameIsOpaque && accountName
+ ? accountName
+ : memberName || accountName,
+ email: currentMember.email,
+ avatar:
+ currentMember.avatar ||
+ user.profile_image_url ||
+ user.picture ||
+ undefined,
+ color: currentMember.color,
+ };
+ }
+
+ const name = (
+ user.name ||
+ gitIdentity?.name ||
+ user.git_user_name ||
+ ""
+ ).trim();
+ const id = (
+ user.uuid ||
+ user.authing_id ||
+ gitIdentity?.email ||
+ user.git_user_email ||
+ name
+ ).trim();
+ if (!id || !name) return null;
+
+ return {
+ id,
+ name,
+ email: gitIdentity?.email || user.git_user_email || undefined,
+ avatar: user.profile_image_url || user.picture || undefined,
+ color: "#52c41a",
+ };
}
/**
@@ -83,42 +158,46 @@ function collectIdentities(
gitIdentity: GitUserIdentity | null
): UserIdentities {
const emailSet = new Set();
+ const usernameSet = new Set();
+ const accountIdSet = new Set();
+
+ for (const accountId of [user.uuid, user.authing_id]) {
+ const normalized = accountId.trim();
+ if (normalized) accountIdSet.add(normalized);
+ }
- // 1. GitHub username from gh CLI (most reliable for matching)
+ // GitHub username from gh CLI.
if (gitIdentity?.github_username) {
- emailSet.add(gitIdentity.github_username.toLowerCase().trim());
+ usernameSet.add(gitIdentity.github_username.toLowerCase().trim());
}
- // 2. Local git config email (matches git shortlog entries)
+ // Exact email identities.
if (gitIdentity?.email) {
emailSet.add(gitIdentity.email.toLowerCase().trim());
}
- // 3. userAtom git_user_email (if populated by backend)
if (user.git_user_email) {
emailSet.add(user.git_user_email.toLowerCase().trim());
}
- // 4. GitHub usernames from linked accounts
+ // Exact provider usernames.
for (const gh of user.github_infos ?? []) {
if (gh.user_name) {
- emailSet.add(gh.user_name.toLowerCase().trim());
+ usernameSet.add(gh.user_name.toLowerCase().trim());
}
}
- // 5. GitLab usernames
for (const gl of user.gitlab_infos ?? []) {
if (gl.user_name) {
- emailSet.add(gl.user_name.toLowerCase().trim());
+ usernameSet.add(gl.user_name.toLowerCase().trim());
}
}
- // Best user name: prefer git config, then userAtom
- const userName = (gitIdentity?.name || user.git_user_name || "")
- .toLowerCase()
- .trim();
-
- return { emails: [...emailSet], userName };
+ return {
+ emails: [...emailSet],
+ accountIds: [...accountIdSet],
+ usernames: [...usernameSet],
+ };
}
// ============================================
@@ -129,30 +208,22 @@ function collectIdentities(
* Check if a member entry matches any of the user's known identities.
*/
function memberMatchesUser(
- member: MemberEntry,
+ member: MemberIdentity,
identities: UserIdentities
): boolean {
const memberEmail = (member.email || "").toLowerCase().trim();
- const memberName = (member.name || "").toLowerCase().trim();
-
- for (const email of identities.emails) {
- // Direct email match
- if (memberEmail === email) return true;
+ const memberUsername = (member.github_username || "").toLowerCase().trim();
- // Email prefix match (e.g. github username "alice" matches "alice@example.com")
- if (memberEmail && memberEmail.split("@")[0] === email) return true;
-
- // Reverse: member email prefix matches user email
- if (
- email.includes("@") &&
- email.split("@")[0] === memberEmail.split("@")[0]
- ) {
- return true;
- }
+ if (identities.accountIds.includes(member.id)) return true;
+ if (memberEmail && identities.emails.includes(memberEmail)) return true;
+ if (memberUsername && identities.usernames.includes(memberUsername)) {
+ return true;
}
- // Name-based fallback
- if (identities.userName && memberName === identities.userName) return true;
+ for (const linked of member.linked_emails ?? []) {
+ const email = linked.email.toLowerCase().trim();
+ if (email && identities.emails.includes(email)) return true;
+ }
return false;
}
@@ -161,9 +232,9 @@ function memberMatchesUser(
* Find a member entry by exact email match.
*/
export function findMemberByEmail(
- members: MemberEntry[],
+ members: readonly MemberIdentity[],
email: string
-): MemberEntry | undefined {
+): MemberIdentity | undefined {
const normalized = email.toLowerCase().trim();
return members.find(
(member) => (member.email || "").toLowerCase().trim() === normalized
@@ -182,7 +253,7 @@ export function findMemberByEmail(
* For the async version that fetches git config, use the hook.
*/
export function findMemberIdsByUser(
- members: MemberEntry[],
+ members: readonly MemberIdentity[],
user: IUserInfo,
gitIdentity?: GitUserIdentity | null
): Set {
@@ -207,6 +278,8 @@ interface UseCurrentUserMemberIdsReturn {
memberIds: Set;
/** Current user's git email (primary) */
gitEmail: string;
+ /** Display identity used by Work Item comments and mutation history. */
+ currentUser: Person | null;
}
/**
@@ -214,7 +287,7 @@ interface UseCurrentUserMemberIdsReturn {
* Fetches git identity from local config on mount.
*/
export function useCurrentUserMemberIds(
- members: MemberEntry[]
+ members: readonly MemberIdentity[]
): UseCurrentUserMemberIdsReturn {
const user = useAtomValue(userAtom);
const [gitIdentity, setGitIdentity] = useState(
@@ -244,6 +317,10 @@ export function useCurrentUserMemberIds(
);
const gitEmail = gitIdentity?.email || user.git_user_email || "";
+ const currentUser = useMemo(
+ () => resolveCurrentUserIdentity(members, memberIds, user, gitIdentity),
+ [gitIdentity, memberIds, members, user]
+ );
- return { memberIds, gitEmail };
+ return { memberIds, gitEmail, currentUser };
}
diff --git a/src/i18n/locales/en/common.json b/src/i18n/locales/en/common.json
index 9f7edd9199..648866578c 100644
--- a/src/i18n/locales/en/common.json
+++ b/src/i18n/locales/en/common.json
@@ -2466,7 +2466,8 @@
"unread": "Unread"
},
"row": {
- "assignedSummary": "{{status}} · {{priority}}"
+ "assignedSummary": "{{status}} · {{priority}}",
+ "ariaLabel": "{{title}}, {{status}}"
},
"search": {
"placeholder": "Search inbox",
@@ -2500,15 +2501,24 @@
"errors": {
"loadTitle": "Unable to load Team Inbox",
"load": "Unable to load Team Inbox",
+ "loadMore": "Unable to load more Team Inbox items. Try again.",
"refresh": "Unable to refresh Team Inbox",
"markRead": "Unable to mark this item as read. Try again.",
"markUnread": "Unable to mark this item as unread. Try again.",
- "markAllRead": "Unable to mark all items as read. Try again."
+ "markAllRead": "Unable to mark all items as read. Try again.",
+ "identity": "Your account could not be matched to a project member. Check your project profile email.",
+ "partialLoad": "Some Team Inbox sources could not be refreshed. Available items are still shown.",
+ "workItemContext": "Some project context is unavailable. The work item remains usable.",
+ "workItemLoad": "Unable to load this work item. Try again.",
+ "workItemUpdate": "Unable to save the latest work item change. Try again."
},
"detail": {
"assignedSubtitle": "Assigned work item",
+ "standaloneProject": "Standalone",
"mentionSubtitle": "Mentioned in a comment",
- "mentionedYou": "mentioned you"
+ "mentionedYou": "mentioned you",
+ "threadComments_one": "{{count}} comment in this thread",
+ "threadComments_other": "{{count}} comments in this thread"
},
"actions": {
"markRead": "Mark as read",
diff --git a/src/i18n/locales/zh/common.json b/src/i18n/locales/zh/common.json
index a3b70973f6..cc89bf0e53 100644
--- a/src/i18n/locales/zh/common.json
+++ b/src/i18n/locales/zh/common.json
@@ -2346,7 +2346,8 @@
"unread": "未读"
},
"row": {
- "assignedSummary": "{{status}} · {{priority}}"
+ "assignedSummary": "{{status}} · {{priority}}",
+ "ariaLabel": "{{title}}，{{status}}"
},
"search": {
"placeholder": "搜索收件箱",
@@ -2380,15 +2381,23 @@
"errors": {
"loadTitle": "无法加载团队收件箱",
"load": "无法加载团队收件箱",
+ "loadMore": "加载更多团队收件箱事项失败，请重试。",
"refresh": "无法刷新团队收件箱",
"markRead": "标记已读失败，请重试。",
"markUnread": "标记未读失败，请重试。",
- "markAllRead": "全部标记已读失败，请重试。"
+ "markAllRead": "全部标记已读失败，请重试。",
+ "identity": "当前账户无法匹配到项目成员，请检查项目个人资料中的邮箱。",
+ "partialLoad": "部分团队收件箱来源刷新失败，当前可用事项仍会保留显示。",
+ "workItemContext": "部分项目上下文暂不可用，工作项仍可继续查看和操作。",
+ "workItemLoad": "无法加载此工作项，请重试。",
+ "workItemUpdate": "无法保存刚才的工作项修改，请重试。"
},
"detail": {
"assignedSubtitle": "分配给你的工作项",
+ "standaloneProject": "独立工作项",
"mentionSubtitle": "评论中提及了你",
- "mentionedYou": "提及了你"
+ "mentionedYou": "提及了你",
+ "threadComments": "该话题中有 {{count}} 条评论"
},
"actions": {
"markRead": "标记已读",
diff --git a/src/modules/MainApp/TeamInbox/ConnectedTeamInboxView.tsx b/src/modules/MainApp/TeamInbox/ConnectedTeamInboxView.tsx
index e92b62f971..f32d84922c 100644
--- a/src/modules/MainApp/TeamInbox/ConnectedTeamInboxView.tsx
+++ b/src/modules/MainApp/TeamInbox/ConnectedTeamInboxView.tsx
@@ -5,9 +5,15 @@ import { useTeamInboxDataSource } from "./useTeamInboxDataSource";
import { useTeamInboxNavigation } from "./useTeamInboxNavigation";
const ConnectedTeamInboxView: React.FC = () => {
- const { dataSource } = useTeamInboxDataSource();
+ const { dataSource, viewerMemberIds } = useTeamInboxDataSource();
const navigate = useTeamInboxNavigation();
- return = ({
onNavigate,
initialFilter = "all",
pageSize = 50,
+ viewerMemberIds = [],
}) => {
const { t } = useTranslation();
const [filter, setFilter] = useState(initialFilter);
@@ -62,8 +71,27 @@ const TeamInboxView: React.FC = ({
const [reloadRevision, setReloadRevision] = useState(0);
const [hasMore, setHasMore] = useState(false);
const [loadingMore, setLoadingMore] = useState(false);
- const mutationEpochRef = useRef(0);
- const mutationByItemRef = useRef(new Map());
+ const mountedRef = useRef(true);
+
+ useEffect(() => {
+ mountedRef.current = true;
+ return () => {
+ mountedRef.current = false;
+ };
+ }, []);
+
+ const issueMessage = useCallback(
+ (issue: TeamInboxIssue): string => {
+ if (issue.code === "identity_unresolved") {
+ return t("teamInbox.errors.identity");
+ }
+ if (issue.code === "partial_load") {
+ return t("teamInbox.errors.partialLoad");
+ }
+ return t("teamInbox.errors.load");
+ },
+ [t]
+ );
useEffect(() => {
const abortController = new AbortController();
@@ -76,7 +104,17 @@ const TeamInboxView: React.FC = ({
setAuthoritativeUnreadCounts(page.unreadCounts ?? null);
setRecencyAnchorMs(Date.now());
setHasMore(page.nextCursor != null);
- setLoadState({ status: "ready", message: null });
+ setLoadState(
+ page.loading
+ ? { status: "loading", message: null }
+ : page.issue
+ ? {
+ status:
+ page.issue.code === "partial_load" ? "warning" : "error",
+ message: issueMessage(page.issue),
+ }
+ : { status: "ready", message: null }
+ );
})
.catch((reason: unknown) => {
if (abortController.signal.aborted) return;
@@ -84,13 +122,18 @@ const TeamInboxView: React.FC = ({
status: "error",
message:
reason instanceof Error
- ? reason.message
+ ? "issue" in reason &&
+ reason.issue &&
+ typeof reason.issue === "object" &&
+ "code" in reason.issue
+ ? issueMessage(reason.issue as TeamInboxIssue)
+ : reason.message
: t("teamInbox.errors.load"),
});
});
return () => abortController.abort();
- }, [dataSource, pageSize, reloadRevision, t]);
+ }, [dataSource, issueMessage, pageSize, reloadRevision, t]);
useEffect(() => {
if (!dataSource.subscribe) return;
@@ -121,26 +164,25 @@ const TeamInboxView: React.FC = ({
? getTeamInboxItemKey(selectedItem)
: null;
- const retry = () => {
- setLoadState({ status: "loading", message: null });
- setReloadRevision((value) => value + 1);
- };
-
const handleLoadMore = () => {
if (!dataSource.loadMore || loadingMore) return;
setLoadingMore(true);
void dataSource
.loadMore()
- .catch((reason: unknown) => {
+ .then(() => {
+ if (mountedRef.current) {
+ setReloadRevision((value) => value + 1);
+ }
+ })
+ .catch(() => {
setLoadState({
status: "error",
- message:
- reason instanceof Error
- ? reason.message
- : t("teamInbox.errors.load"),
+ message: t("teamInbox.errors.loadMore"),
});
})
- .finally(() => setLoadingMore(false));
+ .finally(() => {
+ if (mountedRef.current) setLoadingMore(false);
+ });
};
const handleRefresh = () => {
@@ -149,70 +191,25 @@ const TeamInboxView: React.FC = ({
setReloadRevision((value) => value + 1);
return;
}
- void dataSource.refresh().catch((reason: unknown) => {
- setLoadState({
- status: "error",
- message:
- reason instanceof Error
- ? reason.message
- : t("teamInbox.errors.refresh"),
+ void dataSource
+ .refresh()
+ .then(() => {
+ if (mountedRef.current) {
+ setReloadRevision((value) => value + 1);
+ }
+ })
+ .catch(() => {
+ setLoadState({
+ status: "error",
+ message: t("teamInbox.errors.refresh"),
+ });
});
- });
- };
-
- const beginItemMutations = (itemIds: readonly string[]): number => {
- const epoch = ++mutationEpochRef.current;
- for (const itemId of itemIds) mutationByItemRef.current.set(itemId, epoch);
- return epoch;
- };
-
- const isCurrentItemMutation = (itemId: string, epoch: number): boolean =>
- mutationByItemRef.current.get(itemId) === epoch;
-
- const updateUnreadCount = (kind: TeamInboxItem["kind"], delta: number) => {
- setAuthoritativeUnreadCounts((current) => {
- if (!current) return null;
- const key =
- kind === "comment_mention"
- ? ("mentions" as const)
- : ("assigned" as const);
- const nextForKind = Math.max(0, current[key] + delta);
- return {
- ...current,
- [key]: nextForKind,
- all: Math.max(0, current.all + delta),
- };
- });
- };
-
- const markLocallyRead = (item: TeamInboxItem) => {
- const readAt = new Date().toISOString();
- setItems((current) =>
- current.map((candidate) =>
- getTeamInboxItemKey(candidate) === getTeamInboxItemKey(item)
- ? { ...candidate, readAt }
- : candidate
- )
- );
};
const handleSelect = (item: TeamInboxItem) => {
setRequestedItemId(getTeamInboxItemKey(item));
if (item.readAt !== null) return;
- const epoch = beginItemMutations([item.id]);
- markLocallyRead(item);
- updateUnreadCount(item.kind, -1);
void dataSource.markRead?.(item).catch(() => {
- if (isCurrentItemMutation(item.id, epoch)) {
- setItems((current) =>
- current.map((candidate) =>
- candidate.id === item.id
- ? { ...candidate, readAt: null }
- : candidate
- )
- );
- updateUnreadCount(item.kind, 1);
- }
setLoadState({
status: "error",
message: t("teamInbox.errors.markRead"),
@@ -222,20 +219,7 @@ const TeamInboxView: React.FC = ({
const handleMarkRead = (item: TeamInboxItem) => {
if (item.readAt !== null) return;
- const epoch = beginItemMutations([item.id]);
- markLocallyRead(item);
- updateUnreadCount(item.kind, -1);
void dataSource.markRead?.(item).catch(() => {
- if (isCurrentItemMutation(item.id, epoch)) {
- setItems((current) =>
- current.map((candidate) =>
- candidate.id === item.id
- ? { ...candidate, readAt: null }
- : candidate
- )
- );
- updateUnreadCount(item.kind, 1);
- }
setLoadState({
status: "error",
message: t("teamInbox.errors.markRead"),
@@ -245,27 +229,7 @@ const TeamInboxView: React.FC = ({
const handleMarkUnread = (item: TeamInboxItem) => {
if (item.readAt === null) return;
- const previousReadAt = item.readAt;
- const epoch = beginItemMutations([item.id]);
- setItems((current) =>
- current.map((candidate) =>
- getTeamInboxItemKey(candidate) === getTeamInboxItemKey(item)
- ? { ...candidate, readAt: null }
- : candidate
- )
- );
- updateUnreadCount(item.kind, 1);
void dataSource.markUnread?.(item).catch(() => {
- if (isCurrentItemMutation(item.id, epoch)) {
- setItems((current) =>
- current.map((candidate) =>
- candidate.id === item.id
- ? { ...candidate, readAt: previousReadAt }
- : candidate
- )
- );
- updateUnreadCount(item.kind, -1);
- }
setLoadState({
status: "error",
message: t("teamInbox.errors.markUnread"),
@@ -274,12 +238,6 @@ const TeamInboxView: React.FC = ({
};
const handleMarkAllRead = () => {
- const targetKind = filterItemKind(filter);
- const unreadItems = items.filter(
- (item) =>
- item.readAt === null &&
- (targetKind === null || item.kind === targetKind)
- );
const filterUnreadCount =
filter === "all"
? unreadCounts.all
@@ -287,45 +245,7 @@ const TeamInboxView: React.FC = ({
? unreadCounts.mentions
: unreadCounts.assigned;
if (filterUnreadCount === 0) return;
- const readAt = new Date().toISOString();
- const affectedItems = items.filter(
- (item) => targetKind === null || item.kind === targetKind
- );
- const previousReadAtById = new Map(
- affectedItems.map((item) => [item.id, item.readAt])
- );
- const affectedIds = affectedItems.map((item) => item.id);
- const epoch = beginItemMutations(affectedIds);
- const previousCounts = authoritativeUnreadCounts;
- const markedIds = new Set(affectedIds);
- setItems((current) =>
- current.map((item) =>
- markedIds.has(item.id) ? { ...item, readAt } : item
- )
- );
- setAuthoritativeUnreadCounts((current) => {
- if (!current) return null;
- const assigned =
- filter === "all" || filter === "assigned" ? 0 : current.assigned;
- const mentions =
- filter === "all" || filter === "mentions" ? 0 : current.mentions;
- return { all: assigned + mentions, assigned, mentions };
- });
- void dataSource.markAllRead?.(unreadItems, filter).catch(() => {
- setItems((current) =>
- current.map((item) =>
- isCurrentItemMutation(item.id, epoch) &&
- previousReadAtById.has(item.id)
- ? {
- ...item,
- readAt: previousReadAtById.get(item.id) ?? null,
- }
- : item
- )
- );
- if (affectedIds.every((itemId) => isCurrentItemMutation(itemId, epoch))) {
- setAuthoritativeUnreadCounts(previousCounts);
- }
+ void dataSource.markAllRead?.([], filter).catch(() => {
setLoadState({
status: "error",
message: t("teamInbox.errors.markAllRead"),
@@ -333,6 +253,53 @@ const TeamInboxView: React.FC = ({
});
};
+ const handleWorkItemUpdated = useCallback(
+ (sourceItem: TeamInboxItem, workItem: WorkItem) => {
+ if (sourceItem.kind !== "assigned_work_item") return;
+ const sourceKey = getTeamInboxItemKey(sourceItem);
+ const assignee = workItem.assignee;
+ const belongsToViewer = assignee
+ ? viewerMemberIds.length > 0
+ ? viewerMemberIds.includes(assignee.id)
+ : assignee.id === sourceItem.payload.assigneeMemberId
+ : false;
+ const status =
+ workItem.workItemStatus ?? workItem.status ?? sourceItem.payload.status;
+ const updatedAt = workItem.updated_time || sourceItem.payload.updatedAt;
+ const nextItem: TeamInboxItem | null =
+ assignee && belongsToViewer
+ ? {
+ ...sourceItem,
+ occurredAt: updatedAt,
+ payload: {
+ ...sourceItem.payload,
+ title: workItem.name || sourceItem.payload.title,
+ status,
+ priority: workItem.priority ?? sourceItem.payload.priority,
+ assigneeMemberId: assignee.id,
+ assigneeName: assignee.name,
+ summary: workItem.spec?.trim() || undefined,
+ updatedAt,
+ },
+ }
+ : null;
+ if (dataSource.reconcileItem) {
+ dataSource.reconcileItem(sourceKey, nextItem);
+ return;
+ }
+ setItems((current) =>
+ current.flatMap((candidate) =>
+ getTeamInboxItemKey(candidate) === sourceKey
+ ? nextItem
+ ? [nextItem]
+ : []
+ : [candidate]
+ )
+ );
+ },
+ [dataSource, viewerMemberIds]
+ );
+
const detail = (() => {
if (loadState.status === "loading") {
return (
@@ -351,7 +318,7 @@ const TeamInboxView: React.FC = ({
placement="detail-panel"
title={t("teamInbox.errors.loadTitle")}
subtitle={loadState.message ?? undefined}
- action={{ label: t("common:actions.retry"), onClick: retry }}
+ action={{ label: t("common:actions.retry"), onClick: handleRefresh }}
fillParentHeight
/>
);
@@ -387,24 +354,33 @@ const TeamInboxView: React.FC = ({
onMarkRead={dataSource.markRead ? handleMarkRead : undefined}
onMarkUnread={dataSource.markUnread ? handleMarkUnread : undefined}
onNavigate={onNavigate}
+ onWorkItemUpdated={(workItem) =>
+ handleWorkItemUpdated(selectedItem, workItem)
+ }
/>
);
})();
return (
-
- {loadState.status === "error" && items.length > 0 ? (
+
+ {(loadState.status === "error" || loadState.status === "warning") &&
+ items.length > 0 ? (
{loadState.message}
) : null}
= ({
variant="error"
title={t("teamInbox.errors.loadTitle")}
subtitle={loadState.message ?? undefined}
- action={{ label: t("common:actions.retry"), onClick: retry }}
+ action={{
+ label: t("common:actions.retry"),
+ onClick: handleRefresh,
+ }}
fillParentHeight
/>
) : (
diff --git a/src/modules/MainApp/TeamInbox/__tests__/AssignedWorkItemDetail.test.ts b/src/modules/MainApp/TeamInbox/__tests__/AssignedWorkItemDetail.test.ts
index fd347a904d..38b2db2175 100644
--- a/src/modules/MainApp/TeamInbox/__tests__/AssignedWorkItemDetail.test.ts
+++ b/src/modules/MainApp/TeamInbox/__tests__/AssignedWorkItemDetail.test.ts
@@ -52,33 +52,46 @@ vi.mock("../useTeamInboxWorkItem", () => ({
useTeamInboxWorkItem: () => ({
workItem: mocks.workItem,
status: "ready",
- error: null,
+ issue: null,
repoPath: "/repo",
members: [],
+ currentUser: {
+ id: "user-ea821852",
+ name: "hanafish",
+ avatar: "https://example.com/hanafish.png",
+ color: "#52c41a",
+ },
updateWorkItem: vi.fn(),
refreshWorkItem: vi.fn(),
}),
}));
vi.mock("@src/modules/ProjectManager/WorkItems/components", () => ({
- WorkItemProperties: ({ pillLayout }: { pillLayout?: string }) =>
- createElement("div", {
- "data-testid": "work-item-properties",
- "data-pill-layout": pillLayout,
- }),
- WorkItemContent: ({
+ WorkItemThreadSurface: ({
onStartAgent,
onOpenSession,
- headerProperties,
+ propertyProps,
+ currentUser,
}: {
onStartAgent?: () => void;
onOpenSession?: (sessionId: string) => void;
- headerProperties?: React.ReactNode;
+ propertyProps?: Record;
+ currentUser?: { id: string; name: string; avatar?: string };
}) =>
createElement(
"div",
- null,
- headerProperties,
+ {
+ "data-testid": "work-item-content",
+ "data-current-user-id": currentUser?.id,
+ "data-current-user-name": currentUser?.name,
+ "data-current-user-avatar": currentUser?.avatar,
+ },
+ propertyProps
+ ? createElement("div", {
+ "data-testid": "work-item-properties",
+ "data-property-configured": "true",
+ })
+ : null,
createElement(
"button",
{
@@ -176,7 +189,7 @@ describe("AssignedWorkItemDetail navigation actions", () => {
});
});
- it("uses the responsive wrapping layout for constrained property pills", () => {
+ it("provides editable properties to the shared thread surface", () => {
act(() => {
root.render(createElement(AssignedWorkItemDetail, { item }));
});
@@ -184,8 +197,23 @@ describe("AssignedWorkItemDetail navigation actions", () => {
expect(
container
.querySelector("[data-testid='work-item-properties']")
- ?.getAttribute("data-pill-layout")
- ).toBe("wrap");
+ ?.getAttribute("data-property-configured")
+ ).toBe("true");
+ });
+
+ it("passes one resolved identity to the comment composer and history surface", () => {
+ act(() => {
+ root.render(createElement(AssignedWorkItemDetail, { item }));
+ });
+
+ const content = container.querySelector(
+ "[data-testid='work-item-content']"
+ );
+ expect(content?.getAttribute("data-current-user-id")).toBe("user-ea821852");
+ expect(content?.getAttribute("data-current-user-name")).toBe("hanafish");
+ expect(content?.getAttribute("data-current-user-avatar")).toBe(
+ "https://example.com/hanafish.png"
+ );
});
it("preserves linked-session navigation as a distinct Session tab intent", () => {
diff --git a/src/modules/MainApp/TeamInbox/__tests__/TEST_CASES.md b/src/modules/MainApp/TeamInbox/__tests__/TEST_CASES.md
index 031f5a960c..34f3f4b950 100644
--- a/src/modules/MainApp/TeamInbox/__tests__/TEST_CASES.md
+++ b/src/modules/MainApp/TeamInbox/__tests__/TEST_CASES.md
@@ -12,10 +12,10 @@ Behavior is derived from the shipped implementation, not aspirational.
- Local source page size is 50 (`listLocalTeamInboxPage(..., 50)`); cloud
mentions page size is 50 (`listTeamInboxMentions(..., 50)`).
- `hasMore` is surfaced to the view via `listPage().nextCursor != null`; the
- cursor value itself is an inert sentinel — the data source owns the real
- per-source cursors (`localCursorRef` / `cloudCursorRef`).
-- The load-more control renders only inside the non-empty list branch, at the
- bottom of the scroll area, when `hasMore === true` and `onLoadMore` is defined.
+ cursor value itself is an inert sentinel — the per-store coordinator owns the
+ real local/cloud cursors shared by Sidebar and full Inbox consumers.
+- The load-more control renders whenever `hasMore === true` and `onLoadMore` is
+ defined, including filter/search empty-result states.
## Happy Path
@@ -23,7 +23,7 @@ Behavior is derived from the shipped implementation, not aspirational.
| --- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 1 | Open inbox with > 50 assigned local items (or > 50 mentions). | First page (≤ 50 per source) renders; "Load more" button is visible at list bottom. |
| 2 | Click "Load more". | Button shows loading/disabled; next page of each source with a remaining cursor is fetched, appended, de-duplicated (`dedupeTeamInboxItems`), re-sorted by the view selectors; new items appear. |
-| 3 | Keep clicking "Load more" until exhausted. | Each click appends the next page; when both `localCursorRef` and `cloudCursorRef` are null, `hasMore` becomes false and the button disappears. |
+| 3 | Keep clicking "Load more" until exhausted. | Each click appends the next page; when both shared coordinator cursors are null, `hasMore` becomes false and the button disappears. |
| 4 | Load more with both local + cloud having further pages. | Both sources advance one page; merged list stays newest-first after the view's `selectTeamInboxItems` (dedupe + sort). |
| 5 | After load-more, mark a newly-loaded item read. | Optimistic read state applies to the appended item exactly as for first-page items. |
@@ -31,11 +31,11 @@ Behavior is derived from the shipped implementation, not aspirational.
| # | Scenario | Steps | Expected Result |
| --- | ------------------------------------------------------ | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 1 | Empty inbox | Open inbox with 0 items. | Empty `Placeholder` renders; **no** "Load more" button (it lives in the items-present branch). |
+| 1 | Empty first page with a remaining cursor | Open an active filter/search with 0 visible items and `hasMore`. | Empty `Placeholder` renders together with "Load more", so a matching later page remains reachable. |
| 2 | Single page | Open inbox where both sources returned `nextCursor == null`. | `hasMore === false`; **no** "Load more" button; list is complete. |
| 3 | Exactly one source paginates | Local has a next page, cloud does not (or vice versa). | Button shown while either cursor is non-null; each click advances only the source that still has a cursor; the exhausted source contributes nothing. |
| 4 | Multi-page to exhaustion | Click load-more repeatedly. | Cursors advance each call; button hides once both cursors are null; no duplicate rows (dedupe by canonical `kind:id`). |
-| 5 | Rapid repeated clicks | Click "Load more" several times quickly. | `loadingMoreRef` guard + `disabled={loadingMore}` ensure only one in-flight load; extra clicks are no-ops; no duplicated/skipped pages. |
+| 5 | Rapid repeated clicks | Click "Load more" several times quickly. | View loading state plus the coordinator single-flight promise ensure only one in-flight load; extra clicks reuse/no-op; no duplicated/skipped pages. |
| 6 | Load-more with active search query | Type a query, then click "Load more". | Load-more fetches more raw items into the cache; the client-side search (`searchTeamInboxItems`) re-applies over the enlarged set. |
| 7 | Load-more with a filter tab active (mentions/assigned) | Switch filter, then load more. | Raw items append to the shared cache; the active filter (`selectTeamInboxItems`) still narrows the rendered list. |
| 8 | Duplicate item across pages | A canonical item appears in two fetched pages. | Deduped to one; the freshest `occurredAt` copy wins (`dedupeTeamInboxItems`). |
@@ -43,18 +43,19 @@ Behavior is derived from the shipped implementation, not aspirational.
## Error / Degraded States
-| # | Scenario | Steps | Expected Result |
-| --- | ---------------------------------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 1 | Cloud fetch fails during load-more | Cloud RPC throws while paginating. | Caught inside `loadMore` (`.catch(() => ({ mentions: [], nextCursor: undefined }))`); cloud cursor becomes null (cloud pagination stops); local page still appends; no crash. |
-| 2 | Local fetch fails during load-more | `listLocalTeamInboxPage` rejects. | `Promise.all` rejects → `handleLoadMore` catch sets the error banner (`teamInbox.errors.load`); `loadingMore` resets via `finally`; existing items remain. |
-| 3 | Load-more called with no cursors | `hasMore` stale-true but both cursors null. | `loadMore` early-returns (no-op); no fetch; `loadingMore` never gets stuck. |
-| 4 | Signed-out / no active cloud org | Only local paginates. | Cloud branch resolves to empty; only local advances; behavior identical to Edge #3. |
+| # | Scenario | Steps | Expected Result |
+| --- | ---------------------------------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| 1 | Cloud fetch fails during load-more | Cloud RPC throws while paginating. | Local page still commits; cloud cursor is preserved for retry; a localized partial-success warning appears. |
+| 2 | Local fetch fails during load-more | `listLocalTeamInboxPage` rejects. | Cloud page still commits; local cursor is preserved for retry; a localized partial-success warning appears. |
+| 3 | Every requested source fails | Both active source reads reject. | Existing rows remain; load-more rejects to the view, which shows localized non-blocking error copy and resets loading in `finally`. |
+| 4 | Load-more called with no cursors | `hasMore` stale-true but both cursors null. | `loadMore` early-returns (no-op); no fetch; `loadingMore` never gets stuck. |
+| 5 | Signed-out / no active cloud org | Only local paginates. | No cloud request is started; only local advances. |
## Accessibility
- [ ] "Load more" uses the design-system `Button` (keyboard focusable, Enter/Space activate).
- [ ] While loading, the button is `disabled` and shows `loading` state (no double submit).
-- [ ] The button has a visible localized label (`teamInbox.loadMore`, defaultValue "Load more") — no raw i18n key leaks.
+- [ ] The button has a visible localized label (`teamInbox.loadMore`) — no raw fallback string or i18n key leaks.
- [ ] Load-more does not steal focus from the list; existing roving-tabindex list navigation is unaffected.
## Acceptance Criteria
@@ -63,7 +64,7 @@ Behavior is derived from the shipped implementation, not aspirational.
- [ ] `hasMore` accurately reflects "either source has a next page" and the button visibility follows it.
- [ ] Appended pages are de-duplicated and correctly ordered by the view selectors.
- [ ] Concurrent/rapid load-more is guarded (single in-flight request).
-- [ ] A cloud failure degrades gracefully (local still paginates); a local failure surfaces a non-blocking error banner without losing loaded items.
+- [ ] Either source may fail independently; the successful source still paginates, the failed cursor remains retryable, and loaded items are preserved.
- [ ] Load-more never derives the badge from the loaded window; the server's authoritative mention count remains unchanged until a read mutation succeeds.
- [ ] `pnpm test` for `src/modules/MainApp/TeamInbox` passes; no new TypeScript/lint errors in edited files.
@@ -71,7 +72,6 @@ Behavior is derived from the shipped implementation, not aspirational.
- The unread badge uses the cloud RPC's authoritative full-result count, so
unread mentions on page 2+ are included before those rows are loaded.
-- Hook-level behavior is not unit-tested (repo policy forbids `.tsx` / React
- Testing Library tests); pure logic is covered by `selectors.test.ts`
- (dedupe/sort/select), while the two-instance rendered cloud spec covers the
- production mention picker and durable read-receipt path.
+- Coordinator behavior is unit-tested at the shared Jotai-store seam for cursor
+ continuity, partial failure, scope switching, optimistic rollback and cache
+ bounds. Component composition tests cover empty-result pagination and retry.
diff --git a/src/modules/MainApp/TeamInbox/__tests__/TeamInboxList.test.ts b/src/modules/MainApp/TeamInbox/__tests__/TeamInboxList.test.ts
new file mode 100644
index 0000000000..a6ccbea8ee
--- /dev/null
+++ b/src/modules/MainApp/TeamInbox/__tests__/TeamInboxList.test.ts
@@ -0,0 +1,44 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it, vi } from "vitest";
+
+import TeamInboxList from "../components/TeamInboxList";
+
+vi.mock("react-i18next", () => ({
+ useTranslation: () => ({
+ t: (key: string) => key,
+ }),
+}));
+
+function renderEmptyList(query: string): string {
+ return renderToStaticMarkup(
+ createElement(TeamInboxList, {
+ filter: "all",
+ items: [],
+ recencyAnchorMs: Date.UTC(2026, 6, 28),
+ selectedItemId: null,
+ totalUnread: 0,
+ unreadCounts: { all: 0, mentions: 0, assigned: 0 },
+ query,
+ loading: false,
+ onQueryChange: vi.fn(),
+ onFilterChange: vi.fn(),
+ onSelectItem: vi.fn(),
+ hasMore: true,
+ onLoadMore: vi.fn(),
+ })
+ );
+}
+
+describe("TeamInboxList pagination", () => {
+ it("keeps Load more reachable when the current search has no visible rows", () => {
+ const markup = renderEmptyList("missing");
+
+ expect(markup).toContain("teamInbox.empty.noResults.title");
+ expect(markup).toContain("teamInbox.loadMore");
+ });
+
+ it("does not point assistive technology at an unmounted active row", () => {
+ expect(renderEmptyList("")).not.toContain("aria-activedescendant");
+ });
+});
diff --git a/src/modules/MainApp/TeamInbox/__tests__/TeamInboxRow.test.ts b/src/modules/MainApp/TeamInbox/__tests__/TeamInboxRow.test.ts
new file mode 100644
index 0000000000..d0987769b1
--- /dev/null
+++ b/src/modules/MainApp/TeamInbox/__tests__/TeamInboxRow.test.ts
@@ -0,0 +1,112 @@
+// @vitest-environment jsdom
+import { act, createElement } from "react";
+import { type Root, createRoot } from "react-dom/client";
+import {
+ afterAll,
+ afterEach,
+ beforeAll,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+} from "vitest";
+
+import TeamInboxRow from "../components/TeamInboxRow";
+import type { AssignedWorkItem } from "../domain";
+
+vi.mock("react-i18next", () => ({
+ useTranslation: () => ({
+ t: (_key: string, options?: { defaultValue?: string }) =>
+ options?.defaultValue ?? _key,
+ }),
+}));
+
+const assignedItem: AssignedWorkItem = {
+ id: "assigned-1",
+ kind: "assigned_work_item",
+ occurredAt: new Date().toISOString(),
+ readAt: "2026-07-28T00:00:00.000Z",
+ actor: { id: "member-1", displayName: "Yuki" },
+ target: { kind: "work_item", projectId: "demo", workItemId: "AAA-0001" },
+ payload: {
+ title: "验收 Team Inbox 的真实分配与已读流程",
+ status: "todo",
+ priority: "medium",
+ assigneeMemberId: "member-1",
+ assigneeName: "Yuki",
+ summary:
+ "## 验收目标\\n- 在 Team Inbox 的“全部”和“分配给我”中看到此事项\\n- 打开详情并标记已读",
+ updatedAt: "2026-07-28T00:00:00.000Z",
+ },
+};
+
+describe("TeamInboxRow", () => {
+ let container: HTMLDivElement;
+ let root: Root;
+ const actEnvironment = globalThis as typeof globalThis & {
+ IS_REACT_ACT_ENVIRONMENT?: boolean;
+ };
+
+ beforeAll(() => {
+ actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+ });
+
+ beforeEach(() => {
+ container = document.createElement("div");
+ document.body.appendChild(container);
+ root = createRoot(container);
+ });
+
+ afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+ });
+
+ afterAll(() => {
+ Reflect.deleteProperty(actEnvironment, "IS_REACT_ACT_ENVIRONMENT");
+ });
+
+ it("renders a compact plain-text excerpt and useful Work Item metadata", () => {
+ act(() => {
+ root.render(
+ createElement(TeamInboxRow, {
+ item: assignedItem,
+ itemKey: "assigned_work_item:assigned-1",
+ selected: true,
+ onSelect: vi.fn(),
+ })
+ );
+ });
+
+ const summary = container.querySelector("[title]");
+ expect(summary?.textContent).toBe(
+ "验收目标 在 Team Inbox 的“全部”和“分配给我”中看到此事项 打开详情并标记已读"
+ );
+ expect(summary?.textContent).not.toContain("\\n");
+ expect(summary?.textContent).not.toContain("##");
+ expect(summary?.className).toContain("max-h-10");
+ expect(summary?.className).toContain("text-text-1");
+ expect(container.textContent).toContain("Todo · Medium");
+ expect(container.textContent).not.toContain("Yuki");
+ });
+
+ it("omits the excerpt row when an assigned item has no summary", () => {
+ act(() => {
+ root.render(
+ createElement(TeamInboxRow, {
+ item: {
+ ...assignedItem,
+ payload: { ...assignedItem.payload, summary: undefined },
+ },
+ itemKey: "assigned_work_item:assigned-1",
+ selected: false,
+ onSelect: vi.fn(),
+ })
+ );
+ });
+
+ expect(container.querySelector("[title]")).toBeNull();
+ expect(container.textContent).toContain("Todo · Medium");
+ });
+});
diff --git a/src/modules/MainApp/TeamInbox/__tests__/TeamInboxView.layout.test.ts b/src/modules/MainApp/TeamInbox/__tests__/TeamInboxView.layout.test.ts
index 41599e518f..e888e42931 100644
--- a/src/modules/MainApp/TeamInbox/__tests__/TeamInboxView.layout.test.ts
+++ b/src/modules/MainApp/TeamInbox/__tests__/TeamInboxView.layout.test.ts
@@ -1,5 +1,5 @@
// @vitest-environment jsdom
-import { act, createElement } from "react";
+import React, { act, createElement } from "react";
import { type Root, createRoot } from "react-dom/client";
import {
afterAll,
@@ -12,33 +12,56 @@ import {
vi,
} from "vitest";
+import type { WorkItem } from "@src/types/core/workItem";
+
import TeamInboxView from "../TeamInboxView";
+import type { AssignedWorkItem } from "../domain";
const splitViewProps = vi.hoisted(() => ({
current: null as Record | null,
}));
+const componentProps = vi.hoisted(() => ({
+ assignedDetail: null as Record | null,
+ list: null as Record | null,
+ placeholder: null as Record | null,
+}));
+const translate = vi.hoisted(() => vi.fn((key: string) => key));
vi.mock("react-i18next", () => ({
useTranslation: () => ({
- t: (key: string) => key,
+ t: translate,
}),
}));
vi.mock("@src/modules/shared/layouts/SplitViewLayout", () => ({
default: (props: Record) => {
splitViewProps.current = props;
- return createElement("div", { "data-testid": "team-inbox-split" });
+ return createElement(
+ "div",
+ { "data-testid": "team-inbox-split" },
+ props.listContent as React.ReactNode,
+ props.mainContent as React.ReactNode
+ );
},
}));
vi.mock("@src/modules/shared/layouts/blocks", () => ({
- Placeholder: () => null,
+ Placeholder: (props: Record) => {
+ componentProps.placeholder = props;
+ return null;
+ },
}));
vi.mock("../components", () => ({
- AssignedWorkItemDetail: () => null,
+ AssignedWorkItemDetail: (props: Record) => {
+ componentProps.assignedDetail = props;
+ return null;
+ },
CommentMentionDetail: () => null,
- TeamInboxList: () => null,
+ TeamInboxList: (props: Record) => {
+ componentProps.list = props;
+ return null;
+ },
}));
describe("TeamInboxView split layout", () => {
@@ -54,6 +77,9 @@ describe("TeamInboxView split layout", () => {
beforeEach(() => {
splitViewProps.current = null;
+ componentProps.assignedDetail = null;
+ componentProps.list = null;
+ componentProps.placeholder = null;
container = document.createElement("div");
document.body.appendChild(container);
root = createRoot(container);
@@ -84,4 +110,116 @@ describe("TeamInboxView split layout", () => {
true
);
});
+
+ it("projects successful detail edits back into the matching Inbox row", async () => {
+ const assignedItem: AssignedWorkItem = {
+ id: "assigned-1",
+ kind: "assigned_work_item",
+ occurredAt: "2026-07-28T00:00:00.000Z",
+ readAt: "2026-07-28T00:01:00.000Z",
+ actor: { id: "member-1", displayName: "Yuki" },
+ target: {
+ kind: "work_item",
+ projectId: "demo",
+ workItemId: "AAA-0001",
+ },
+ payload: {
+ title: "Old title",
+ status: "todo",
+ priority: "medium",
+ assigneeMemberId: "member-1",
+ assigneeName: "Yuki",
+ summary: "Old summary",
+ updatedAt: "2026-07-28T00:00:00.000Z",
+ },
+ };
+
+ await act(async () => {
+ root.render(
+ createElement(TeamInboxView, {
+ dataSource: {
+ listPage: async () => ({
+ items: [assignedItem],
+ nextCursor: null,
+ }),
+ },
+ })
+ );
+ await Promise.resolve();
+ });
+
+ const onWorkItemUpdated = componentProps.assignedDetail
+ ?.onWorkItemUpdated as ((workItem: WorkItem) => void) | undefined;
+ expect(onWorkItemUpdated).toBeTypeOf("function");
+
+ const updatedWorkItem: WorkItem = {
+ session_id: "AAA-0001",
+ user_id: "member-1",
+ name: "Updated title",
+ status: "in_review",
+ workItemStatus: "in_review",
+ priority: "high",
+ spec: "## Updated summary",
+ assignee: { id: "member-1", name: "Yuki" },
+ star: false,
+ target_date: null,
+ created_time: "2026-07-28T00:00:00.000Z",
+ updated_time: "2026-07-28T00:05:00.000Z",
+ linkedSessions: [],
+ todos: [],
+ };
+
+ act(() => onWorkItemUpdated?.(updatedWorkItem));
+
+ const updatedItems = componentProps.list?.items as AssignedWorkItem[];
+ expect(updatedItems[0].payload).toMatchObject({
+ title: "Updated title",
+ status: "in_review",
+ priority: "high",
+ assigneeMemberId: "member-1",
+ assigneeName: "Yuki",
+ summary: "## Updated summary",
+ updatedAt: "2026-07-28T00:05:00.000Z",
+ });
+
+ act(() =>
+ onWorkItemUpdated?.({
+ ...updatedWorkItem,
+ assignee: { id: "member-2", name: "Lin" },
+ })
+ );
+
+ expect(componentProps.list?.items).toEqual([]);
+ });
+
+ it("retries the backing source instead of rereading a failed snapshot", async () => {
+ const listPage = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("offline"))
+ .mockResolvedValueOnce({ items: [], nextCursor: null });
+ const refresh = vi.fn(async () => undefined);
+
+ await act(async () => {
+ root.render(
+ createElement(TeamInboxView, {
+ dataSource: { listPage, refresh },
+ })
+ );
+ await Promise.resolve();
+ });
+
+ const action = componentProps.placeholder?.action as
+ | { onClick?: () => void }
+ | undefined;
+ expect(action?.onClick).toBeTypeOf("function");
+
+ await act(async () => {
+ action?.onClick?.();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(refresh).toHaveBeenCalledOnce();
+ expect(listPage).toHaveBeenCalledTimes(2);
+ });
});
diff --git a/src/modules/MainApp/TeamInbox/__tests__/teamInboxCoordinator.test.ts b/src/modules/MainApp/TeamInbox/__tests__/teamInboxCoordinator.test.ts
new file mode 100644
index 0000000000..4e0bd67011
--- /dev/null
+++ b/src/modules/MainApp/TeamInbox/__tests__/teamInboxCoordinator.test.ts
@@ -0,0 +1,385 @@
+import { createStore } from "jotai";
+import { describe, expect, it, vi } from "vitest";
+
+import type { TeamInboxMention } from "@src/features/Org2Cloud/teamInboxMentionsClient";
+
+import type { AssignedWorkItem } from "../domain";
+import { teamInboxCacheAtom } from "../store";
+import {
+ TEAM_INBOX_CACHE_LIMIT,
+ TeamInboxCoordinator,
+ type TeamInboxCoordinatorDependencies,
+ type TeamInboxCoordinatorScope,
+} from "../teamInboxCoordinator";
+
+function assignedItem(
+ id: string,
+ occurredAt = "2026-07-28T10:00:00.000Z"
+): AssignedWorkItem {
+ return {
+ id,
+ kind: "assigned_work_item",
+ occurredAt,
+ readAt: null,
+ actor: { id: "assigner", displayName: "Assigner" },
+ target: {
+ kind: "work_item",
+ projectId: "project-1",
+ workItemId: id,
+ },
+ payload: {
+ title: id,
+ status: "todo",
+ priority: "medium",
+ assigneeMemberId: "viewer-1",
+ updatedAt: occurredAt,
+ },
+ };
+}
+
+function mention(id: string): TeamInboxMention {
+ return {
+ comment: { id },
+ session: { id: `session-${id}` },
+ author: { userId: "author-1" },
+ body: `Mention ${id}`,
+ createdAt: "2026-07-28T11:00:00.000Z",
+ readAt: null,
+ commentCount: 1,
+ threadCount: 1,
+ };
+}
+
+function dependencies(
+ overrides: Partial = {}
+): TeamInboxCoordinatorDependencies {
+ return {
+ listLocalPage: vi.fn(async () => ({
+ page: { items: [], nextCursor: null },
+ unreadCount: 0,
+ })),
+ listInitialMentions: vi.fn(async () => ({
+ mentions: [],
+ unreadCount: 0,
+ })),
+ listMentions: vi.fn(async () => ({
+ mentions: [],
+ unreadCount: 0,
+ })),
+ markLocalRead: vi.fn(async () => true),
+ markLocalUnread: vi.fn(async () => true),
+ markAllLocalRead: vi.fn(async () => 0),
+ setMentionRead: vi.fn(async () => ({
+ readAt: "2026-07-28T12:00:00.000Z",
+ unreadCount: 0,
+ })),
+ markAllMentionsRead: vi.fn(async () => ({
+ readAt: "2026-07-28T12:00:00.000Z",
+ unreadCount: 0,
+ })),
+ now: () => "2026-07-28T12:00:00.000Z",
+ ...overrides,
+ };
+}
+
+function scope(
+ overrides: Partial = {}
+): TeamInboxCoordinatorScope {
+ return {
+ key: "viewer-1::local",
+ viewerMemberIds: ["viewer-1"],
+ accessToken: null,
+ activeCloudOrgId: null,
+ members: [],
+ ...overrides,
+ };
+}
+
+describe("TeamInboxCoordinator", () => {
+ it("shares the first-page cursor across consumers using the same store", async () => {
+ const firstCursor = {
+ occurredAt: "2026-07-28T10:00:00.000Z",
+ itemKey: "assigned_work_item:first",
+ };
+ const listLocalPage = vi
+ .fn()
+ .mockResolvedValueOnce({
+ page: { items: [assignedItem("first")], nextCursor: firstCursor },
+ unreadCount: 2,
+ })
+ .mockResolvedValueOnce({
+ page: {
+ items: [assignedItem("second", "2026-07-28T09:00:00.000Z")],
+ nextCursor: null,
+ },
+ unreadCount: 2,
+ });
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({ listLocalPage })
+ );
+ const store = createStore();
+ const viewerScope = scope();
+
+ await coordinator.refresh(store, viewerScope, "version-1");
+ await coordinator.loadMore(store, viewerScope);
+
+ expect(listLocalPage).toHaveBeenNthCalledWith(
+ 2,
+ ["viewer-1"],
+ "all",
+ firstCursor
+ );
+ expect(store.get(teamInboxCacheAtom).items.map((item) => item.id)).toEqual([
+ "first",
+ "second",
+ ]);
+ expect(store.get(teamInboxCacheAtom).hasMore).toBe(false);
+ });
+
+ it("publishes a usable partial snapshot when one source fails", async () => {
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({
+ listLocalPage: vi.fn(async () => ({
+ page: { items: [assignedItem("local")], nextCursor: null },
+ unreadCount: 1,
+ })),
+ listInitialMentions: vi.fn(async () => {
+ throw new Error("cloud unavailable");
+ }),
+ })
+ );
+ const store = createStore();
+
+ await coordinator.refresh(
+ store,
+ scope({
+ key: "viewer-1::org-1",
+ accessToken: "token",
+ activeCloudOrgId: "org-1",
+ }),
+ "version-1"
+ );
+
+ expect(store.get(teamInboxCacheAtom)).toMatchObject({
+ unreadCount: 1,
+ unreadCounts: { all: 1, assigned: 1, mentions: 0 },
+ issue: { code: "partial_load", detail: "cloud unavailable" },
+ });
+ expect(store.get(teamInboxCacheAtom).items).toHaveLength(1);
+ });
+
+ it("keeps cloud results visible while reporting an unresolved local identity", async () => {
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({
+ listInitialMentions: vi.fn(async () => ({
+ mentions: [mention("cloud-1")],
+ unreadCount: 1,
+ })),
+ })
+ );
+ const store = createStore();
+
+ await coordinator.refresh(
+ store,
+ scope({
+ key: "::org-1",
+ viewerMemberIds: [],
+ accessToken: "token",
+ activeCloudOrgId: "org-1",
+ members: [
+ {
+ id: "someone-else",
+ name: "Someone Else",
+ email: "else@example.com",
+ active: true,
+ },
+ ],
+ }),
+ "version-1"
+ );
+
+ expect(store.get(teamInboxCacheAtom).issue?.code).toBe(
+ "identity_unresolved"
+ );
+ expect(store.get(teamInboxCacheAtom).items).toHaveLength(1);
+ });
+
+ it("keeps a failed source cursor retryable while appending a successful page", async () => {
+ const localCursor = {
+ occurredAt: "2026-07-28T10:00:00.000Z",
+ itemKey: "assigned_work_item:first",
+ };
+ const listLocalPage = vi
+ .fn()
+ .mockResolvedValueOnce({
+ page: { items: [assignedItem("first")], nextCursor: localCursor },
+ unreadCount: 2,
+ })
+ .mockResolvedValueOnce({
+ page: {
+ items: [assignedItem("second", "2026-07-28T09:00:00.000Z")],
+ nextCursor: null,
+ },
+ unreadCount: 2,
+ });
+ const listMentions = vi
+ .fn()
+ .mockRejectedValueOnce(new Error("temporary cloud failure"))
+ .mockResolvedValueOnce({
+ mentions: [mention("cloud-2")],
+ unreadCount: 2,
+ });
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({
+ listLocalPage,
+ listInitialMentions: vi.fn(async () => ({
+ mentions: [mention("cloud-1")],
+ nextCursor: "cloud-cursor",
+ unreadCount: 2,
+ })),
+ listMentions,
+ })
+ );
+ const store = createStore();
+ const viewerScope = scope({
+ key: "viewer-1::org-1",
+ accessToken: "token",
+ activeCloudOrgId: "org-1",
+ });
+
+ await coordinator.refresh(store, viewerScope, "version-1");
+ await coordinator.loadMore(store, viewerScope);
+
+ expect(store.get(teamInboxCacheAtom).issue?.code).toBe("partial_load");
+ expect(store.get(teamInboxCacheAtom).hasMore).toBe(true);
+ expect(
+ store.get(teamInboxCacheAtom).items.map((item) => item.id)
+ ).toContain("second");
+
+ await coordinator.loadMore(store, viewerScope);
+
+ expect(listMentions).toHaveBeenNthCalledWith(
+ 2,
+ "token",
+ "org-1",
+ "cloud-cursor",
+ 50,
+ expect.any(AbortSignal)
+ );
+ expect(
+ store.get(teamInboxCacheAtom).items.map((item) => item.id)
+ ).toContain("cloud-comment:org-1:cloud-2");
+ expect(store.get(teamInboxCacheAtom).hasMore).toBe(false);
+ });
+
+ it("ignores a late response after the viewer scope changes", async () => {
+ let resolveOldCloud:
+ | ((value: { mentions: TeamInboxMention[]; unreadCount: number }) => void)
+ | undefined;
+ const oldCloud = new Promise<{
+ mentions: TeamInboxMention[];
+ unreadCount: number;
+ }>((resolve) => {
+ resolveOldCloud = resolve;
+ });
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({
+ listLocalPage: vi.fn(async (viewerIds) => ({
+ page: {
+ items: [assignedItem(viewerIds[0] ?? "unknown")],
+ nextCursor: null,
+ },
+ unreadCount: 1,
+ })),
+ listInitialMentions: vi
+ .fn()
+ .mockImplementationOnce(async () => oldCloud)
+ .mockResolvedValueOnce({ mentions: [], unreadCount: 0 }),
+ })
+ );
+ const store = createStore();
+ const oldScope = scope({
+ key: "viewer-1::org-1",
+ accessToken: "token",
+ activeCloudOrgId: "org-1",
+ });
+ const nextScope = scope({
+ key: "viewer-2::org-2",
+ viewerMemberIds: ["viewer-2"],
+ accessToken: "token",
+ activeCloudOrgId: "org-2",
+ });
+
+ const staleRefresh = coordinator.refresh(store, oldScope, "version-1");
+ await coordinator.refresh(store, nextScope, "version-1");
+ resolveOldCloud?.({ mentions: [mention("stale")], unreadCount: 1 });
+ await staleRefresh;
+
+ expect(store.get(teamInboxCacheAtom).loadedForViewerKey).toBe(
+ "viewer-2::org-2"
+ );
+ expect(store.get(teamInboxCacheAtom).items.map((item) => item.id)).toEqual([
+ "viewer-2",
+ ]);
+ });
+
+ it("rolls back an optimistic read mutation when persistence fails", async () => {
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({
+ listLocalPage: vi.fn(async () => ({
+ page: { items: [assignedItem("first")], nextCursor: null },
+ unreadCount: 1,
+ })),
+ markLocalRead: vi.fn(async () => {
+ throw new Error("write failed");
+ }),
+ })
+ );
+ const store = createStore();
+ const viewerScope = scope();
+ await coordinator.refresh(store, viewerScope, "version-1");
+ const item = store.get(teamInboxCacheAtom).items[0];
+
+ const mutation = coordinator.markRead(store, viewerScope, item);
+ expect(store.get(teamInboxCacheAtom).items[0].readAt).toBe(
+ "2026-07-28T12:00:00.000Z"
+ );
+ expect(store.get(teamInboxCacheAtom).unreadCount).toBe(0);
+
+ await expect(mutation).rejects.toThrow("write failed");
+ expect(store.get(teamInboxCacheAtom).items[0].readAt).toBeNull();
+ expect(store.get(teamInboxCacheAtom).unreadCount).toBe(1);
+ });
+
+ it("caps retained rows and closes cursors at the cache boundary", async () => {
+ const coordinator = new TeamInboxCoordinator(
+ dependencies({
+ listLocalPage: vi.fn(async () => ({
+ page: {
+ items: Array.from(
+ { length: TEAM_INBOX_CACHE_LIMIT + 25 },
+ (_, index) =>
+ assignedItem(
+ `item-${index}`,
+ new Date(Date.UTC(2026, 6, 28, 12, 0, index)).toISOString()
+ )
+ ),
+ nextCursor: {
+ occurredAt: "2026-07-28T00:00:00.000Z",
+ itemKey: "more",
+ },
+ },
+ unreadCount: TEAM_INBOX_CACHE_LIMIT + 25,
+ })),
+ })
+ );
+ const store = createStore();
+
+ await coordinator.refresh(store, scope(), "version-1");
+
+ expect(store.get(teamInboxCacheAtom).items).toHaveLength(
+ TEAM_INBOX_CACHE_LIMIT
+ );
+ expect(store.get(teamInboxCacheAtom).hasMore).toBe(false);
+ });
+});
diff --git a/src/modules/MainApp/TeamInbox/__tests__/useTeamInboxWorkItem.test.ts b/src/modules/MainApp/TeamInbox/__tests__/useTeamInboxWorkItem.test.ts
new file mode 100644
index 0000000000..6f1bbe50dd
--- /dev/null
+++ b/src/modules/MainApp/TeamInbox/__tests__/useTeamInboxWorkItem.test.ts
@@ -0,0 +1,206 @@
+// @vitest-environment jsdom
+import { act, createElement, useEffect } from "react";
+import { type Root, createRoot } from "react-dom/client";
+import {
+ afterAll,
+ afterEach,
+ beforeAll,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+} from "vitest";
+
+import type { WorkItem } from "@src/types/core/workItem";
+
+import {
+ type TeamInboxWorkItemState,
+ useTeamInboxWorkItem,
+} from "../useTeamInboxWorkItem";
+
+const mocks = vi.hoisted(() => ({
+ readWorkItem: vi.fn(),
+ readProject: vi.fn(),
+ readMembers: vi.fn(),
+ readStandaloneWorkItem: vi.fn(),
+ updateWorkItemPartial: vi.fn(),
+}));
+
+vi.mock("@src/api/http/project", () => ({
+ projectApi: {
+ readWorkItem: mocks.readWorkItem,
+ readProject: mocks.readProject,
+ readMembers: mocks.readMembers,
+ readStandaloneWorkItem: mocks.readStandaloneWorkItem,
+ updateWorkItemPartial: mocks.updateWorkItemPartial,
+ },
+ standaloneWorkItemDataToEnriched: (value: unknown) => value,
+ enrichedWorkItemToUI: (value: unknown) => value,
+}));
+
+vi.mock("@src/hooks/project/useCurrentUserMemberId", () => ({
+ useCurrentUserMemberIds: () => ({ currentUser: null }),
+}));
+
+vi.mock("@src/hooks/logger", () => ({
+ createLogger: () => ({ warn: vi.fn() }),
+}));
+
+vi.mock("@src/modules/ProjectManager/WorkItems/workItemPartialUpdate", () => ({
+ toWorkItemPartialUpdate: (value: unknown) => value,
+}));
+
+const WORK_ITEM: WorkItem = {
+ session_id: "AAA-0001",
+ user_id: "member-1",
+ name: "Inbox item",
+ status: "planned",
+ workItemStatus: "planned",
+ priority: "medium",
+ spec: "Body",
+ assignee: { id: "member-1", name: "Ada" },
+ star: false,
+ target_date: null,
+ created_time: "2026-07-28T00:00:00.000Z",
+ updated_time: "2026-07-28T00:00:00.000Z",
+ linkedSessions: [],
+ todos: [],
+};
+
+let latestState: TeamInboxWorkItemState | null = null;
+
+function Probe() {
+ const state = useTeamInboxWorkItem({
+ kind: "work_item",
+ projectId: "demo",
+ workItemId: "AAA-0001",
+ });
+ useEffect(() => {
+ latestState = state;
+ }, [state]);
+ return null;
+}
+
+function deferred() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise((nextResolve) => {
+ resolve = nextResolve;
+ });
+ return { promise, resolve };
+}
+
+describe("useTeamInboxWorkItem", () => {
+ let container: HTMLDivElement;
+ let root: Root;
+ const actEnvironment = globalThis as typeof globalThis & {
+ IS_REACT_ACT_ENVIRONMENT?: boolean;
+ };
+
+ beforeAll(() => {
+ actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+ });
+
+ beforeEach(() => {
+ latestState = null;
+ vi.clearAllMocks();
+ mocks.readWorkItem.mockResolvedValue(WORK_ITEM);
+ mocks.readProject.mockResolvedValue({
+ slug: "demo",
+ meta: { name: "Demo", linked_repos: [] },
+ });
+ mocks.readMembers.mockResolvedValue({ members: [] });
+ container = document.createElement("div");
+ document.body.appendChild(container);
+ root = createRoot(container);
+ });
+
+ afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+ });
+
+ afterAll(() => {
+ Reflect.deleteProperty(actEnvironment, "IS_REACT_ACT_ENVIRONMENT");
+ });
+
+ it("keeps the Work Item usable when optional project context fails", async () => {
+ mocks.readMembers.mockRejectedValueOnce(new Error("members unavailable"));
+
+ await act(async () => {
+ root.render(createElement(Probe));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ });
+
+ expect(latestState).toMatchObject({
+ status: "ready",
+ workItem: WORK_ITEM,
+ members: [],
+ issue: "context_unavailable",
+ });
+ });
+
+ it("uses the blocking state only when the required Work Item read fails", async () => {
+ mocks.readWorkItem.mockRejectedValueOnce(new Error("item unavailable"));
+
+ await act(async () => {
+ root.render(createElement(Probe));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ });
+
+ expect(latestState).toMatchObject({
+ status: "error",
+ workItem: null,
+ issue: "load_failed",
+ });
+ expect(mocks.readProject).not.toHaveBeenCalled();
+ expect(mocks.readMembers).not.toHaveBeenCalled();
+ });
+
+ it("serializes same-item updates so response order follows user intent", async () => {
+ const first = deferred();
+ const second = deferred();
+ mocks.updateWorkItemPartial
+ .mockImplementationOnce(() => first.promise)
+ .mockImplementationOnce(() => second.promise);
+
+ await act(async () => {
+ root.render(createElement(Probe));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ });
+
+ act(() => {
+ latestState?.updateWorkItem({ workItemStatus: "in_review" });
+ latestState?.updateWorkItem({ priority: "high" });
+ });
+ await Promise.resolve();
+ expect(mocks.updateWorkItemPartial).toHaveBeenCalledTimes(1);
+
+ await act(async () => {
+ first.resolve({
+ ...WORK_ITEM,
+ status: "in_review",
+ workItemStatus: "in_review",
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ expect(mocks.updateWorkItemPartial).toHaveBeenCalledTimes(2);
+
+ await act(async () => {
+ second.resolve({
+ ...WORK_ITEM,
+ status: "in_review",
+ workItemStatus: "in_review",
+ priority: "high",
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(latestState?.workItem).toMatchObject({
+ workItemStatus: "in_review",
+ priority: "high",
+ });
+ });
+});
diff --git a/src/modules/MainApp/TeamInbox/api.ts b/src/modules/MainApp/TeamInbox/api.ts
index db1787615f..8e06deae5a 100644
--- a/src/modules/MainApp/TeamInbox/api.ts
+++ b/src/modules/MainApp/TeamInbox/api.ts
@@ -75,7 +75,7 @@ function mapWireItem(item: TeamInboxWireItem): TeamInboxItem {
const occurredAt = new Date(item.occurredAt).toISOString();
const actor = item.actor ?? {
id: "system",
- displayName: "Team Inbox",
+ displayName: "",
};
if (
diff --git a/src/modules/MainApp/TeamInbox/components/AssignedWorkItemDetail.tsx b/src/modules/MainApp/TeamInbox/components/AssignedWorkItemDetail.tsx
index afcce63421..6a3ef79cc6 100644
--- a/src/modules/MainApp/TeamInbox/components/AssignedWorkItemDetail.tsx
+++ b/src/modules/MainApp/TeamInbox/components/AssignedWorkItemDetail.tsx
@@ -2,11 +2,7 @@ import { ClipboardList, ExternalLink } from "lucide-react";
import React from "react";
import { useTranslation } from "react-i18next";
-import {
- WorkItemContent,
- WorkItemProperties,
-} from "@src/modules/ProjectManager/WorkItems/components";
-import type { WorkItemPropertyFieldKey } from "@src/modules/ProjectManager/WorkItems/components/WorkItemProperties/types";
+import { WorkItemThreadSurface } from "@src/modules/ProjectManager/WorkItems/components";
import { Placeholder } from "@src/modules/shared/layouts/blocks";
import type { Person } from "@src/types/core/shared";
import type { WorkItem } from "@src/types/core/workItem";
@@ -17,22 +13,15 @@ import {
isGitHubIssueStatus,
} from "../domain";
import { useTeamInboxWorkItem } from "../useTeamInboxWorkItem";
+import type { TeamInboxWorkItemIssue } from "../useTeamInboxWorkItem";
import TeamInboxDetailLayout from "./TeamInboxDetailLayout";
-const WORK_ITEM_THREAD_PROPERTY_FIELDS: WorkItemPropertyFieldKey[] = [
- "project",
- "status",
- "priority",
- "assignee",
- "reviewer",
- "date",
-];
-
export interface AssignedWorkItemDetailProps {
item: AssignedWorkItem;
onNavigate?: (intent: TeamInboxNavigationIntent) => void;
onMarkRead?: (item: AssignedWorkItem) => void;
onMarkUnread?: (item: AssignedWorkItem) => void;
+ onWorkItemUpdated?: (workItem: WorkItem) => void;
}
interface AssignedWorkItemThreadProps {
@@ -40,7 +29,9 @@ interface AssignedWorkItemThreadProps {
workItem: WorkItem;
repoPath: string | null;
members: Person[];
- error: string | null;
+ currentUser: Person | null;
+ issueMessage: string | null;
+ issueTone: "warning" | "error" | null;
updateWorkItem: (updates: Partial) => void;
refreshWorkItem: () => void;
onNavigate?: (intent: TeamInboxNavigationIntent) => void;
@@ -51,7 +42,9 @@ const AssignedWorkItemThread: React.FC = ({
workItem,
repoPath,
members,
- error,
+ currentUser,
+ issueMessage,
+ issueTone,
updateWorkItem,
refreshWorkItem,
onNavigate,
@@ -59,41 +52,42 @@ const AssignedWorkItemThread: React.FC = ({
const canUpdate = Boolean(item.target.projectId);
const isGitHubIssue = isGitHubIssueStatus(item.payload.status);
- const properties = canUpdate ? (
-
- {error ? (
+ {issueMessage ? (
- {error}
+ {issueMessage}
) : null}
-
= ({
onNavigate,
onMarkRead,
onMarkUnread,
+ onWorkItemUpdated,
}) => {
const { t } = useTranslation();
const {
workItem,
status,
- error,
+ issue,
repoPath,
members,
+ currentUser,
updateWorkItem,
refreshWorkItem,
- } = useTeamInboxWorkItem(item.target);
+ } = useTeamInboxWorkItem(item.target, onWorkItemUpdated);
+ const issueMessage = ((): string | null => {
+ const keyByIssue: Record = {
+ context_unavailable: "teamInbox.errors.workItemContext",
+ load_failed: "teamInbox.errors.workItemLoad",
+ update_failed: "teamInbox.errors.workItemUpdate",
+ };
+ return issue ? t(keyByIssue[issue]) : null;
+ })();
return (
= ({
workItem={workItem}
repoPath={repoPath}
members={members}
- error={error}
+ currentUser={currentUser}
+ issueMessage={issueMessage}
+ issueTone={
+ issue === "context_unavailable" ? "warning" : issue ? "error" : null
+ }
updateWorkItem={updateWorkItem}
refreshWorkItem={refreshWorkItem}
onNavigate={onNavigate}
@@ -187,7 +195,7 @@ const AssignedWorkItemDetail: React.FC = ({
= ({
label: t("teamInbox.fields.comments"),
value: item.payload.commentCount,
},
- {
- label: t("teamInbox.fields.threadId"),
- value: item.target.threadId,
- },
- {
- label: t("teamInbox.fields.commentId"),
- value: item.target.commentId,
- },
]}
>
@@ -78,9 +70,14 @@ const CommentMentionDetail: React.FC = ({
) : null}
- {item.payload.context ? (
+ {item.payload.threadCommentCount !== undefined ||
+ item.payload.context ? (
- {item.payload.context}
+ {item.payload.threadCommentCount !== undefined
+ ? t("teamInbox.detail.threadComments", {
+ count: item.payload.threadCommentCount,
+ })
+ : item.payload.context}
) : null}
diff --git a/src/modules/MainApp/TeamInbox/components/TeamInboxList.tsx b/src/modules/MainApp/TeamInbox/components/TeamInboxList.tsx
index 308b143266..01437fda6e 100644
--- a/src/modules/MainApp/TeamInbox/components/TeamInboxList.tsx
+++ b/src/modules/MainApp/TeamInbox/components/TeamInboxList.tsx
@@ -89,6 +89,20 @@ const TeamInboxList: React.FC
= ({
[items, recencyAnchorMs]
);
const activeFilterUnread = unreadCounts[filter];
+ const loadMoreAction =
+ hasMore && onLoadMore ? (
+
+
+ {t("teamInbox.loadMore")}
+
+
+ ) : null;
const filterTabs = useMemo(
() => [
{
@@ -224,34 +238,36 @@ const TeamInboxList: React.FC = ({
+ {hasQuery ? (
+
+ ) : (
+
+ )}
+ {loadMoreAction}
+
{groups.map((group) => {
@@ -290,19 +306,7 @@ const TeamInboxList: React.FC = ({
);
})}
- {hasMore && onLoadMore ? (
-
-
- {t("teamInbox.loadMore", { defaultValue: "Load more" })}
-
-
- ) : null}
+ {loadMoreAction}
)}
diff --git a/src/modules/MainApp/TeamInbox/components/TeamInboxRow.tsx b/src/modules/MainApp/TeamInbox/components/TeamInboxRow.tsx
index 1a2bf0f5ed..dc3acdd588 100644
--- a/src/modules/MainApp/TeamInbox/components/TeamInboxRow.tsx
+++ b/src/modules/MainApp/TeamInbox/components/TeamInboxRow.tsx
@@ -19,25 +19,48 @@ export interface TeamInboxRowProps {
onSelect: (item: TeamInboxItem) => void;
}
+function toCompactPreview(content: string): string {
+ return content
+ .replace(/\\[nr]/g, "\n")
+ .replace(/^\s*```[^\n]*$/gm, "")
+ .replace(/!\[([^\]]*)\]\((?:\\.|[^)])*\)/g, "$1")
+ .replace(/\[([^\]]+)\]\((?:\\.|[^)])*\)/g, "$1")
+ .replace(/^\s{0,3}#{1,6}[\t ]+/gm, "")
+ .replace(/^\s{0,3}>[\t ]?/gm, "")
+ .replace(/^\s{0,3}(?:[-+*]|\d+[.)])[\t ]+/gm, "")
+ .replace(/^\s*\[[ xX]\][\t ]+/gm, "")
+ .replace(/(`+)([\s\S]*?)\1/g, "$2")
+ .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, "$2")
+ .replace(/~~(?=\S)([\s\S]*?\S)~~/g, "$1")
+ .replace(/\s+/g, " ")
+ .trim();
+}
+
const TeamInboxRow = forwardRef(
({ item, itemKey, selected, onSelect }, ref) => {
const { t } = useTranslation();
const isMention = item.kind === "comment_mention";
const title = isMention ? item.target.sessionTitle : item.payload.title;
- const summary = useMemo(() => {
- if (item.kind === "comment_mention") return item.payload.commentBody;
- if (item.payload.summary) return item.payload.summary;
+ const { meta, summary } = useMemo(() => {
+ if (item.kind === "comment_mention") {
+ return {
+ meta: item.actor.displayName,
+ summary: toCompactPreview(item.payload.commentBody),
+ };
+ }
const status = t(workItemStatusLabelKey(item.payload.status), {
defaultValue: humanizeToken(item.payload.status),
});
const priority = t(workItemPriorityLabelKey(item.payload.priority), {
defaultValue: humanizeToken(item.payload.priority),
});
- return t("teamInbox.row.assignedSummary", { status, priority });
+ return {
+ meta: `${status} · ${priority}`,
+ summary: item.payload.summary
+ ? toCompactPreview(item.payload.summary)
+ : "",
+ };
}, [item, t]);
- const personName = isMention
- ? item.actor.displayName
- : (item.payload.assigneeName ?? item.payload.assigneeMemberId);
const relativeTime = useMemo(
() => formatRelativeTime(item.occurredAt, "nano"),
[item.occurredAt]
@@ -54,7 +77,10 @@ const TeamInboxRow = forwardRef(
type="button"
role="option"
aria-selected={selected}
- aria-label={`${title}，${readLabel}`}
+ aria-label={t("teamInbox.row.ariaLabel", {
+ title,
+ status: readLabel,
+ })}
tabIndex={selected ? 0 : -1}
data-testid="team-inbox-row"
data-item-kind={item.kind}
@@ -86,11 +112,16 @@ const TeamInboxRow = forwardRef(
{relativeTime}
-
- {summary}
-
-
- {personName}
+ {summary ? (
+
+ {summary}
+
+ ) : null}
+
+ {meta}
diff --git a/src/modules/MainApp/TeamInbox/domain/index.ts b/src/modules/MainApp/TeamInbox/domain/index.ts
index 516b2ffde6..f06ab07eb1 100644
--- a/src/modules/MainApp/TeamInbox/domain/index.ts
+++ b/src/modules/MainApp/TeamInbox/domain/index.ts
@@ -33,6 +33,8 @@ export type {
TeamInboxDataSource,
TeamInboxFilter,
TeamInboxItem,
+ TeamInboxIssue,
+ TeamInboxIssueCode,
TeamInboxNavigationIntent,
TeamInboxPage,
TeamInboxTarget,
diff --git a/src/modules/MainApp/TeamInbox/domain/types.ts b/src/modules/MainApp/TeamInbox/domain/types.ts
index 1a59324a18..a14f39d618 100644
--- a/src/modules/MainApp/TeamInbox/domain/types.ts
+++ b/src/modules/MainApp/TeamInbox/domain/types.ts
@@ -36,6 +36,8 @@ export interface CommentMentionItem extends TeamInboxItemBase {
payload: {
commentBody: string;
context?: string;
+ /** Structured cloud value; presentation localizes it at render time. */
+ threadCommentCount?: number;
commentCount: number;
};
}
@@ -66,6 +68,10 @@ export interface TeamInboxCursor {
export interface TeamInboxPage {
items: TeamInboxItem[];
nextCursor: TeamInboxCursor | null;
+ /** True when this snapshot was synchronously cleared for a new scope. */
+ loading?: boolean;
+ /** Non-fatal or fatal source condition associated with this snapshot. */
+ issue?: TeamInboxIssue | null;
/** Authoritative source totals; absent on lightweight/test data sources. */
unreadCounts?: {
all: number;
@@ -74,6 +80,17 @@ export interface TeamInboxPage {
};
}
+export type TeamInboxIssueCode =
+ | "identity_unresolved"
+ | "load_failed"
+ | "partial_load";
+
+export interface TeamInboxIssue {
+ code: TeamInboxIssueCode;
+ /** Diagnostic detail for logs/support; UI copy is derived from `code`. */
+ detail?: string;
+}
+
export interface ListTeamInboxInput {
cursor?: TeamInboxCursor | null;
limit?: number;
@@ -101,6 +118,11 @@ export interface TeamInboxDataSource {
*/
loadMore?(): Promise;
subscribe?(listener: () => void): () => void;
+ /**
+ * Reconciles a detail-side projection into the canonical list snapshot.
+ * `nextItem = null` removes an item that no longer belongs to this viewer.
+ */
+ reconcileItem?(itemKey: string, nextItem: TeamInboxItem | null): void;
}
export type TeamInboxNavigationIntent =
diff --git a/src/modules/MainApp/TeamInbox/store.ts b/src/modules/MainApp/TeamInbox/store.ts
index dfa6da566b..80d76c5480 100644
--- a/src/modules/MainApp/TeamInbox/store.ts
+++ b/src/modules/MainApp/TeamInbox/store.ts
@@ -1,6 +1,7 @@
import { atom } from "jotai";
import type { TeamInboxItem } from "./domain";
+import type { TeamInboxIssue } from "./domain";
import type { TeamInboxUnreadCounts } from "./domain";
export interface TeamInboxCacheState {
@@ -8,7 +9,7 @@ export interface TeamInboxCacheState {
unreadCount: number;
unreadCounts: TeamInboxUnreadCounts;
loading: boolean;
- error: string | null;
+ issue: TeamInboxIssue | null;
revision: number;
loadedForViewerKey: string | null;
/** True when either the local or cloud source still has a next page. */
@@ -20,7 +21,7 @@ export const teamInboxCacheAtom = atom({
unreadCount: 0,
unreadCounts: { all: 0, mentions: 0, assigned: 0 },
loading: false,
- error: null,
+ issue: null,
revision: 0,
loadedForViewerKey: null,
hasMore: false,
diff --git a/src/modules/MainApp/TeamInbox/teamInboxCoordinator.ts b/src/modules/MainApp/TeamInbox/teamInboxCoordinator.ts
new file mode 100644
index 0000000000..adc50adbb3
--- /dev/null
+++ b/src/modules/MainApp/TeamInbox/teamInboxCoordinator.ts
@@ -0,0 +1,884 @@
+import type { Store } from "jotai/vanilla/store";
+
+import type { MemberEntry } from "@src/api/http/project";
+import type {
+ TeamInboxMention,
+ TeamInboxMentionsPage,
+ TeamInboxReadMutation,
+} from "@src/features/Org2Cloud/teamInboxMentionsClient";
+import {
+ listInitialTeamInboxMentions,
+ listTeamInboxMentions,
+ markAllTeamInboxMentionsRead,
+ setTeamInboxMentionRead,
+} from "@src/features/Org2Cloud/teamInboxMentionsClient";
+
+import {
+ listLocalTeamInboxPage,
+ markAllLocalTeamInboxRead,
+ markLocalTeamInboxItemRead,
+ markLocalTeamInboxItemUnread,
+} from "./api";
+import {
+ dedupeTeamInboxItems,
+ getTeamInboxItemKey,
+ sortTeamInboxItems,
+} from "./domain";
+import type {
+ TeamInboxCursor,
+ TeamInboxFilter,
+ TeamInboxIssue,
+ TeamInboxItem,
+} from "./domain";
+import { teamInboxCacheAtom, teamInboxInvalidationAtom } from "./store";
+
+const MAX_CACHED_TEAM_INBOX_ITEMS = 500;
+const MAX_PENDING_TEAM_INBOX_MUTATIONS = 100;
+
+interface LocalPageResult {
+ page: {
+ items: TeamInboxItem[];
+ nextCursor: TeamInboxCursor | null;
+ };
+ unreadCount: number;
+}
+
+export interface TeamInboxCoordinatorDependencies {
+ listLocalPage(
+ viewerMemberIds: readonly string[],
+ filter: TeamInboxFilter,
+ cursor?: TeamInboxCursor | null
+ ): Promise;
+ listInitialMentions(
+ accessToken: string,
+ orgId: string,
+ limit: number,
+ signal?: AbortSignal
+ ): Promise;
+ listMentions(
+ accessToken: string,
+ orgId: string,
+ cursor: string | null,
+ limit: number,
+ signal?: AbortSignal
+ ): Promise;
+ markLocalRead(
+ viewerMemberIds: readonly string[],
+ itemId: string
+ ): Promise;
+ markLocalUnread(
+ viewerMemberIds: readonly string[],
+ itemId: string
+ ): Promise;
+ markAllLocalRead(
+ viewerMemberIds: readonly string[],
+ filter: TeamInboxFilter
+ ): Promise;
+ setMentionRead(
+ accessToken: string,
+ orgId: string,
+ commentId: string,
+ read: boolean,
+ signal?: AbortSignal
+ ): Promise;
+ markAllMentionsRead(
+ accessToken: string,
+ orgId: string,
+ signal?: AbortSignal
+ ): Promise;
+ now(): string;
+}
+
+export interface TeamInboxCoordinatorScope {
+ key: string;
+ viewerMemberIds: readonly string[];
+ accessToken: string | null;
+ activeCloudOrgId: string | null;
+ members: readonly MemberEntry[];
+ /** Degraded prerequisite reads (for example, a subset of member files). */
+ prerequisiteIssue?: TeamInboxIssue | null;
+}
+
+interface CoordinatorRuntime {
+ scopeKey: string;
+ generation: number;
+ scopeController: AbortController;
+ localCursor: TeamInboxCursor | null;
+ cloudCursor: string | null;
+ refreshPromise: Promise | null;
+ activeRefreshVersion: string | null;
+ desiredRefreshVersion: string | null;
+ queuedRefresh: { scope: TeamInboxCoordinatorScope; version: string } | null;
+ loadMorePromise: Promise | null;
+ mutationTail: Promise;
+ pendingMutations: number;
+ mutationEpoch: number;
+ mutationEpochByItem: Map;
+ invalidationQueued: boolean;
+}
+
+type Settled = { ok: true; value: T } | { ok: false; error: unknown };
+
+function settle(promise: Promise): Promise> {
+ return promise.then(
+ (value) => ({ ok: true, value }),
+ (error: unknown) => ({ ok: false, error })
+ );
+}
+
+function errorDetail(errors: readonly unknown[]): string | undefined {
+ const messages = errors
+ .map((error) => (error instanceof Error ? error.message : String(error)))
+ .filter(Boolean);
+ return messages.length > 0 ? messages.join(" · ") : undefined;
+}
+
+function issueForFailures(
+ failures: readonly unknown[],
+ requestedSourceCount: number
+): TeamInboxIssue | null {
+ if (failures.length === 0) return null;
+ return {
+ code:
+ failures.length >= requestedSourceCount ? "load_failed" : "partial_load",
+ detail: errorDetail(failures),
+ };
+}
+
+function mergeIssues(
+ primary: TeamInboxIssue | null,
+ secondary: TeamInboxIssue | null | undefined
+): TeamInboxIssue | null {
+ if (!primary) return secondary ?? null;
+ if (!secondary) return primary;
+ return {
+ code:
+ primary.code === "load_failed" || secondary.code === "load_failed"
+ ? "load_failed"
+ : primary.code === "identity_unresolved" ||
+ secondary.code === "identity_unresolved"
+ ? "identity_unresolved"
+ : "partial_load",
+ detail: errorDetail([primary.detail, secondary.detail].filter(Boolean)),
+ };
+}
+
+function prerequisiteIssueForScope(
+ scope: TeamInboxCoordinatorScope
+): TeamInboxIssue | null {
+ const identityIssue =
+ scope.viewerMemberIds.length === 0 && scope.members.length > 0
+ ? ({ code: "identity_unresolved" } as const)
+ : null;
+ return mergeIssues(identityIssue, scope.prerequisiteIssue);
+}
+
+function mapMentionsToItems(
+ mentions: readonly TeamInboxMention[],
+ activeCloudOrgId: string
+): TeamInboxItem[] {
+ return mentions.map((mention) => ({
+ id: `cloud-comment:${activeCloudOrgId}:${mention.comment.id}`,
+ kind: "comment_mention" as const,
+ occurredAt: mention.createdAt,
+ readAt: mention.readAt,
+ actor: {
+ id: mention.author.userId,
+ displayName: mention.author.displayName ?? mention.author.userId,
+ },
+ target: {
+ kind: "session_comment" as const,
+ sessionId: mention.session.id,
+ sessionTitle: mention.session.title ?? mention.session.id,
+ commentId: mention.comment.id,
+ threadId: mention.comment.parentId ?? mention.comment.id,
+ anchor: mention.comment.id,
+ },
+ payload: {
+ commentBody: mention.body,
+ commentCount: mention.commentCount,
+ threadCommentCount: mention.threadCount,
+ },
+ }));
+}
+
+function resolveAssigneeDisplayNames(
+ items: readonly TeamInboxItem[],
+ members: readonly MemberEntry[]
+): TeamInboxItem[] {
+ if (members.length === 0) return [...items];
+ const nameById = new Map(members.map((member) => [member.id, member.name]));
+ return items.map((item) => {
+ if (item.kind !== "assigned_work_item") return item;
+ const resolved = nameById.get(item.payload.assigneeMemberId);
+ if (!resolved || resolved === item.payload.assigneeName) return item;
+ return {
+ ...item,
+ payload: { ...item.payload, assigneeName: resolved },
+ };
+ });
+}
+
+function boundedItems(items: readonly TeamInboxItem[]): TeamInboxItem[] {
+ return sortTeamInboxItems(dedupeTeamInboxItems(items)).slice(
+ 0,
+ MAX_CACHED_TEAM_INBOX_ITEMS
+ );
+}
+
+function createRuntime(scopeKey: string): CoordinatorRuntime {
+ return {
+ scopeKey,
+ generation: 0,
+ scopeController: new AbortController(),
+ localCursor: null,
+ cloudCursor: null,
+ refreshPromise: null,
+ activeRefreshVersion: null,
+ desiredRefreshVersion: null,
+ queuedRefresh: null,
+ loadMorePromise: null,
+ mutationTail: Promise.resolve(),
+ pendingMutations: 0,
+ mutationEpoch: 0,
+ mutationEpochByItem: new Map(),
+ invalidationQueued: false,
+ };
+}
+
+/**
+ * Store-scoped Team Inbox coordinator.
+ *
+ * All mounted consumers in one Jotai store share request identity, cursors,
+ * mutation ordering and cancellation. Separate stores receive isolated runtime
+ * state through the WeakMap, while persisted/cache state remains in Jotai.
+ */
+export class TeamInboxCoordinator {
+ private readonly runtimeByStore = new WeakMap();
+
+ constructor(
+ private readonly dependencies: TeamInboxCoordinatorDependencies
+ ) {}
+
+ ensureScope(store: Store, scopeKey: string): CoordinatorRuntime {
+ const currentRuntime = this.runtimeByStore.get(store);
+ if (currentRuntime?.scopeKey === scopeKey) return currentRuntime;
+
+ currentRuntime?.scopeController.abort();
+ const runtime = createRuntime(scopeKey);
+ this.runtimeByStore.set(store, runtime);
+
+ const cache = store.get(teamInboxCacheAtom);
+ if (cache.loadedForViewerKey !== scopeKey) {
+ store.set(teamInboxCacheAtom, {
+ ...cache,
+ items: [],
+ unreadCount: 0,
+ unreadCounts: { all: 0, mentions: 0, assigned: 0 },
+ loading: true,
+ hasMore: false,
+ loadedForViewerKey: null,
+ issue: null,
+ revision: cache.revision + 1,
+ });
+ }
+ return runtime;
+ }
+
+ invalidate(store: Store): void {
+ const runtime = this.runtimeByStore.get(store);
+ if (runtime?.invalidationQueued) return;
+ if (runtime) runtime.invalidationQueued = true;
+ queueMicrotask(() => {
+ const latest = this.runtimeByStore.get(store);
+ if (latest) latest.invalidationQueued = false;
+ store.set(
+ teamInboxInvalidationAtom,
+ store.get(teamInboxInvalidationAtom) + 1
+ );
+ });
+ }
+
+ refresh(
+ store: Store,
+ scope: TeamInboxCoordinatorScope,
+ requestVersion: string
+ ): Promise {
+ const runtime = this.ensureScope(store, scope.key);
+ runtime.desiredRefreshVersion = requestVersion;
+
+ if (runtime.refreshPromise) {
+ if (runtime.activeRefreshVersion !== requestVersion) {
+ runtime.queuedRefresh = { scope, version: requestVersion };
+ }
+ return runtime.refreshPromise;
+ }
+ if (
+ runtime.activeRefreshVersion === requestVersion &&
+ store.get(teamInboxCacheAtom).loadedForViewerKey === scope.key
+ ) {
+ return Promise.resolve();
+ }
+
+ const generation = ++runtime.generation;
+ runtime.activeRefreshVersion = requestVersion;
+ store.set(teamInboxCacheAtom, (current) => ({
+ ...current,
+ loading: true,
+ issue: null,
+ }));
+
+ const canLoadLocal = scope.viewerMemberIds.length > 0;
+ const canLoadCloud = Boolean(scope.accessToken && scope.activeCloudOrgId);
+ if (!canLoadLocal && !canLoadCloud) {
+ runtime.localCursor = null;
+ runtime.cloudCursor = null;
+ store.set(teamInboxCacheAtom, (current) => ({
+ ...current,
+ items: [],
+ unreadCount: 0,
+ unreadCounts: { all: 0, mentions: 0, assigned: 0 },
+ loading: false,
+ hasMore: false,
+ loadedForViewerKey: scope.key,
+ issue: prerequisiteIssueForScope(scope),
+ revision: current.revision + 1,
+ }));
+ return Promise.resolve();
+ }
+
+ const requestedSourceCount = Number(canLoadLocal) + Number(canLoadCloud);
+ const promise = Promise.all([
+ canLoadLocal
+ ? settle(
+ this.dependencies.listLocalPage(scope.viewerMemberIds, "all", null)
+ )
+ : Promise.resolve>({
+ ok: true,
+ value: {
+ page: { items: [], nextCursor: null },
+ unreadCount: 0,
+ },
+ }),
+ canLoadCloud && scope.accessToken && scope.activeCloudOrgId
+ ? settle(
+ this.dependencies.listInitialMentions(
+ scope.accessToken,
+ scope.activeCloudOrgId,
+ 50,
+ runtime.scopeController.signal
+ )
+ )
+ : Promise.resolve>({
+ ok: true,
+ value: { mentions: [], unreadCount: 0 },
+ }),
+ ])
+ .then(([local, cloud]) => {
+ const currentRuntime = this.runtimeByStore.get(store);
+ if (
+ currentRuntime !== runtime ||
+ generation !== runtime.generation ||
+ runtime.scopeController.signal.aborted ||
+ runtime.desiredRefreshVersion !== requestVersion
+ ) {
+ return;
+ }
+
+ const previous = store.get(teamInboxCacheAtom);
+ const sameScope = previous.loadedForViewerKey === scope.key;
+ const previousLocal = sameScope
+ ? previous.items.filter((item) => item.kind === "assigned_work_item")
+ : [];
+ const previousCloud = sameScope
+ ? previous.items.filter((item) => item.kind === "comment_mention")
+ : [];
+ const failures = [
+ ...(local.ok ? [] : [local.error]),
+ ...(cloud.ok ? [] : [cloud.error]),
+ ];
+
+ const localItems = local.ok ? local.value.page.items : previousLocal;
+ const cloudItems = cloud.ok
+ ? mapMentionsToItems(
+ cloud.value.mentions,
+ scope.activeCloudOrgId ?? ""
+ )
+ : previousCloud;
+ const localUnread = local.ok
+ ? local.value.unreadCount
+ : sameScope
+ ? previous.unreadCounts.assigned
+ : 0;
+ const cloudUnread = cloud.ok
+ ? cloud.value.unreadCount
+ : sameScope
+ ? previous.unreadCounts.mentions
+ : 0;
+
+ if (local.ok) runtime.localCursor = local.value.page.nextCursor;
+ if (cloud.ok) runtime.cloudCursor = cloud.value.nextCursor ?? null;
+
+ const items = boundedItems(
+ resolveAssigneeDisplayNames(
+ [...cloudItems, ...localItems],
+ scope.members
+ )
+ );
+ if (items.length >= MAX_CACHED_TEAM_INBOX_ITEMS) {
+ runtime.localCursor = null;
+ runtime.cloudCursor = null;
+ }
+ store.set(teamInboxCacheAtom, (current) => ({
+ ...current,
+ items,
+ unreadCount: localUnread + cloudUnread,
+ unreadCounts: {
+ all: localUnread + cloudUnread,
+ mentions: cloudUnread,
+ assigned: localUnread,
+ },
+ loading: false,
+ issue: mergeIssues(
+ issueForFailures(failures, requestedSourceCount),
+ prerequisiteIssueForScope(scope)
+ ),
+ loadedForViewerKey: scope.key,
+ hasMore: Boolean(runtime.localCursor || runtime.cloudCursor),
+ revision: current.revision + 1,
+ }));
+ })
+ .finally(() => {
+ if (runtime.refreshPromise === promise) {
+ runtime.refreshPromise = null;
+ }
+ const queued = runtime.queuedRefresh;
+ runtime.queuedRefresh = null;
+ if (
+ queued &&
+ this.runtimeByStore.get(store) === runtime &&
+ !runtime.scopeController.signal.aborted
+ ) {
+ void this.refresh(store, queued.scope, queued.version);
+ }
+ });
+ runtime.refreshPromise = promise;
+ return promise;
+ }
+
+ loadMore(store: Store, scope: TeamInboxCoordinatorScope): Promise {
+ const runtime = this.ensureScope(store, scope.key);
+ if (runtime.loadMorePromise) return runtime.loadMorePromise;
+ const localCursor = runtime.localCursor;
+ const cloudCursor = runtime.cloudCursor;
+ if (!localCursor && !cloudCursor) return Promise.resolve();
+
+ const generation = runtime.generation;
+ const requestedSourceCount =
+ Number(Boolean(localCursor)) + Number(Boolean(cloudCursor));
+ const promise = Promise.all([
+ localCursor
+ ? settle(
+ this.dependencies.listLocalPage(
+ scope.viewerMemberIds,
+ "all",
+ localCursor
+ )
+ )
+ : Promise.resolve>({
+ ok: true,
+ value: {
+ page: { items: [], nextCursor: null },
+ unreadCount: store.get(teamInboxCacheAtom).unreadCounts.assigned,
+ },
+ }),
+ cloudCursor && scope.accessToken && scope.activeCloudOrgId
+ ? settle(
+ this.dependencies.listMentions(
+ scope.accessToken,
+ scope.activeCloudOrgId,
+ cloudCursor,
+ 50,
+ runtime.scopeController.signal
+ )
+ )
+ : Promise.resolve>({
+ ok: true,
+ value: {
+ mentions: [],
+ unreadCount: store.get(teamInboxCacheAtom).unreadCounts.mentions,
+ },
+ }),
+ ])
+ .then(([local, cloud]) => {
+ if (
+ this.runtimeByStore.get(store) !== runtime ||
+ generation !== runtime.generation ||
+ runtime.scopeController.signal.aborted
+ ) {
+ return;
+ }
+ const failures = [
+ ...(local.ok ? [] : [local.error]),
+ ...(cloud.ok ? [] : [cloud.error]),
+ ];
+ if (localCursor && local.ok) {
+ runtime.localCursor = local.value.page.nextCursor;
+ }
+ if (cloudCursor && cloud.ok) {
+ runtime.cloudCursor = cloud.value.nextCursor ?? null;
+ }
+ const appended = resolveAssigneeDisplayNames(
+ [
+ ...(cloud.ok
+ ? mapMentionsToItems(
+ cloud.value.mentions,
+ scope.activeCloudOrgId ?? ""
+ )
+ : []),
+ ...(local.ok ? local.value.page.items : []),
+ ],
+ scope.members
+ );
+ store.set(teamInboxCacheAtom, (current) => {
+ const items = boundedItems([...current.items, ...appended]);
+ if (items.length >= MAX_CACHED_TEAM_INBOX_ITEMS) {
+ runtime.localCursor = null;
+ runtime.cloudCursor = null;
+ }
+ const assigned = local.ok
+ ? local.value.unreadCount
+ : current.unreadCounts.assigned;
+ const mentions = cloud.ok
+ ? cloud.value.unreadCount
+ : current.unreadCounts.mentions;
+ return {
+ ...current,
+ items,
+ unreadCount: assigned + mentions,
+ unreadCounts: {
+ all: assigned + mentions,
+ assigned,
+ mentions,
+ },
+ issue: mergeIssues(
+ issueForFailures(failures, requestedSourceCount),
+ prerequisiteIssueForScope(scope)
+ ),
+ hasMore: Boolean(runtime.localCursor || runtime.cloudCursor),
+ revision: current.revision + 1,
+ };
+ });
+ if (failures.length >= requestedSourceCount) {
+ throw new Error(errorDetail(failures) ?? "Team Inbox load failed");
+ }
+ })
+ .finally(() => {
+ if (runtime.loadMorePromise === promise) {
+ runtime.loadMorePromise = null;
+ }
+ });
+ runtime.loadMorePromise = promise;
+ return promise;
+ }
+
+ markRead(
+ store: Store,
+ scope: TeamInboxCoordinatorScope,
+ item: TeamInboxItem
+ ): Promise {
+ return this.setReadState(store, scope, item, true);
+ }
+
+ markUnread(
+ store: Store,
+ scope: TeamInboxCoordinatorScope,
+ item: TeamInboxItem
+ ): Promise {
+ return this.setReadState(store, scope, item, false);
+ }
+
+ private setReadState(
+ store: Store,
+ scope: TeamInboxCoordinatorScope,
+ item: TeamInboxItem,
+ read: boolean
+ ): Promise {
+ const runtime = this.ensureScope(store, scope.key);
+ const itemKey = getTeamInboxItemKey(item);
+ const epoch = ++runtime.mutationEpoch;
+ runtime.mutationEpochByItem.set(itemKey, epoch);
+ this.patchReadState(
+ store,
+ scope.key,
+ itemKey,
+ read ? this.dependencies.now() : null
+ );
+
+ return this.enqueueMutation(runtime, async () => {
+ try {
+ let cloudResult: TeamInboxReadMutation | null = null;
+ if (item.kind === "comment_mention") {
+ if (!scope.accessToken || !scope.activeCloudOrgId) {
+ throw new Error("Cloud identity is unavailable");
+ }
+ cloudResult = await this.dependencies.setMentionRead(
+ scope.accessToken,
+ scope.activeCloudOrgId,
+ item.target.commentId,
+ read,
+ runtime.scopeController.signal
+ );
+ } else {
+ const updated = read
+ ? await this.dependencies.markLocalRead(
+ scope.viewerMemberIds,
+ item.id
+ )
+ : await this.dependencies.markLocalUnread(
+ scope.viewerMemberIds,
+ item.id
+ );
+ if (!updated)
+ throw new Error("Assigned Work Item is no longer visible");
+ }
+ if (
+ this.runtimeByStore.get(store) !== runtime ||
+ runtime.scopeController.signal.aborted ||
+ runtime.mutationEpochByItem.get(itemKey) !== epoch
+ ) {
+ return;
+ }
+ if (cloudResult) {
+ const authoritativeReadAt = read
+ ? (cloudResult.readAt ?? this.dependencies.now())
+ : null;
+ this.patchReadState(
+ store,
+ scope.key,
+ itemKey,
+ authoritativeReadAt,
+ cloudResult.unreadCount
+ );
+ }
+ } catch (error) {
+ if (
+ this.runtimeByStore.get(store) === runtime &&
+ !runtime.scopeController.signal.aborted &&
+ runtime.mutationEpochByItem.get(itemKey) === epoch
+ ) {
+ this.patchReadState(
+ store,
+ scope.key,
+ itemKey,
+ read ? null : item.readAt
+ );
+ }
+ throw error;
+ } finally {
+ if (runtime.mutationEpochByItem.get(itemKey) === epoch) {
+ runtime.mutationEpochByItem.delete(itemKey);
+ }
+ }
+ });
+ }
+
+ markAllRead(
+ store: Store,
+ scope: TeamInboxCoordinatorScope,
+ filter: TeamInboxFilter
+ ): Promise {
+ const runtime = this.ensureScope(store, scope.key);
+ return this.enqueueMutation(runtime, async () => {
+ const includeAssigned = filter === "all" || filter === "assigned";
+ const includeMentions = filter === "all" || filter === "mentions";
+ const before = store.get(teamInboxCacheAtom);
+ const [local, cloud] = await Promise.all([
+ includeAssigned && before.unreadCounts.assigned > 0
+ ? settle(
+ this.dependencies.markAllLocalRead(
+ scope.viewerMemberIds,
+ "assigned"
+ )
+ )
+ : Promise.resolve>({ ok: true, value: 0 }),
+ includeMentions && before.unreadCounts.mentions > 0
+ ? scope.accessToken && scope.activeCloudOrgId
+ ? settle(
+ this.dependencies.markAllMentionsRead(
+ scope.accessToken,
+ scope.activeCloudOrgId,
+ runtime.scopeController.signal
+ )
+ )
+ : Promise.resolve>({
+ ok: false,
+ error: new Error("Cloud identity is unavailable"),
+ })
+ : Promise.resolve>({
+ ok: true,
+ value: { readAt: null, unreadCount: 0 },
+ }),
+ ]);
+ if (
+ this.runtimeByStore.get(store) !== runtime ||
+ runtime.scopeController.signal.aborted
+ ) {
+ return;
+ }
+ const readAt = cloud.ok
+ ? (cloud.value.readAt ?? this.dependencies.now())
+ : this.dependencies.now();
+ store.set(teamInboxCacheAtom, (current) => {
+ const assigned =
+ includeAssigned && local.ok ? 0 : current.unreadCounts.assigned;
+ const mentions =
+ includeMentions && cloud.ok
+ ? cloud.value.unreadCount
+ : current.unreadCounts.mentions;
+ return {
+ ...current,
+ items: current.items.map((candidate) => {
+ const shouldMark =
+ (includeAssigned &&
+ local.ok &&
+ candidate.kind === "assigned_work_item") ||
+ (includeMentions &&
+ cloud.ok &&
+ candidate.kind === "comment_mention");
+ return shouldMark ? { ...candidate, readAt } : candidate;
+ }),
+ unreadCount: assigned + mentions,
+ unreadCounts: { all: assigned + mentions, assigned, mentions },
+ revision: current.revision + 1,
+ };
+ });
+ const failures = [
+ ...(local.ok ? [] : [local.error]),
+ ...(cloud.ok ? [] : [cloud.error]),
+ ];
+ if (failures.length > 0) {
+ throw new Error(errorDetail(failures) ?? "Team Inbox update failed");
+ }
+ });
+ }
+
+ reconcileItem(
+ store: Store,
+ scopeKey: string,
+ itemKey: string,
+ nextItem: TeamInboxItem | null
+ ): void {
+ store.set(teamInboxCacheAtom, (current) => {
+ if (current.loadedForViewerKey !== scopeKey) return current;
+ const previousItem = current.items.find(
+ (candidate) => getTeamInboxItemKey(candidate) === itemKey
+ );
+ const nextItems = current.items.flatMap((candidate) =>
+ getTeamInboxItemKey(candidate) === itemKey
+ ? nextItem
+ ? [nextItem]
+ : []
+ : [candidate]
+ );
+ const previousUnread = previousItem?.readAt === null ? 1 : 0;
+ const nextUnread = nextItem?.readAt === null ? 1 : 0;
+ const unreadDelta = nextUnread - previousUnread;
+ const assigned =
+ previousItem?.kind === "assigned_work_item" ||
+ nextItem?.kind === "assigned_work_item"
+ ? Math.max(0, current.unreadCounts.assigned + unreadDelta)
+ : current.unreadCounts.assigned;
+ const mentions =
+ previousItem?.kind === "comment_mention" ||
+ nextItem?.kind === "comment_mention"
+ ? Math.max(0, current.unreadCounts.mentions + unreadDelta)
+ : current.unreadCounts.mentions;
+ return {
+ ...current,
+ items: boundedItems(nextItems),
+ unreadCount: assigned + mentions,
+ unreadCounts: { all: assigned + mentions, assigned, mentions },
+ revision: current.revision + 1,
+ };
+ });
+ }
+
+ private enqueueMutation(
+ runtime: CoordinatorRuntime,
+ operation: () => Promise
+ ): Promise {
+ if (runtime.pendingMutations >= MAX_PENDING_TEAM_INBOX_MUTATIONS) {
+ return Promise.reject(new Error("Too many pending Team Inbox updates"));
+ }
+ runtime.pendingMutations += 1;
+ const run = async (): Promise => {
+ try {
+ return await operation();
+ } finally {
+ runtime.pendingMutations = Math.max(0, runtime.pendingMutations - 1);
+ }
+ };
+ const result = runtime.mutationTail.then(run, run);
+ runtime.mutationTail = result.then(
+ () => undefined,
+ () => undefined
+ );
+ return result;
+ }
+
+ private patchReadState(
+ store: Store,
+ scopeKey: string,
+ itemKey: string,
+ readAt: string | null,
+ authoritativeMentionUnread?: number
+ ): void {
+ store.set(teamInboxCacheAtom, (current) => {
+ if (current.loadedForViewerKey !== scopeKey) return current;
+ const candidate = current.items.find(
+ (item) => getTeamInboxItemKey(item) === itemKey
+ );
+ if (!candidate) return current;
+ const wasUnread = candidate.readAt === null;
+ const willBeUnread = readAt === null;
+ const delta = Number(willBeUnread) - Number(wasUnread);
+ const assigned =
+ candidate.kind === "assigned_work_item"
+ ? Math.max(0, current.unreadCounts.assigned + delta)
+ : current.unreadCounts.assigned;
+ const mentions =
+ candidate.kind === "comment_mention"
+ ? (authoritativeMentionUnread ??
+ Math.max(0, current.unreadCounts.mentions + delta))
+ : current.unreadCounts.mentions;
+ return {
+ ...current,
+ items: current.items.map((item) =>
+ getTeamInboxItemKey(item) === itemKey ? { ...item, readAt } : item
+ ),
+ unreadCount: assigned + mentions,
+ unreadCounts: { all: assigned + mentions, assigned, mentions },
+ revision: current.revision + 1,
+ };
+ });
+ }
+}
+
+const productionDependencies: TeamInboxCoordinatorDependencies = {
+ listLocalPage: listLocalTeamInboxPage,
+ listInitialMentions: listInitialTeamInboxMentions,
+ listMentions: listTeamInboxMentions,
+ markLocalRead: markLocalTeamInboxItemRead,
+ markLocalUnread: markLocalTeamInboxItemUnread,
+ markAllLocalRead: markAllLocalTeamInboxRead,
+ setMentionRead: setTeamInboxMentionRead,
+ markAllMentionsRead: markAllTeamInboxMentionsRead,
+ now: () => new Date().toISOString(),
+};
+
+export const teamInboxCoordinator = new TeamInboxCoordinator(
+ productionDependencies
+);
+
+export const TEAM_INBOX_CACHE_LIMIT = MAX_CACHED_TEAM_INBOX_ITEMS;
diff --git a/src/modules/MainApp/TeamInbox/useTeamInboxDataSource.ts b/src/modules/MainApp/TeamInbox/useTeamInboxDataSource.ts
index 00be22929f..5f909fa5f8 100644
--- a/src/modules/MainApp/TeamInbox/useTeamInboxDataSource.ts
+++ b/src/modules/MainApp/TeamInbox/useTeamInboxDataSource.ts
@@ -1,12 +1,5 @@
-import { useAtomValue, useSetAtom } from "jotai";
-import {
- useCallback,
- useEffect,
- useLayoutEffect,
- useMemo,
- useRef,
- useState,
-} from "react";
+import { useAtomValue, useStore } from "jotai";
+import { useEffect, useLayoutEffect, useMemo, useState } from "react";
import { invalidateProjectCache, projectApi } from "@src/api/http/project";
import type { MemberEntry } from "@src/api/http/project";
@@ -19,131 +12,92 @@ import {
orgCommentsKey,
} from "@src/features/Org2Cloud/org2CloudCommentsBus";
import { sidebarActiveCloudOrgIdAtom } from "@src/features/Org2Cloud/org2CloudOrgsAtom";
-import {
- type TeamInboxMention,
- listInitialTeamInboxMentions,
- listTeamInboxMentions,
- markAllTeamInboxMentionsRead,
- setTeamInboxMentionRead,
-} from "@src/features/Org2Cloud/teamInboxMentionsClient";
+import { createLogger } from "@src/hooks/logger";
import { useProjectDataChanged } from "@src/hooks/project";
import { useCurrentUserMemberIds } from "@src/hooks/project/useCurrentUserMemberId";
-import {
- listLocalTeamInboxPage,
- markAllLocalTeamInboxRead,
- markLocalTeamInboxItemRead,
- markLocalTeamInboxItemUnread,
-} from "./api";
-import { dedupeTeamInboxItems } from "./domain";
import type {
- TeamInboxCursor,
TeamInboxDataSource,
TeamInboxFilter,
+ TeamInboxIssue,
TeamInboxItem,
} from "./domain";
+import { teamInboxCacheAtom, teamInboxInvalidationAtom } from "./store";
import {
- invalidateTeamInboxAtom,
- teamInboxCacheAtom,
- teamInboxInvalidationAtom,
-} from "./store";
+ type TeamInboxCoordinatorScope,
+ teamInboxCoordinator,
+} from "./teamInboxCoordinator";
-const listeners = new Set<() => void>();
-const MAX_PENDING_TEAM_INBOX_MUTATIONS = 100;
-let membersRequest: Promise | null = null;
-let inboxRequest: {
- key: string;
- promise: Promise<{
- mentionItems: TeamInboxItem[];
- localItems: TeamInboxItem[];
- localUnread: number;
- cloudUnread: number;
- localNextCursor: TeamInboxCursor | null;
- cloudNextCursor: string | null;
- }>;
-} | null = null;
+const log = createLogger("TeamInboxDataSource");
+const MEMBER_READ_CONCURRENCY = 8;
-const EMPTY_CLOUD_MENTION_PAGE = {
- mentions: [],
- nextCursor: undefined,
- unreadCount: 0,
-} as const;
-
-function notifyTeamInboxListeners(): void {
- for (const listener of listeners) listener();
+interface MemberSnapshot {
+ members: MemberEntry[];
+ issue: TeamInboxIssue | null;
}
-/**
- * Maps the server-authoritative cloud mention projection into Team Inbox
- * items. Shared by initial load and pagination so both paths stay identical.
- */
-function mapMentionsToItems(
- mentions: readonly TeamInboxMention[],
- activeCloudOrgId: string
-): TeamInboxItem[] {
- return mentions.map((mention) => {
- const itemId = `cloud-comment:${activeCloudOrgId}:${mention.comment.id}`;
- return {
- id: itemId,
- kind: "comment_mention" as const,
- occurredAt: mention.createdAt,
- readAt: mention.readAt,
- actor: {
- id: mention.author.userId,
- displayName: mention.author.displayName ?? "Team member",
- },
- target: {
- kind: "session_comment" as const,
- sessionId: mention.session.id,
- sessionTitle: mention.session.title ?? "Session",
- commentId: mention.comment.id,
- threadId: mention.comment.parentId ?? mention.comment.id,
- anchor: mention.comment.id,
- },
- payload: {
- commentBody: mention.body,
- commentCount: mention.commentCount,
- context: `${mention.threadCount} thread comments`,
- },
- };
- });
-}
+const EMPTY_MEMBER_SNAPSHOT: MemberSnapshot = {
+ members: [],
+ issue: null,
+};
-/**
- * Resolves each assigned item's display name from its stable `assigneeMemberId`
- * into the optional `assigneeName` field. When the member cannot be resolved the
- * name is left unset and consumers fall back to the id, so a row never renders
- * blank.
- */
-function resolveAssigneeDisplayNames(
- items: readonly TeamInboxItem[],
- members: readonly MemberEntry[]
-): TeamInboxItem[] {
- if (members.length === 0) return [...items];
- const nameById = new Map(members.map((member) => [member.id, member.name]));
- return items.map((item) => {
- if (item.kind !== "assigned_work_item") return item;
- const resolved = nameById.get(item.payload.assigneeMemberId);
- if (!resolved || resolved === item.payload.assigneeName) return item;
- return {
- ...item,
- payload: { ...item.payload, assigneeName: resolved },
- };
- });
-}
+let membersRequest: Promise | null = null;
-async function readAllProjectMembers(): Promise {
+async function readAllProjectMembers(): Promise {
if (membersRequest) return membersRequest;
membersRequest = (async () => {
const projects = await projectApi.readProjects();
- const memberFiles = await Promise.all(
- projects.map((project) => projectApi.readMembers(project.slug))
- );
+ if (projects.length === 0) return EMPTY_MEMBER_SNAPSHOT;
+
+ const memberFiles: MemberEntry[][] = [];
+ const failures: unknown[] = [];
+ let nextIndex = 0;
+ const workerCount = Math.min(MEMBER_READ_CONCURRENCY, projects.length);
+ const workers = Array.from({ length: workerCount }, async () => {
+ while (nextIndex < projects.length) {
+ const index = nextIndex;
+ nextIndex += 1;
+ const project = projects[index];
+ try {
+ const file = await projectApi.readMembers(project.slug);
+ memberFiles.push(file.members);
+ } catch (error) {
+ failures.push(error);
+ }
+ }
+ });
+ await Promise.all(workers);
+ if (memberFiles.length === 0 && failures.length > 0) {
+ throw failures[0];
+ }
+ if (failures.length > 0) {
+ log.warn(
+ `Skipped ${failures.length} project member file(s) while resolving Team Inbox identity`
+ );
+ }
+
const members = new Map