Files
PaperClipAI/ui/src/pages/Inbox.tsx
T
DottaandClaude Opus 5.5 87d363a5c0 perf(ui): reveal a returning Mine visit from the saved cache (#20594)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - The Mine inbox is the board's main list of work for one person; the
app saves its query cache in `localStorage` so a returning visit can
paint from it
> - On a hard load the saved cache gave no benefit: Mine restored its
rows but still held them until the first approvals, join-request and
dismissal reads answered, because those items sort in among task rows by
time and a late one would push rows down (#20407)
> - Those three reads were not saved, so every returning visit waited on
the network for items it showed a minute before
> - This pull request saves what Mine showed from those reads, as one
record per user and company, and lets it answer the wait on a returning
visit while every read refreshes in the background
> - The benefit is that a returning visit shows its rows with no API
response at all; the first visit keeps its bounded wait unchanged

## Linked Issues or Issue Description

**What happened?**
A returning hard load of `/:companyPrefix/issues?view=mine` with the
saved cache present (`paperclip:query-cache:v1:<user>:<company>`) showed
rows no sooner than with the cache cleared. On the hosted staging
instance, rows appeared about 40 ms after `GET
/companies/:id/join-requests?status=pending_approval` returned in 7 of
10 runs.

**Steps to reproduce**
1. Open Mine once so the app saves its query cache.
2. Delay API responses (for example 300 ms) and reload.
3. Rows appear only after the approvals and join-request reads answer.

**Expected behavior**
Rows show from the saved cache at once. The reads refresh in the
background.

Related: #20407 (kept approvals and join requests in the reveal gate),
#20408 and #20419 (Mine snapshot and its perf guard), #20591 (removes
the second wave of reads; merged), #20592 (task chat preload; merged).

## What Changed

- `ui/src/lib/inbox-mine-reveal-sources.ts` (new): the record `["inbox",
companyId, "mine-reveal-sources", userId]` holds the approvals visible
in Mine, the pending join requests, and the dismissals of those items
and of Mine's failed runs. A record over 256 KB is replaced by an empty
`incomplete` record that never answers the wait. `readMineRevealSources`
accepts a record only for the same user and company.
- `ui/src/lib/persisted-query-cache.ts`: the saved cache keeps that
record per user and company, only when its data names the same user and
company as its key.
- `ui/src/pages/Inbox.tsx`:
- Mine writes the record once approvals, join requests and dismissals
all have server answers.
- On a returning visit with a restored Mine snapshot, the saved
approvals, join requests and dismissals stand in while their reads are
pending, and after a transient failure. A refusal (401/403/404) or a
server answer replaces them. The first-attempt wait is skipped only when
saved values stand in; the first visit is unchanged.
- Selection fix: the selected row's key is recorded only when the
selection moves. Before, every list change recorded the row now at the
old index before the re-anchor ran, so a row inserted above the
selection (a late approval, or any live insert) moved the selection to
another row.
- `ui/src/hooks/useInboxBadge.ts`: `useInboxDismissals` takes an
optional saved `fallback` and returns `hasServerData`. Other callers are
unchanged.
- Tests:
- `Inbox.test.tsx`: a returning visit reveals rows and the saved
approval while the reads are pending, then keeps selection on the same
row when a newer approval arrives above it; a transient failure keeps
the saved approval and a 403 drops it; a record stamped for another user
is ignored and the page waits as a first visit does.
- `inbox-mine-reveal-sources.test.ts`: projection, size limit,
user/company checks, persistence scope.
- `persisted-query-cache.test.ts`: the record round-trips for the same
user, restores as invalidated, and another user's record is not saved.
- `useInboxDismissals.test.tsx`: fallback while pending, after a
transient failure, dropped after a refusal, and no fallback.
- `tests/perf/collections/mine-returning-visit.spec.ts` +
`returning-visit-fixture.ts`: production-build browser checks and the
timing case; README updated.

## Verification

- `cd ui && pnpm exec vitest run src/pages src/lib src/hooks
src/components/coordinator`: 453 files, 5574 tests pass.
- Browser checks on a disposable local instance (production UI build,
`local_trusted`, embedded PostgreSQL, Chromium headless, 1440×900):
`PAPERCLIP_COLLECTION_PERF_BASE_URL=http://127.0.0.1:<port> pnpm exec
playwright test --config tests/perf/collections/playwright.config.ts
mine-returning-visit.spec.ts`
- With every read of the company held, task rows and saved approvals
show and no company read has answered. Fails on `master`, passes here.
- An approval dismissed after the cache was saved stands in, then leaves
when the reads answer. Fails on `master` (no saved approvals), passes
here.
- Another company's Mine never shows the saved company's rows. Passes on
both.
- Timing (5 fresh contexts per arm, alternating saved/cleared, every API
response +300 ms, same instance and fixture, host load average about
20). "Responses before rows" counts API responses that finished before
the first row:

| Build | Saved cache: median (range) | Responses before rows | Cleared
cache: median (range) |
  | --- | --- | --- | --- |
| `master` (`99edcd28a7`) | 1028 ms (906–3011) | 16–19 | 1502 ms
(1423–1592) |
  | This PR | 625 ms (589–672) | 0 | 1632 ms (1359–1692) |
  | This PR + #20591 | 625 ms (604–671) | 0 | 1495 ms (1398–1585) |

Saved cache: difference of medians 403 ms. The remaining 625 ms is
JavaScript download and route-chunk loading in a fresh browser context;
no API response precedes the rows. Cleared cache: no change is claimed;
the spread overlaps.
- Existing collection specs on this build: `parent-context.spec.ts`
passes; `startup-regressions.spec.ts` has 4 failures (partial
failure/context error and two 429 cases) that fail the same way on the
`master` build. `mine-workspaces.spec.ts` was not run (needs a database
URL for its fixture).
- Review follow-up (9da56b5515), each with a red/green test that fails
on the previous head:
- Once a saved record exists, each source's answer replaces its part at
once and a refusal (401/403/404) empties it, without waiting for the
other reads, so a reload never shows refused join requests or approvals.
- The selected row's key is also recorded when the recorded row has left
the list, so a new item arriving above the fallback row never becomes
the selection or the archive target.
- An optimistic dismissal and its rollback start from the saved
dismissals that stand in, not from an empty list.
After the rebase onto `origin/master`: `cd ui && pnpm exec vitest run
src/pages src/lib src/hooks src/context src/components/coordinator`
passes (a first run under host load average ~35 had 4 timeouts and two
files missing new dependencies; after `agent-preflight` the affected
files pass, 223 tests).
- `pnpm check:token-gates`: clean. `pnpm verify` selected broader
coverage (exit 2, perf fixture is a global CI input); required CI
supplies it.
- Not run: the hosted staging page, the full local Vitest suite.

## Risks

- Saved approvals can be stale until the read answers (or after a
transient failure). A stale approval shows briefly and its actions go to
the server, which answers with the current state. A 401/403/404 drops
the saved values.
- The record holds approval payloads and join requests for the signed-in
user's company in `localStorage`. It uses the saved cache's existing
projection (secret-like fields removed), the same per-user revocation on
sign-out, and a 256 KB limit.
- #20591 is merged, so this branch (rebased on it) gets one read of each
shell request. Without it, a returning visit still reconnects the live
socket when the session is verified; because rows now reveal sooner,
that reconnect refetches more reads (here: session, health, company list
and agents twice). With both, every shell read runs once.
- Relation to #20592 (task chat preload): both edit
`ui/src/pages/Inbox.tsx` in different places and merge cleanly in either
order (checked with `git merge-tree`). This PR does not preload
anything. #20592 starts its chat preload when `allLoaded` turns true;
with this PR that happens sooner on a returning visit, while the reads
still refresh in the background, so its preload overlaps that refresh.
#20592 is merged and this branch is rebased on it with no conflicts.
- The selection change affects every Inbox tab: the key is recorded when
the selection moves, not on every list change. Archive and removal still
clamp as before.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, via Claude Code with
tool use (shell, file edits, Playwright). Standard context window,
reasoning enabled.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 21:49:17 -06:00

3679 lines
158 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { errorCodes, isTransientError } from "@/api/errors";
import { useQueryView } from "@/components/QueryView";
import { useCoordinatorPresentation } from "@/components/coordinator/CoordinatorPresentation";
import { useWarmTaskDetailCode } from "@/hooks/useWarmTaskDetailCode";
import { topTaskRefs, usePreloadTaskChats } from "../hooks/usePreloadTaskChats";
import { describeError } from "../api/errors";
import { useIssueRowDetails } from "../hooks/useIssueRowDetails";
import { IssueRowDetailsNotice } from "../components/IssueRowDetailsNotice";
import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from "react";
import { Link, useLocation, useNavigate } from "@/lib/router";
import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
import { deriveOriginatingActor, INBOX_MINE_ISSUE_STATUS_FILTER, isHeartbeatRunVisibleInMine } from "@paperclipai/shared";
import { usePublishSharedQueryData, useSharedPollingQuery } from "@/hooks/useSharedPolling";
import { approvalsApi } from "../api/approvals";
import { accessApi } from "../api/access";
import { authApi } from "../api/auth";
import { ApiError } from "../api/client";
import { dashboardApi } from "../api/dashboard";
import { executionWorkspacesApi } from "../api/execution-workspaces";
import { issuesApi } from "../api/issues";
import { useSecondTick } from "../hooks/useSecondTick";
import { taskRetryNotStartedReason } from "../hooks/useTaskRetry";
import { agentsApi } from "../api/agents";
import { heartbeatsApi } from "../api/heartbeats";
import { instanceSettingsApi } from "../api/instanceSettings";
import { projectsApi } from "../api/projects";
import {
BLOCKED_GROUP_OPTIONS,
BLOCKED_SORT_OPTIONS,
type BlockedInboxGroupBy,
type BlockedInboxSort,
} from "../lib/blockedInbox";
import { useCompany } from "../context/CompanyContext";
import { useToastActions } from "../context/ToastContext";
import { useBreadcrumbs } from "../context/BreadcrumbContext";
import { useSidebar } from "../context/SidebarContext";
import { queryKeys } from "../lib/queryKeys";
import { buildMineRevealSources, mineRevealSourcesQueryKey, readMineRevealSources, type MineRevealSources } from "../lib/inbox-mine-reveal-sources";
import { useDialogActions } from "../context/DialogContext";
import { useIssueExternalObjectSummaries } from "../hooks/useIssueExternalObjects";
import {
applyIssueFilters,
countActiveIssueFilters,
defaultIssueFilterState,
normalizeIssueFilterState,
type IssueFilterState,
} from "../lib/issue-filters";
import { collectLiveIssueIds, collectSubtreeLiveCounts, issueWaitingOf } from "../lib/liveIssueIds";
import { formatAssigneeUserLabel } from "../lib/assignees";
import { buildCompanyUserLabelMap, buildCompanyUserProfileMap } from "../lib/company-members";
import {
armIssueDetailInboxQuickArchive,
createIssueDetailLocationState,
createIssueDetailPath,
rememberIssueDetailLocationState,
withIssueDetailHeaderSeed,
} from "../lib/issueDetailBreadcrumb";
import { prefetchIssueDetailForNavigation } from "../lib/issueDetailCache";
import {
hasBlockingShortcutDialog,
isKeyboardShortcutTextInputTarget,
resolveInboxUndoArchiveKeyAction,
shouldBlurPageSearchOnEnter,
shouldBlurPageSearchOnEscape,
} from "../lib/keyboardShortcuts";
import {
resolveInboxIssueBlockerAttention,
resolveIssueRunningDescendantCount,
} from "../lib/inbox-live-descendants";
import {
beginLocalInboxArchive,
boundLocalInboxArchive,
cancelInboxIssueQueries,
clearLocalInboxArchive,
confirmLocalInboxArchive,
invalidateInboxIssueQueries,
getIssuePresenceInActiveInboxCaches,
removeIssueFromInboxCaches,
restoreIssueToInboxCaches,
snapshotInboxIssueCaches,
type InboxIssueCacheSnapshot,
useLocalInboxArchiveIssueIds,
} from "../lib/inboxArchiveCache";
import { EmptyState } from "../components/EmptyState";
import { CollectionToolbar, type CollectionToolbarProps } from "../components/CollectionToolbar";
import { IssueGroupHeader } from "../components/IssueGroupHeader";
import { PageSkeleton } from "../components/PageSkeleton";
import {
InboxIssueMetaLeading,
InboxIssueTrailingColumns,
IssueColumnPicker,
issueActivityText,
issueActivityTimestamp,
issueTrailingColumns,
} from "../components/IssueColumns";
import { IssueFiltersPopover } from "../components/IssueFiltersPopover";
import { InboxArchiveButton, IssueRow } from "../components/IssueRow";
import { BlockedInboxView } from "../components/BlockedInboxView";
import { SwipeToArchive } from "../components/SwipeToArchive";
import { useStreamlinedUiEnabled } from "../hooks/useStreamlinedUiEnabled";
import { Inbox as LegacyInbox } from "./LegacyInbox";
import { StatusIcon } from "../components/StatusIcon";
import { cn } from "../lib/utils";
import { StatusBadge } from "../components/StatusBadge";
import { approvalLabel, defaultTypeIcon, typeIcon } from "../components/ApprovalPayload";
import { timeAgo } from "../lib/timeAgo";
import { Button } from "@/components/ui/button";
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle,
} from "@/components/ui/dialog";
import { Separator } from "@/components/ui/separator";
import { Tabs } from "@/components/ui/tabs";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
import {
Inbox as InboxIcon,
AlertTriangle,
Check,
ChevronRight,
ArrowUpDown,
Layers,
Plus,
XCircle,
X,
RotateCcw,
UserPlus,
Search,
ListTree,
} from "lucide-react";
import { Input } from "@/components/ui/input";
import { PageTabBar } from "../components/PageTabBar";
import type { Approval, HeartbeatRun, InboxMineSnapshot, Issue, JoinRequest } from "@paperclipai/shared";
import {
ACTIONABLE_APPROVAL_STATUSES,
DEFAULT_INBOX_ISSUE_COLUMNS,
buildGroupedInboxSections,
buildInboxIssueGroupCreateDefaults,
buildInboxKeyboardNavEntries,
getAvailableInboxIssueColumns,
getInboxWorkItemKey,
getApprovalsForTab,
getArchivedInboxSearchIssues,
getInboxKeyboardSelectionIndex,
getInboxWorkItems,
getInboxSearchSupplementIssues,
getLatestFailedRunsByAgent,
collectReferencedExecutionWorkspaceIds,
matchesInboxIssueSearch,
getRecentTouchedIssues,
isInboxEntityDismissed,
isMineInboxTab,
loadCollapsedInboxGroupKeys,
loadCollapsedInboxParentIds,
loadInboxNesting,
loadInboxWorkItemGroupBy,
normalizeInboxIssueColumns,
resolveInboxNestingEnabled,
shouldResetInboxWorkspaceGrouping,
resolveIssueWorkspaceName,
resolveInboxSelectionIndex,
saveCollapsedInboxGroupKeys,
saveCollapsedInboxParentIds,
saveInboxNesting,
saveInboxWorkItemGroupBy,
type InboxWorkspaceGroupingOptions,
type InboxApprovalFilter,
type InboxCategoryFilter,
type InboxFilterPreferences,
type InboxIssueColumn,
type InboxKeyboardNavEntry,
saveLastInboxTab,
shouldShowCompanyAlerts,
shouldShowInboxSection,
type InboxGroupedSection,
type InboxTab,
type InboxWorkItem,
type InboxWorkItemGroupBy,
INBOX_FILTER_PREFERENCES_KEY_PREFIX,
INBOX_ISSUE_COLUMNS_KEY,
inboxNavEntryTask,
} from "../lib/inbox";
import { useDismissedInboxAlerts, useInboxDismissals, useReadInboxItems } from "../hooks/useInboxBadge";
import { useInboxSortAttention } from "../hooks/useInboxSortAttention";
import {
captureInboxOrderPin,
reconcileInboxOrderPin,
type InboxOrderPin,
} from "../lib/inboxOrderPin";
import {
loadTaskCollectionPreferences,
saveTaskCollectionPreferences,
type TaskCollectionPreferenceLocation,
} from "../lib/task-collection-preferences";
import {
taskDateGroup,
taskDateGroupSeparator,
type TaskDateGroup,
} from "../lib/task-date-groups";
import { taskStatusIconProps } from "@/lib/task-status-presentation";
const INBOX_HEARTBEAT_RUN_LIMIT = 200;
const INBOX_ISSUE_LIST_LIMIT = 100;
const INBOX_HOT_PATH_STALE_MS = 30_000;
// Stable fallback so memos over unloaded or disabled issue reads do not rerun on every render.
const NO_ISSUES: Issue[] = [];
const NO_JOIN_REQUESTS: JoinRequest[] = [];
/** Bounds an optional read that can hold task rows hidden; a timeout reveals rows and retries in the background. */
const INBOX_OPTIONAL_READ_TIMEOUT_MS = 10_000;
const INBOX_COLLECTION_KEY = "inbox";
type StreamlinedInboxViewState = InboxFilterPreferences & {
showDateGroupSeparators: boolean;
};
const DEFAULT_INBOX_FILTER_PREFERENCES: StreamlinedInboxViewState = {
allCategoryFilter: "everything",
allApprovalFilter: "all",
issueFilters: { ...defaultIssueFilterState },
showDateGroupSeparators: true,
};
function normalizeInboxCollectionViewState(value: unknown): StreamlinedInboxViewState {
const candidate = value && typeof value === "object"
? value as Partial<StreamlinedInboxViewState>
: {};
const category = candidate.allCategoryFilter;
const approval = candidate.allApprovalFilter;
return {
allCategoryFilter:
category === "issues_i_touched"
|| category === "join_requests"
|| category === "approvals"
|| category === "failed_runs"
|| category === "alerts"
? category
: "everything",
allApprovalFilter: approval === "actionable" || approval === "resolved" ? approval : "all",
issueFilters: {
...normalizeIssueFilterState(candidate.issueFilters),
// The filter menu no longer offers Workspace. Drop a saved selection so
// it cannot keep hiding tasks. A task-link workspace query is applied
// by the task list after this load.
workspaces: [],
},
showDateGroupSeparators: candidate.showDateGroupSeparators !== false,
};
}
function inboxCollectionPreferenceLocation(
companyId: string | null | undefined,
): TaskCollectionPreferenceLocation {
return {
companyId: companyId ?? "__unscoped__",
collectionKey: INBOX_COLLECTION_KEY,
legacyViewStorageKey: companyId
? `${INBOX_FILTER_PREFERENCES_KEY_PREFIX}:${companyId}`
: undefined,
legacyColumnsStorageKey: INBOX_ISSUE_COLUMNS_KEY,
};
}
function loadInboxCollectionPreferences(companyId: string | null | undefined) {
return loadTaskCollectionPreferences({
...inboxCollectionPreferenceLocation(companyId),
defaultViewState: DEFAULT_INBOX_FILTER_PREFERENCES,
defaultColumns: DEFAULT_INBOX_ISSUE_COLUMNS,
normalizeViewState: normalizeInboxCollectionViewState,
normalizeColumns: (value) => Array.isArray(value)
? normalizeInboxIssueColumns(value)
: DEFAULT_INBOX_ISSUE_COLUMNS,
});
}
export { InboxIssueMetaLeading, InboxIssueTrailingColumns } from "../components/IssueColumns";
export { IssueGroupHeader as InboxGroupHeader } from "../components/IssueGroupHeader";
type SectionKey =
| "work_items"
| "alerts";
/** A flat navigation entry for keyboard j/k traversal that includes expanded children. */
type NavEntry = InboxKeyboardNavEntry;
// Stable identity for a nav row, resilient to the numeric index shifting when
// the inbox reshapes (archive/poll). Used to re-anchor both the keyboard
// selection and the hovered row across list refreshes.
const navEntryKey = (entry: NavEntry | undefined): string | null =>
!entry
? null
: entry.type === "top"
? `top:${entry.itemKey}`
: entry.type === "child"
? `child:${entry.issueId}`
: `group:${entry.groupKey}`;
type CreatorOption = {
id: string;
label: string;
kind: "agent" | "user";
searchText?: string;
};
function firstNonEmptyLine(value: string | null | undefined): string | null {
if (!value) return null;
const line = value.split("\n").map((chunk) => chunk.trim()).find(Boolean);
return line ?? null;
}
function runFailureMessage(run: HeartbeatRun): string {
return firstNonEmptyLine(run.error) ?? firstNonEmptyLine(run.stderrExcerpt) ?? "Run exited with an error.";
}
function approvalStatusLabel(status: Approval["status"]): string {
return status.replaceAll("_", " ");
}
function readIssueIdFromRun(run: HeartbeatRun): string | null {
if (run.issueId) return run.issueId;
const context = run.contextSnapshot;
if (!context) return null;
const issueId = context["issueId"];
if (typeof issueId === "string" && issueId.length > 0) return issueId;
const taskId = context["taskId"];
if (typeof taskId === "string" && taskId.length > 0) return taskId;
return null;
}
function nonEmptyLabel(value: string | null | undefined): string | null {
const trimmed = value?.trim();
return trimmed ? trimmed : null;
}
export function formatJoinRequestInboxLabel(
joinRequest: Pick<
JoinRequest,
"requestType" | "agentName" | "requestEmailSnapshot" | "requestingUserId"
> & {
requesterUser?: {
name: string | null;
email: string | null;
} | null;
},
) {
if (joinRequest.requestType !== "human") {
return `Agent join request${joinRequest.agentName ? `: ${joinRequest.agentName}` : ""}`;
}
const requesterName = nonEmptyLabel(joinRequest.requesterUser?.name);
const requesterEmail =
nonEmptyLabel(joinRequest.requesterUser?.email) ??
nonEmptyLabel(joinRequest.requestEmailSnapshot);
const requesterId = nonEmptyLabel(joinRequest.requestingUserId);
if (requesterName && requesterEmail) return `${requesterName} (${requesterEmail})`;
if (requesterEmail) return requesterEmail;
if (requesterName) return requesterName;
if (requesterId) return requesterId;
return "Human join request";
}
type NonIssueUnreadState = "visible" | "fading" | "hidden" | null;
// Rows outside SwipeToArchive (non-archivable tabs/sections) still need the
// hover-follows-selection band that SwipeToArchive's surface normally paints.
function InboxRowSurface({ selected, children }: { selected: boolean; children: ReactNode }) {
return <div className={cn(selected && "rounded-lg bg-accent/50")}>{children}</div>;
}
export function FailedRunInboxRow({
run,
issueById,
agentName: linkedAgentName,
issueLinkState,
onDismiss,
onRetry,
isRetrying,
unreadState = null,
onMarkRead,
onArchive,
archiveDisabled,
selected = false,
className,
}: {
run: HeartbeatRun;
issueById: Map<string, Issue>;
agentName: string | null;
issueLinkState: unknown;
onDismiss: () => void;
onRetry: () => void;
isRetrying: boolean;
unreadState?: NonIssueUnreadState;
onMarkRead?: () => void;
onArchive?: () => void;
archiveDisabled?: boolean;
selected?: boolean;
className?: string;
}) {
const issueId = readIssueIdFromRun(run);
const issue = issueId ? issueById.get(issueId) ?? null : null;
const interruption = issue?.interruption;
useSecondTick(interruption?.state === "retry_scheduled");
const retrySeconds = Math.max(0, Math.ceil((Date.parse(interruption?.nextRetryAt ?? "") - Date.now()) / 1000));
const displayError = isRetrying ? "Thinking"
: interruption?.retryWait ? interruption.retryWait.message
: interruption?.state === "working" ? "Thinking"
: interruption?.state === "retry_scheduled" ? `Trying again in ${retrySeconds}s…`
: interruption?.state === "failed" ? "Couldn’t finish this attempt. Your message is saved."
: interruption?.state === "waiting_for_user" ? ({
approval: "Approval required", reconnect: "Reconnect account", assign_agent: "Assign an agent", choose_model: "Choose a supported model",
resume: "Work is paused", budget: "Budget limit reached",
project_access: "Agent needs project access",
confirm_owner_stop: "Confirm the previous server stopped",
confirm_run_stopped: "Confirm the previous run stopped",
}[interruption.userAction ?? "resume"]) : runFailureMessage(run);
const retryAvailable = !interruption || (interruption.canRetry && interruption.retryAction !== "move_forward");
const showUnreadSlot = unreadState !== null;
const showUnreadDot = unreadState === "visible" || unreadState === "fading";
return (
<div className={cn(
"group py-2.5 pl-4 pr-2 sm:py-2",
className,
)}>
<div className="flex items-start gap-2 sm:items-center">
{showUnreadSlot ? (
<span className="hidden sm:inline-flex h-4 w-4 shrink-0 items-center justify-center self-center">
{showUnreadDot ? (
<button
type="button"
onClick={onMarkRead}
className={cn(
"inline-flex h-4 w-4 items-center justify-center rounded-full transition-colors",
"hover:bg-blue-500/20",
)}
aria-label="Mark as read"
>
<span className={cn(
"block h-2 w-2 rounded-full transition-opacity duration-300",
"bg-blue-600 dark:bg-blue-400",
unreadState === "fading" ? "opacity-0" : "opacity-100",
)} />
</button>
) : (
<span className="inline-flex h-4 w-4" aria-hidden="true" />
)}
</span>
) : null}
<Link
to={issueId ? `/issues/${issueId}` : `/agents/${run.agentId}/runs/${run.id}`}
className={cn(
"flex min-w-0 flex-1 items-start gap-2 no-underline text-inherit transition-colors",
selected ? "hover:bg-transparent" : "hover:bg-accent/50",
)}
>
{!showUnreadSlot && <span className="hidden h-2 w-2 shrink-0 sm:inline-flex" aria-hidden="true" />}
<span className="hidden h-3.5 w-3.5 shrink-0 sm:inline-flex" aria-hidden="true" />
<span className="mt-0.5 shrink-0 rounded-md bg-red-500/20 p-1.5 sm:mt-0">
<XCircle className="h-4 w-4 text-red-600 dark:text-red-400" />
</span>
<span className="min-w-0 flex-1">
<span className="line-clamp-2 text-sm font-medium sm:truncate sm:line-clamp-none">
{issue ? (
<>
<span className="font-mono text-muted-foreground mr-1.5">
{issue.identifier ?? issue.id.slice(0, 8)}
</span>
{issue.title}
</>
) : (
<>Failed run{linkedAgentName ? ` — ${linkedAgentName}` : ""}</>
)}
</span>
<span className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground">
{!interruption && <StatusBadge status={run.status} />}
{linkedAgentName && issue ? <span>{linkedAgentName}</span> : null}
<span className="truncate max-w-(--sz-300px)">{displayError}</span>
<span>{timeAgo(run.createdAt)}</span>
</span>
</span>
</Link>
<div className="hidden shrink-0 items-center gap-2 sm:flex">
{onArchive ? (
<InboxArchiveButton onArchive={onArchive} disabled={archiveDisabled} />
) : null}
{retryAvailable && <Button
type="button"
variant="outline"
size="sm"
className="h-8 shrink-0 px-2.5"
onClick={onRetry}
disabled={isRetrying}
>
<RotateCcw className="mr-1.5 h-3.5 w-3.5" />
{isRetrying ? "Thinking" : "Retry"}
</Button>}
{!showUnreadSlot && (
<button
type="button"
onClick={onDismiss}
className="rounded-md p-1 text-muted-foreground opacity-0 transition-opacity hover:bg-accent hover:text-foreground group-hover:opacity-100"
aria-label="Dismiss"
>
<X className="h-4 w-4" />
</button>
)}
</div>
</div>
<div className="mt-3 flex gap-2 sm:hidden">
{retryAvailable && <Button
type="button"
variant="outline"
size="sm"
className="h-8 shrink-0 px-2.5"
onClick={onRetry}
disabled={isRetrying}
>
<RotateCcw className="mr-1.5 h-3.5 w-3.5" />
{isRetrying ? "Thinking" : "Retry"}
</Button>}
{!showUnreadSlot && (
<button
type="button"
onClick={onDismiss}
className="rounded-md p-1 text-muted-foreground hover:bg-accent hover:text-foreground"
aria-label="Dismiss"
>
<X className="h-4 w-4" />
</button>
)}
</div>
</div>
);
}
function ApprovalInboxRow({
approval,
requesterName,
onApprove,
onReject,
isPending,
unreadState = null,
onMarkRead,
onArchive,
archiveDisabled,
selected = false,
className,
}: {
approval: Approval;
requesterName: string | null;
onApprove: () => void;
onReject: () => void;
isPending: boolean;
unreadState?: NonIssueUnreadState;
onMarkRead?: () => void;
onArchive?: () => void;
archiveDisabled?: boolean;
selected?: boolean;
className?: string;
}) {
const Icon = typeIcon[approval.type] ?? defaultTypeIcon;
const label = approvalLabel(approval.type, approval.payload as Record<string, unknown> | null);
const showResolutionButtons =
approval.type !== "budget_override_required" &&
ACTIONABLE_APPROVAL_STATUSES.has(approval.status);
const showUnreadSlot = unreadState !== null;
const showUnreadDot = unreadState === "visible" || unreadState === "fading";
return (
<div className={cn(
"group py-2.5 pl-4 pr-2 sm:py-2",
className,
)}>
<div className="flex items-start gap-2 sm:items-center">
{showUnreadSlot ? (
<span className="hidden sm:inline-flex h-4 w-4 shrink-0 items-center justify-center self-center">
{showUnreadDot ? (
<button
type="button"
onClick={onMarkRead}
className={cn(
"inline-flex h-4 w-4 items-center justify-center rounded-full transition-colors",
"hover:bg-blue-500/20",
)}
aria-label="Mark as read"
>
<span className={cn(
"block h-2 w-2 rounded-full transition-opacity duration-300",
"bg-blue-600 dark:bg-blue-400",
unreadState === "fading" ? "opacity-0" : "opacity-100",
)} />
</button>
) : (
<span className="inline-flex h-4 w-4" aria-hidden="true" />
)}
</span>
) : null}
<Link
to={`/approvals/${approval.id}`}
className={cn(
"flex min-w-0 flex-1 items-start gap-2 no-underline text-inherit transition-colors",
selected ? "hover:bg-transparent" : "hover:bg-accent/50",
)}
>
{!showUnreadSlot && <span className="hidden h-2 w-2 shrink-0 sm:inline-flex" aria-hidden="true" />}
<span className="hidden h-3.5 w-3.5 shrink-0 sm:inline-flex" aria-hidden="true" />
<span className="mt-0.5 shrink-0 rounded-md bg-muted p-1.5 sm:mt-0">
<Icon className="h-4 w-4 text-muted-foreground" />
</span>
<span className="min-w-0 flex-1">
<span className="line-clamp-2 text-sm font-medium sm:truncate sm:line-clamp-none">
{label}
</span>
<span className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground">
<span className="capitalize">{approvalStatusLabel(approval.status)}</span>
{requesterName ? <span>requested by {requesterName}</span> : null}
<span>updated {timeAgo(approval.updatedAt)}</span>
</span>
</span>
</Link>
{(onArchive || showResolutionButtons) ? (
<div className="hidden shrink-0 items-center gap-2 sm:flex">
{onArchive ? (
<InboxArchiveButton onArchive={onArchive} disabled={archiveDisabled} />
) : null}
{showResolutionButtons ? (
<>
<Button
size="sm"
className="h-8 min-w-(--sz-64px) justify-center bg-green-700 px-3 text-white hover:bg-green-600"
onClick={onApprove}
disabled={isPending}
>
Approve
</Button>
<Button
variant="destructive"
size="sm"
className="h-8 min-w-(--sz-64px) justify-center px-3"
onClick={onReject}
disabled={isPending}
>
Reject
</Button>
</>
) : null}
</div>
) : null}
</div>
{showResolutionButtons ? (
<div className="mt-3 flex gap-2 sm:hidden">
<Button
size="sm"
className="h-8 min-w-(--sz-64px) justify-center bg-green-700 px-3 text-white hover:bg-green-600"
onClick={onApprove}
disabled={isPending}
>
Approve
</Button>
<Button
variant="destructive"
size="sm"
className="h-8 min-w-(--sz-64px) justify-center px-3"
onClick={onReject}
disabled={isPending}
>
Reject
</Button>
</div>
) : null}
</div>
);
}
function JoinRequestInboxRow({
joinRequest,
onApprove,
onReject,
isPending,
unreadState = null,
onMarkRead,
onArchive,
archiveDisabled,
selected = false,
className,
}: {
joinRequest: JoinRequest;
onApprove: () => void;
onReject: () => void;
isPending: boolean;
unreadState?: NonIssueUnreadState;
onMarkRead?: () => void;
onArchive?: () => void;
archiveDisabled?: boolean;
selected?: boolean;
className?: string;
}) {
const label = formatJoinRequestInboxLabel(joinRequest);
const showUnreadSlot = unreadState !== null;
const showUnreadDot = unreadState === "visible" || unreadState === "fading";
return (
<div className={cn(
"group py-2.5 pl-4 pr-2 sm:py-2",
className,
)}>
<div className="flex items-start gap-2 sm:items-center">
{showUnreadSlot ? (
<span className="hidden sm:inline-flex h-4 w-4 shrink-0 items-center justify-center self-center">
{showUnreadDot ? (
<button
type="button"
onClick={onMarkRead}
className={cn(
"inline-flex h-4 w-4 items-center justify-center rounded-full transition-colors",
"hover:bg-blue-500/20",
)}
aria-label="Mark as read"
>
<span className={cn(
"block h-2 w-2 rounded-full transition-opacity duration-300",
"bg-blue-600 dark:bg-blue-400",
unreadState === "fading" ? "opacity-0" : "opacity-100",
)} />
</button>
) : (
<span className="inline-flex h-4 w-4" aria-hidden="true" />
)}
</span>
) : null}
<div className="flex min-w-0 flex-1 items-start gap-2">
{!showUnreadSlot && <span className="hidden h-2 w-2 shrink-0 sm:inline-flex" aria-hidden="true" />}
<span className="hidden h-3.5 w-3.5 shrink-0 sm:inline-flex" aria-hidden="true" />
<span className="mt-0.5 shrink-0 rounded-md bg-muted p-1.5 sm:mt-0">
<UserPlus className="h-4 w-4 text-muted-foreground" />
</span>
<span className="min-w-0 flex-1">
<span className="line-clamp-2 text-sm font-medium sm:truncate sm:line-clamp-none">
{label}
</span>
<span className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground">
<span>requested {timeAgo(joinRequest.createdAt)} from IP {joinRequest.requestIp}</span>
{joinRequest.adapterType && <span>adapter: {joinRequest.adapterType}</span>}
</span>
</span>
</div>
<div className="hidden shrink-0 items-center gap-2 sm:flex">
{onArchive ? (
<InboxArchiveButton onArchive={onArchive} disabled={archiveDisabled} />
) : null}
<Button
size="sm"
className="h-8 bg-green-700 px-3 text-white hover:bg-green-600"
onClick={onApprove}
disabled={isPending}
>
Approve
</Button>
<Button
variant="destructive"
size="sm"
className="h-8 px-3"
onClick={onReject}
disabled={isPending}
>
Reject
</Button>
</div>
</div>
<div className="mt-3 flex gap-2 sm:hidden">
<Button
size="sm"
className="h-8 bg-green-700 px-3 text-white hover:bg-green-600"
onClick={onApprove}
disabled={isPending}
>
Approve
</Button>
<Button
variant="destructive"
size="sm"
className="h-8 px-3"
onClick={onReject}
disabled={isPending}
>
Reject
</Button>
</div>
</div>
);
}
function InboxCollectionToolbar({
streamlined,
context,
search,
controls,
feedback,
ariaLabel,
}: CollectionToolbarProps & { streamlined: boolean }) {
if (streamlined) {
return (
<CollectionToolbar
className={ariaLabel === "Tasks controls" ? "mobile-task-toolbar" : undefined}
ariaLabel={ariaLabel}
context={context}
search={search}
controls={controls}
feedback={feedback}
/>
);
}
return (
<div role="toolbar" aria-label={ariaLabel} className="space-y-2">
{search ? <div className="sm:hidden">{search}</div> : null}
<div className="flex flex-wrap items-center justify-between gap-2">
{context}
<div className="flex items-center gap-2">
{search ? <div className="hidden sm:block">{search}</div> : null}
{controls}
</div>
</div>
{feedback}
</div>
);
}
/**
* PAP-670: the inbox stopped being its own page and became the "My work" half
* of Tasks. `Tasks` hosts this component and drives it through these props, so
* every inbox behaviour (unread state, archive, date groups, the mixed
* approval / failed-run / join-request rows) survives the merge by construction
* rather than being reimplemented on the task list.
*
* With no props it is still the standalone `/inbox/*` page, which the legacy
* (non-streamlined) shell continues to use.
*/
export interface InboxSurfaceProps {
/** Which view to render. Falls back to the last path segment when absent. */
tab?: InboxTab;
/** Replaces the inbox tab bar in the toolbar's context slot. */
toolbarContext?: ReactNode;
/** Breadcrumb and back-link label; "Inbox" when standalone, "Tasks" when hosted. */
surfaceLabel?: string;
}
export function Inbox(props: InboxSurfaceProps = {}) {
const { enabled: streamlinedUiEnabled } = useStreamlinedUiEnabled();
const coordinator = useCoordinatorPresentation();
return streamlinedUiEnabled || coordinator ? <StreamlinedInbox {...props} /> : <LegacyInbox />;
}
function StreamlinedInbox({
tab: tabOverride,
toolbarContext,
surfaceLabel = "Inbox",
}: InboxSurfaceProps) {
const streamlinedUiEnabled = true;
const { selectedCompanyId } = useCompany();
const { setBreadcrumbs } = useBreadcrumbs();
const { openNewIssue } = useDialogActions();
const { isMobile } = useSidebar();
const navigate = useNavigate();
const { pushToast } = useToastActions();
const location = useLocation();
const queryClient = useQueryClient();
const [actionError, setActionError] = useState<string | null>(null);
const { data: experimentalSettings, isLoading: isSettingsLoading } = useQuery({
queryKey: queryKeys.instance.experimentalSettings,
queryFn: () => instanceSettingsApi.getExperimental(),
});
const experimentalSettingsLoaded = experimentalSettings !== undefined;
const [searchQuery, setSearchQuery] = useState("");
const normalizedSearchQuery = searchQuery.trim();
const [filterPreferences, setFilterPreferences] = useState<StreamlinedInboxViewState>(
() => loadInboxCollectionPreferences(selectedCompanyId).viewState,
);
const [groupBy, setGroupBy] = useState<InboxWorkItemGroupBy>(() => loadInboxWorkItemGroupBy());
const [blockedGroupBy, setBlockedGroupBy] = useState<BlockedInboxGroupBy>("none");
const [blockedSortBy, setBlockedSortBy] = useState<BlockedInboxSort>("most_recent");
const [visibleIssueColumns, setVisibleIssueColumns] = useState<InboxIssueColumn[]>(
() => loadInboxCollectionPreferences(selectedCompanyId).columns,
);
const { dismissed: dismissedAlerts, dismiss: dismissAlert } = useDismissedInboxAlerts();
const { readItems, markRead: markItemRead, markUnread: markItemUnread } = useReadInboxItems();
const { allCategoryFilter, allApprovalFilter, issueFilters } = filterPreferences;
const pathSegment = location.pathname.split("/").pop() ?? "mine";
const pathTab: InboxTab =
pathSegment === "mine"
|| pathSegment === "recent"
|| pathSegment === "all"
|| pathSegment === "unread"
|| pathSegment === "blocked"
? pathSegment
: "mine";
const tab: InboxTab = tabOverride ?? pathTab;
const canArchiveFromTab = isMineInboxTab(tab);
const issueLinkState = useMemo(
() =>
createIssueDetailLocationState(
surfaceLabel,
`${location.pathname}${location.search}${location.hash}`,
"inbox",
),
[surfaceLabel, location.pathname, location.search, location.hash],
);
const { data: session, isLoading: isSessionLoading } = useQuery({
queryKey: queryKeys.auth.session,
queryFn: () => authApi.getSession(),
});
const currentUserId = session?.user.id ?? session?.session.userId ?? null;
const mineContextQueryKey = [...queryKeys.issues.list(selectedCompanyId!), "mine-context", currentUserId] as const;
const { data: mineSnapshot } = useQuery<InboxMineSnapshot>({ queryKey: mineContextQueryKey, enabled: false });
// On a returning visit the saved query cache restores Mine's snapshot and the
// approvals, join requests and dismissals it showed. Those stand in until the
// reads answer, so rows show without waiting on the network.
const revealSourcesQueryKey = mineRevealSourcesQueryKey(selectedCompanyId!, currentUserId);
const { data: savedRevealSourcesData } = useQuery<MineRevealSources>({ queryKey: revealSourcesQueryKey, enabled: false });
const savedRevealSources = tab === "mine" && mineSnapshot
? readMineRevealSources(savedRevealSourcesData, currentUserId, selectedCompanyId) : null;
const {
dismissals: inboxDismissals,
dismissedAtByKey,
dismiss: dismissInboxItem,
isLoading: isDismissalsLoading,
hasServerData: hasServerDismissals,
error: dismissalsError,
} = useInboxDismissals(selectedCompanyId, { fallback: savedRevealSources?.dismissals });
const { data: agents, isLoading: isAgentsLoading } = useQuery({
queryKey: queryKeys.agents.list(selectedCompanyId!),
queryFn: () => agentsApi.list(selectedCompanyId!),
enabled: !!selectedCompanyId,
});
const { data: projects, isLoading: isProjectsLoading } = useQuery({
queryKey: queryKeys.projects.list(selectedCompanyId!, { includeArchived: true }),
queryFn: () => projectsApi.list(selectedCompanyId!, { includeArchived: true }),
enabled: !!selectedCompanyId,
});
const { data: labels } = useQuery({
queryKey: queryKeys.issues.labels(selectedCompanyId!),
queryFn: () => issuesApi.listLabels(selectedCompanyId!),
enabled: !!selectedCompanyId,
});
const isolatedWorkspacesEnabled = experimentalSettings?.enableIsolatedWorkspaces === true;
const externalObjectsEnabled = experimentalSettings?.enableExternalObjects === true;
useEffect(() => {
setBreadcrumbs([{ label: surfaceLabel }]);
}, [setBreadcrumbs, surfaceLabel]);
useEffect(() => {
saveLastInboxTab(tab);
setSelectedIndex(-1);
setSearchQuery("");
}, [tab]);
const previousSelectedCompanyIdRef = useRef<string | null>(selectedCompanyId);
useEffect(() => {
if (previousSelectedCompanyIdRef.current !== selectedCompanyId) {
previousSelectedCompanyIdRef.current = selectedCompanyId;
const preferences = loadInboxCollectionPreferences(selectedCompanyId);
setFilterPreferences(preferences.viewState);
setVisibleIssueColumns(preferences.columns);
setCollapsedGroupKeys(loadCollapsedInboxGroupKeys(selectedCompanyId));
setCollapsedInboxParents(loadCollapsedInboxParentIds(selectedCompanyId));
}
}, [selectedCompanyId]);
const {
data: serverApprovals,
isLoading: isApprovalsLoading,
failureCount: approvalsFailureCount,
error: approvalsError,
} = useQuery({
queryKey: queryKeys.approvals.list(selectedCompanyId!),
queryFn: ({ signal }) =>
approvalsApi.list(selectedCompanyId!, undefined, { signal, timeoutMs: INBOX_OPTIONAL_READ_TIMEOUT_MS }),
enabled: !!selectedCompanyId,
});
const {
data: serverJoinRequests,
isLoading: isJoinRequestsLoading,
failureCount: joinRequestsFailureCount,
error: joinRequestsError,
} = useQuery({
queryKey: queryKeys.access.joinRequests(selectedCompanyId!),
queryFn: async ({ signal }) => {
try {
return await accessApi.listJoinRequests(selectedCompanyId!, "pending_approval", undefined, {
signal,
timeoutMs: INBOX_OPTIONAL_READ_TIMEOUT_MS,
});
} catch (err) {
if (err instanceof ApiError && (err.status === 403 || err.status === 401)) {
return [];
}
throw err;
}
},
enabled: !!selectedCompanyId,
});
// Saved values stand in while a read is pending or after a transient failure;
// a refusal (403/404) or a server answer replaces them.
const savedStandsIn = (data: unknown, error: unknown) =>
data === undefined && savedRevealSources !== null && (!error || isTransientError(error));
const approvalsFromSaved = savedStandsIn(serverApprovals, approvalsError);
const joinRequestsFromSaved = savedStandsIn(serverJoinRequests, joinRequestsError);
const approvals = approvalsFromSaved ? savedRevealSources!.approvals : serverApprovals;
const joinRequests = serverJoinRequests ?? (joinRequestsFromSaved ? savedRevealSources!.joinRequests : NO_JOIN_REQUESTS);
// Save what Mine shows for the next visit. A complete record needs a server
// answer from every source. Once one exists, each answer replaces its part at
// once, and a refusal (401/403/404) empties it, so a reload never shows what
// the server has since refused while another read is still pending.
useEffect(() => {
if (tab !== "mine" || !selectedCompanyId || !currentUserId || !mineSnapshot) return;
const key = mineRevealSourcesQueryKey(selectedCompanyId, currentUserId);
const saved = readMineRevealSources(queryClient.getQueryData(key), currentUserId, selectedCompanyId);
const refused = (error: unknown) => !!error && !isTransientError(error);
const part = <T,>(server: T[] | undefined, error: unknown, previous: T[] | undefined) =>
server ?? (refused(error) ? [] : previous);
const nextApprovals = part(serverApprovals, approvalsError, saved?.approvals);
const nextJoinRequests = part(serverJoinRequests, joinRequestsError, saved?.joinRequests);
const nextDismissals = part(hasServerDismissals ? inboxDismissals : undefined, dismissalsError, saved?.dismissals);
if (!nextApprovals || !nextJoinRequests || !nextDismissals) return;
const next = buildMineRevealSources({
userId: currentUserId, companyId: selectedCompanyId, approvals: nextApprovals, joinRequests: nextJoinRequests,
dismissals: nextDismissals, failedRunIds: mineSnapshot.failureRuns.map((run) => run.id),
});
// Each write schedules a save of the query cache; skip unchanged values.
if (JSON.stringify(queryClient.getQueryData(key)) === JSON.stringify(next)) return;
queryClient.setQueryData(key, next);
}, [tab, selectedCompanyId, currentUserId, mineSnapshot, serverApprovals, approvalsError, serverJoinRequests, joinRequestsError,
hasServerDismissals, inboxDismissals, dismissalsError, queryClient]);
const dashboardQueryKey = queryKeys.dashboard(selectedCompanyId!);
const sharedDashboard = useSharedPollingQuery({
companyId: selectedCompanyId,
resourceKey: "dashboard",
queryKey: dashboardQueryKey,
enabled: !!selectedCompanyId && tab === "all",
});
const { data: dashboard, isLoading: isDashboardLoading, dataUpdatedAt: dashboardUpdatedAt } = useQuery({
queryKey: dashboardQueryKey,
queryFn: () => dashboardApi.summary(selectedCompanyId!),
enabled: !!selectedCompanyId && tab === "all",
});
usePublishSharedQueryData(sharedDashboard, dashboard, dashboardUpdatedAt);
const mineIssuesQuery = useQuery({
queryKey: [...queryKeys.issues.listMineByMe(selectedCompanyId!), "index", "with-routine-executions", "live-descendant-summary", INBOX_ISSUE_LIST_LIMIT, currentUserId] as const,
queryFn: async ({ signal }) => {
const snapshot = await issuesApi.inboxMine(selectedCompanyId!, { signal });
if (snapshot.userId !== currentUserId) {
void queryClient.invalidateQueries({ queryKey: queryKeys.auth.session });
throw new ApiError("Your account changed. Refresh the inbox.", 409, { error: "account_changed" });
}
queryClient.setQueryData(mineContextQueryKey, snapshot);
return snapshot.issues as Issue[];
},
enabled: !!selectedCompanyId && !!currentUserId && tab === "mine",
refetchOnMount: mineSnapshot ? undefined : "always",
refetchOnWindowFocus: false,
staleTime: mineSnapshot ? INBOX_HOT_PATH_STALE_MS : 0,
// A successful aggregate can still omit a failed source. React Query's
// error retries do not run for that 200 response, so retry those sources.
refetchInterval: () => {
const snapshot = queryClient.getQueryData<InboxMineSnapshot>(mineContextQueryKey);
return [snapshot?.failureError, snapshot?.contextError].some(error =>
error && isTransientError(new ApiError(error.message, error.status, null))) ? 5_000 : false;
},
});
const { data: mineIssuesRaw = NO_ISSUES, isLoading: isMineIssuesLoading, error: mineIssuesError } = mineIssuesQuery;
const mineIssuesView = useQueryView(mineIssuesQuery);
const mineIssuesQueryKey = [...queryKeys.issues.listMineByMe(selectedCompanyId!), "index", "with-routine-executions", "live-descendant-summary", INBOX_ISSUE_LIST_LIMIT, currentUserId] as const;
// Mine owns one coherent response: broadcasting only its task array would
// refresh that array while another tab retained stale parent/failure context.
// Each tab uses the authenticated aggregate read; the server coalesces it.
const touchedIssuesQuery = useQuery({
queryKey: [...queryKeys.issues.listTouchedByMe(selectedCompanyId!), "index", "with-routine-executions", "live-descendant-summary", INBOX_ISSUE_LIST_LIMIT] as const,
queryFn: () =>
issuesApi.listCompact(selectedCompanyId!, {
touchedByUserId: "me",
status: INBOX_MINE_ISSUE_STATUS_FILTER,
projection: "index",
sortField: "updated",
sortDir: "desc",
includeRoutineExecutions: true,
includeLiveDescendantSummary: true,
limit: INBOX_ISSUE_LIST_LIMIT,
}).then((rows) => rows as Issue[]),
enabled: !!selectedCompanyId && (tab !== "mine" && tab !== "blocked" || normalizedSearchQuery.length > 0),
refetchOnWindowFocus: false,
staleTime: INBOX_HOT_PATH_STALE_MS,
});
const { data: touchedIssuesRaw = NO_ISSUES, isLoading: isTouchedIssuesLoading, error: touchedIssuesError, dataUpdatedAt: touchedIssuesUpdatedAt } = touchedIssuesQuery;
const touchedIssuesView = useQueryView(touchedIssuesQuery);
const touchedIssuesQueryKey = [...queryKeys.issues.listTouchedByMe(selectedCompanyId!), "index", "with-routine-executions", "live-descendant-summary", INBOX_ISSUE_LIST_LIMIT] as const;
const sharedTouchedIssues = useSharedPollingQuery<Issue[]>({
companyId: selectedCompanyId,
resourceKey: "inbox:touched-issues",
queryKey: touchedIssuesQueryKey,
enabled: !!selectedCompanyId && (tab !== "mine" && tab !== "blocked" || normalizedSearchQuery.length > 0),
});
usePublishSharedQueryData(sharedTouchedIssues, touchedIssuesRaw, touchedIssuesUpdatedAt);
const { data: otherHeartbeatRuns, isLoading: isOtherRunsLoading, error: otherRunsError } = useQuery({
queryKey: [...queryKeys.heartbeats(selectedCompanyId!), "inbox-failures", INBOX_HEARTBEAT_RUN_LIMIT],
queryFn: () => heartbeatsApi.list(selectedCompanyId!, undefined, INBOX_HEARTBEAT_RUN_LIMIT, { summary: true, latestFailuresOnly: true }),
enabled: !!selectedCompanyId && tab !== "mine",
refetchOnWindowFocus: false,
staleTime: INBOX_HOT_PATH_STALE_MS,
});
const heartbeatRuns = tab === "mine" ? mineSnapshot?.failureRuns : otherHeartbeatRuns;
const isRunsLoading = tab === "mine" ? !!currentUserId && !mineSnapshot && !mineIssuesError : isOtherRunsLoading;
const runsError = tab === "mine" && mineSnapshot?.failureError
? new ApiError(mineSnapshot.failureError.message, mineSnapshot.failureError.status, null) : tab === "mine" ? null : otherRunsError;
const bundledContextIds = useMemo(() => new Set(tab === "mine" && mineSnapshot ? [
...mineSnapshot.issues.map((issue) => issue.parentId).filter((id): id is string => Boolean(id)),
...mineSnapshot.failureRuns.map(readIssueIdFromRun).filter((id): id is string => Boolean(id)),
] : []), [tab, mineSnapshot]);
const { parentContextIds, failureContextIds, contextIssueIds } = useMemo(() => {
const sourceIssues = tab === "mine" ? mineIssuesRaw : touchedIssuesRaw;
const loadedIds = new Set(sourceIssues.map((issue) => issue.id));
// Failure cards need interruption state even when their task is already in
// the index. Parent captions only need index metadata.
const failureIds = new Set((heartbeatRuns ?? []).map(readIssueIdFromRun)
.filter((id): id is string => Boolean(id))
.filter((id) => !bundledContextIds.has(id)));
const parentIds = new Set(sourceIssues.map((issue) => issue.parentId)
.filter((id): id is string => Boolean(id))
.filter((id) => !loadedIds.has(id) && !failureIds.has(id) && !bundledContextIds.has(id)));
return {
parentContextIds: [...parentIds].sort(),
failureContextIds: [...failureIds].sort(),
contextIssueIds: new Set([...parentIds, ...failureIds]),
};
}, [tab, mineIssuesRaw, touchedIssuesRaw, heartbeatRuns, bundledContextIds]);
const needsIssueContext = !!selectedCompanyId && contextIssueIds.size > 0 && tab !== "blocked"
&& (tab !== "mine" || !!mineSnapshot || !!mineIssuesError);
const {
data: issueContext,
isLoading: isContextIssuesLoading,
isPlaceholderData: isContextIssuesPlaceholder,
error: extraContextIssuesError,
} = useQuery<{
companyId: string | null;
userId: string | null;
issues: Issue[];
failureIssueIds: string[];
}>({
queryKey: [...queryKeys.issues.list(selectedCompanyId!), "row-context", "parent-index-with-failure-state", parentContextIds, failureContextIds, currentUserId],
placeholderData: (previous) => needsIssueContext && previous?.companyId === selectedCompanyId && previous.userId === currentUserId
? { ...previous, issues: previous.issues.filter((issue) => contextIssueIds.has(issue.id)) }
: undefined,
queryFn: async ({ signal }) => {
const loadContext = async (ids: string[], projection: "index" | "rows") => {
const result: Issue[] = [];
for (let offset = 0; offset < ids.length; offset += 100) {
result.push(...await issuesApi.listCompact(selectedCompanyId!, {
ids: ids.slice(offset, offset + 100), projection, limit: 100,
includeRoutineExecutions: true,
}, { signal }) as Issue[]);
}
return result;
};
const [parents, failures] = await Promise.all([
loadContext(parentContextIds, "index"),
loadContext(failureContextIds, "rows"),
]);
// A completed failure read also establishes absence for filtered/missing
// tasks. Parent-only placeholders cannot supply this coverage.
return { companyId: selectedCompanyId, userId: currentUserId, issues: [...parents, ...failures], failureIssueIds: failureContextIds };
},
enabled: needsIssueContext,
});
const contextIssuesError = extraContextIssuesError ?? (tab === "mine" && mineSnapshot?.contextError
? new ApiError(mineSnapshot.contextError.message, mineSnapshot.contextError.status, null) : null);
const contextIssues = useMemo(() => {
if (tab !== "mine" || !mineSnapshot) return issueContext?.issues ?? [];
const sourceIds = new Set(mineIssuesRaw.map((issue) => issue.id));
const parentIds = new Set(mineIssuesRaw.map((issue) => issue.parentId));
return [
...mineSnapshot.issues.filter((issue) => !sourceIds.has(issue.id) && parentIds.has(issue.id)),
...mineSnapshot.contextIssues.filter((issue) => parentIds.has(issue.id) || mineSnapshot.failureIssueIds.includes(issue.id)),
...(issueContext?.issues ?? []),
] as Issue[];
}, [tab, mineSnapshot, mineIssuesRaw, issueContext]);
const knownFailureContextIds = useMemo(() => new Set([
...(tab === "mine" ? mineSnapshot?.failureIssueIds ?? [] : []), ...(issueContext?.failureIssueIds ?? []),
]), [tab, mineSnapshot, issueContext]);
const issues = useMemo(() => [...mineIssuesRaw, ...touchedIssuesRaw, ...contextIssues], [mineIssuesRaw, touchedIssuesRaw, contextIssues]);
const liveRunsQueryKey = queryKeys.liveRuns(selectedCompanyId!);
const sharedLiveRuns = useSharedPollingQuery({
companyId: selectedCompanyId,
resourceKey: "live-runs",
queryKey: liveRunsQueryKey,
enabled: !!selectedCompanyId,
// Event-sourced via LiveUpdatesProvider (GitHub issue 9627); no interval poll needed.
refetchInterval: false,
leaderOnly: true,
});
const { data: liveRuns, isLoading: isLiveRunsLoading, dataUpdatedAt: liveRunsUpdatedAt } = useQuery({
queryKey: liveRunsQueryKey,
queryFn: () => heartbeatsApi.liveRunsForCompany(selectedCompanyId!),
enabled: sharedLiveRuns.enabled,
refetchInterval: sharedLiveRuns.refetchInterval,
});
usePublishSharedQueryData(sharedLiveRuns, liveRuns, liveRunsUpdatedAt);
const {
data: companyMembers,
isLoading: isMembersLoading,
failureCount: membersFailureCount,
} = useQuery({
queryKey: queryKeys.access.companyUserDirectory(selectedCompanyId!),
queryFn: ({ signal }) =>
accessApi.listUserDirectory(selectedCompanyId!, { signal, timeoutMs: INBOX_OPTIONAL_READ_TIMEOUT_MS }),
enabled: !!selectedCompanyId,
});
const [archivingIssueIds, setArchivingIssueIds] = useState<Set<string>>(new Set());
const [undoableArchiveIssueIds, setUndoableArchiveIssueIds] = useState<string[]>([]);
const [unarchivingIssueIds, setUnarchivingIssueIds] = useState<Set<string>>(new Set());
const guardedArchiveIssueIds = useLocalInboxArchiveIssueIds(selectedCompanyId);
const locallyArchivedIssueIds = useMemo(() => {
const issueIds = new Set(guardedArchiveIssueIds);
for (const issueId of undoableArchiveIssueIds) issueIds.add(issueId);
for (const issueId of archivingIssueIds) issueIds.add(issueId);
for (const issueId of unarchivingIssueIds) issueIds.delete(issueId);
return issueIds;
}, [archivingIssueIds, guardedArchiveIssueIds, undoableArchiveIssueIds, unarchivingIssueIds]);
const companyUserLabelMap = useMemo(
() => buildCompanyUserLabelMap(companyMembers?.users),
[companyMembers?.users],
);
const companyUserProfileMap = useMemo(
() => buildCompanyUserProfileMap(companyMembers?.users),
[companyMembers?.users],
);
const mineIssues = useMemo(
() => getRecentTouchedIssues(mineIssuesRaw).filter((issue) => !locallyArchivedIssueIds.has(issue.id)),
[locallyArchivedIssueIds, mineIssuesRaw],
);
const touchedIssues = useMemo(
() => getRecentTouchedIssues(touchedIssuesRaw).filter((issue) => !locallyArchivedIssueIds.has(issue.id)),
[locallyArchivedIssueIds, touchedIssuesRaw],
);
const sourceSearchIds = useMemo(() => [...new Set([...mineIssuesRaw, ...touchedIssuesRaw].map((issue) => issue.id))].sort(), [mineIssuesRaw, touchedIssuesRaw]);
const sourceSearchQuery = useQuery<Issue[]>({
queryKey: [...queryKeys.issues.list(selectedCompanyId!), "inbox-source-search", normalizedSearchQuery, sourceSearchIds],
queryFn: async ({ signal }) => {
const matches: Issue[] = [];
for (let offset = 0; offset < sourceSearchIds.length; offset += 100) {
matches.push(...await issuesApi.listCompact(selectedCompanyId!, {
ids: sourceSearchIds.slice(offset, offset + 100), q: normalizedSearchQuery,
projection: "index", includeRoutineExecutions: true, limit: 100,
}, { signal }) as Issue[]);
}
return matches;
},
enabled: !!selectedCompanyId && normalizedSearchQuery.length > 0 && sourceSearchIds.length > 0,
});
const { data: sourceSearchMatches = [], isLoading: isSourceSearchLoading, error: sourceSearchError } = sourceSearchQuery;
const sourceSearchView = useQueryView(sourceSearchQuery);
const sourceSearchMatchIds = useMemo(() => new Set(sourceSearchMatches.map((issue) => issue.id)), [sourceSearchMatches]);
const shouldUseIssueSearchSupplement =
!!selectedCompanyId
&& normalizedSearchQuery.length > 0;
const { data: remoteIssueSearchResults = NO_ISSUES } = useQuery({
queryKey: [
...queryKeys.issues.search(selectedCompanyId!, normalizedSearchQuery, undefined, 25),
"compact",
"inbox-supplement",
issueFilters.showAgentCreatedTasks,
"live-descendant-summary",
],
queryFn: () =>
issuesApi.listCompact(selectedCompanyId!, {
q: normalizedSearchQuery,
limit: 25,
includeAgentCreatedTasks: issueFilters.showAgentCreatedTasks,
includeParticipatedTasks: true,
includeRoutineExecutions: true,
includeLiveDescendantSummary: true,
}).then((rows) => rows as Issue[]),
enabled: shouldUseIssueSearchSupplement,
});
const liveIssueIds = useMemo(
() => collectLiveIssueIds(liveRuns, [
...(issues ?? []),
...mineIssuesRaw,
...touchedIssuesRaw,
...remoteIssueSearchResults,
]),
[issues, liveRuns, mineIssuesRaw, remoteIssueSearchResults, touchedIssuesRaw],
);
const inboxIssueIdsForExternalObjectSummaries = useMemo(() => {
const issueIds = new Set<string>();
for (const issue of mineIssues) issueIds.add(issue.id);
for (const issue of touchedIssues) issueIds.add(issue.id);
for (const issue of remoteIssueSearchResults) issueIds.add(issue.id);
return [...issueIds];
}, [mineIssues, remoteIssueSearchResults, touchedIssues]);
// Only the workspaces these rows reference; a company-wide list can be thousands of rows.
const referencedExecutionWorkspaceIds = useMemo(
() => collectReferencedExecutionWorkspaceIds(issues, remoteIssueSearchResults),
[issues, remoteIssueSearchResults],
);
const referencedExecutionWorkspaceIdsKey = referencedExecutionWorkspaceIds.join(",");
const workspaceLookupEnabled = !!selectedCompanyId && isolatedWorkspacesEnabled && referencedExecutionWorkspaceIds.length > 0;
const {
data: executionWorkspaces = [],
isLoading: isWorkspacesLoading,
isPlaceholderData: isWorkspacesPlaceholder,
} = useQuery({
queryKey: queryKeys.executionWorkspaces.summaryList(selectedCompanyId ?? "__disabled__", {
ids: referencedExecutionWorkspaceIdsKey,
}),
queryFn: () => executionWorkspacesApi.listSummariesByIds(selectedCompanyId!, referencedExecutionWorkspaceIds),
enabled: workspaceLookupEnabled,
// Keep names visible while this company's id set changes; never carry them across companies
// or into a view that needs no lookup, where a placeholder would never be replaced.
placeholderData: (previous, previousQuery) =>
workspaceLookupEnabled && previousQuery?.queryKey[1] === selectedCompanyId ? previous : undefined,
});
const {
summaries: externalObjectSummaryByIssueId,
isLoading: externalObjectSummariesLoading,
isReady: externalObjectSummariesReady,
error: externalObjectSummariesError,
refetch: retryExternalObjectSummaries,
} = useIssueExternalObjectSummaries(
selectedCompanyId,
inboxIssueIdsForExternalObjectSummaries,
);
const issueFilterContext = useMemo(() => ({
externalObjectSummaryByIssueId,
externalObjectSummariesReady: externalObjectSummariesReady && !externalObjectSummariesLoading,
}), [externalObjectSummariesLoading, externalObjectSummariesReady, externalObjectSummaryByIssueId]);
const visibleMineIssues = useMemo(
() => applyIssueFilters(mineIssues, issueFilters, currentUserId, false, liveIssueIds, issueFilterContext),
[mineIssues, issueFilters, currentUserId, liveIssueIds, issueFilterContext],
);
const visibleTouchedIssues = useMemo(
() => applyIssueFilters(touchedIssues, issueFilters, currentUserId, false, liveIssueIds, issueFilterContext),
[touchedIssues, issueFilters, currentUserId, liveIssueIds, issueFilterContext],
);
const unreadTouchedIssues = useMemo(
() => visibleTouchedIssues.filter((issue) => issue.isUnreadForMe),
[visibleTouchedIssues],
);
const creatorOptions = useMemo<CreatorOption[]>(() => {
const options = new Map<string, CreatorOption>();
const sourceIssues = [...mineIssues, ...touchedIssues];
if (currentUserId) {
options.set(`user:${currentUserId}`, {
id: `user:${currentUserId}`,
label: currentUserId === "local-board" ? "Board" : "Me",
kind: "user",
searchText: currentUserId === "local-board" ? "board me human local-board" : `me board human ${currentUserId}`,
});
}
for (const issue of sourceIssues) {
if (issue.createdByUserId) {
const id = `user:${issue.createdByUserId}`;
if (!options.has(id)) {
options.set(id, {
id,
label: formatAssigneeUserLabel(issue.createdByUserId, currentUserId) ?? issue.createdByUserId.slice(0, 5),
kind: "user",
searchText: `${issue.createdByUserId} board user human`,
});
}
}
}
const knownAgentIds = new Set<string>();
for (const agent of agents ?? []) {
knownAgentIds.add(agent.id);
const id = `agent:${agent.id}`;
if (!options.has(id)) {
options.set(id, {
id,
label: agent.name,
kind: "agent",
searchText: `${agent.name} ${agent.id} agent`,
});
}
}
for (const issue of sourceIssues) {
if (issue.createdByAgentId && !knownAgentIds.has(issue.createdByAgentId)) {
const id = `agent:${issue.createdByAgentId}`;
if (!options.has(id)) {
options.set(id, {
id,
label: issue.createdByAgentId.slice(0, 8),
kind: "agent",
searchText: `${issue.createdByAgentId} agent`,
});
}
}
}
return [...options.values()].sort((a, b) => {
if (a.kind !== b.kind) return a.kind === "user" ? -1 : 1;
return a.label.localeCompare(b.label);
});
}, [agents, currentUserId, mineIssues, touchedIssues]);
const issuesToRender = useMemo(
() => {
if (tab === "mine") return visibleMineIssues;
if (tab === "unread") return unreadTouchedIssues;
return visibleTouchedIssues;
},
[tab, visibleMineIssues, visibleTouchedIssues, unreadTouchedIssues],
);
const agentById = useMemo(() => {
const map = new Map<string, string>();
for (const agent of agents ?? []) map.set(agent.id, agent.name);
return map;
}, [agents]);
const issueById = useMemo(() => {
const map = new Map<string, Issue>();
for (const issue of issues ?? []) map.set(issue.id, issue);
return map;
}, [issues]);
const projectById = useMemo(() => {
const map = new Map<string, { name: string; color: string | null }>();
for (const project of projects ?? []) {
map.set(project.id, { name: project.name, color: project.color });
}
return map;
}, [projects]);
const projectWorkspaceById = useMemo(() => {
const map = new Map<string, { name: string; projectId: string }>();
for (const project of projects ?? []) {
for (const workspace of project.workspaces ?? []) {
map.set(workspace.id, { name: workspace.name, projectId: project.id });
}
}
return map;
}, [projects]);
const defaultProjectWorkspaceIdByProjectId = useMemo(() => {
const map = new Map<string, string>();
for (const project of projects ?? []) {
const defaultWorkspaceId =
project.executionWorkspacePolicy?.defaultProjectWorkspaceId
?? project.primaryWorkspace?.id
?? null;
if (defaultWorkspaceId) map.set(project.id, defaultWorkspaceId);
}
return map;
}, [projects]);
const executionWorkspaceById = useMemo(() => {
const map = new Map<string, {
name: string;
mode: "shared_workspace" | "isolated_workspace" | "operator_branch" | "adapter_managed" | "cloud_sandbox";
projectWorkspaceId: string | null;
projectId: string | null;
}>();
for (const workspace of executionWorkspaces) {
const projectWorkspace = workspace.projectWorkspaceId
? projectWorkspaceById.get(workspace.projectWorkspaceId) ?? null
: null;
map.set(workspace.id, {
name: workspace.name,
mode: workspace.mode,
projectWorkspaceId: workspace.projectWorkspaceId ?? null,
projectId: projectWorkspace?.projectId ?? null,
});
}
return map;
}, [executionWorkspaces, projectWorkspaceById]);
const inboxWorkspaceGrouping = useMemo<InboxWorkspaceGroupingOptions>(
() => ({
agentById,
executionWorkspaceById,
projectWorkspaceById,
defaultProjectWorkspaceIdByProjectId,
projectById,
userLabelById: companyUserLabelMap,
currentUserId,
}),
[
agentById,
companyUserLabelMap,
currentUserId,
defaultProjectWorkspaceIdByProjectId,
executionWorkspaceById,
projectById,
projectWorkspaceById,
],
);
const visibleIssueColumnSet = useMemo(() => new Set(visibleIssueColumns), [visibleIssueColumns]);
const availableIssueColumns = useMemo(
() => getAvailableInboxIssueColumns(isolatedWorkspacesEnabled),
[isolatedWorkspacesEnabled],
);
const availableIssueColumnSet = useMemo(() => new Set(availableIssueColumns), [availableIssueColumns]);
const visibleTrailingIssueColumns = useMemo(
() => issueTrailingColumns.filter((column) => visibleIssueColumnSet.has(column) && availableIssueColumnSet.has(column)),
[availableIssueColumnSet, visibleIssueColumnSet],
);
const visibleTaskDataColumns = useMemo(
() => visibleTrailingIssueColumns.filter((column) => column !== "updated"),
[visibleTrailingIssueColumns],
);
const showTaskTimestamp = visibleIssueColumnSet.has("updated") && availableIssueColumnSet.has("updated");
const failedRuns = useMemo(
() =>
getLatestFailedRunsByAgent(heartbeatRuns ?? []).filter((run) => {
const issueId = readIssueIdFromRun(run);
return !isInboxEntityDismissed(dismissedAtByKey, `run:${run.id}`, run.createdAt)
&& (!issueId || knownFailureContextIds.has(issueId) || !!contextIssuesError)
&& issueById.get(issueId ?? "")?.interruption?.state !== "resolved";
}),
[heartbeatRuns, dismissedAtByKey, issueById, knownFailureContextIds, contextIssuesError],
);
const approvalsToRender = useMemo(() => {
let filtered = getApprovalsForTab(approvals ?? [], tab, allApprovalFilter, currentUserId);
if (tab === "mine") {
filtered = filtered.filter(
(a) => !isInboxEntityDismissed(dismissedAtByKey, `approval:${a.id}`, a.updatedAt),
);
}
return filtered;
}, [approvals, tab, allApprovalFilter, currentUserId, dismissedAtByKey]);
const showJoinRequestsCategory =
allCategoryFilter === "everything" || allCategoryFilter === "join_requests";
const showTouchedCategory =
allCategoryFilter === "everything" || allCategoryFilter === "issues_i_touched";
const showApprovalsCategory =
allCategoryFilter === "everything" || allCategoryFilter === "approvals";
const showFailedRunsCategory =
allCategoryFilter === "everything" || allCategoryFilter === "failed_runs";
const showAlertsCategory = allCategoryFilter === "everything" || allCategoryFilter === "alerts";
const failedRunsForTab = useMemo(() => {
if (tab === "all" && !showFailedRunsCategory) return [];
if (tab === "mine") return failedRuns.filter((run) => isHeartbeatRunVisibleInMine(run, currentUserId));
return failedRuns;
}, [failedRuns, tab, showFailedRunsCategory, currentUserId]);
const joinRequestsForTab = useMemo(() => {
if (tab === "all" && !showJoinRequestsCategory) return [];
if (tab === "mine") {
return joinRequests.filter(
(jr) => !isInboxEntityDismissed(dismissedAtByKey, `join:${jr.id}`, jr.updatedAt ?? jr.createdAt),
);
}
return joinRequests;
}, [joinRequests, tab, showJoinRequestsCategory, dismissedAtByKey]);
const workItemsToRender = useMemo(
() =>
getInboxWorkItems({
issues: tab === "all" && !showTouchedCategory ? [] : issuesToRender,
approvals: tab === "all" && !showApprovalsCategory ? [] : approvalsToRender,
failedRuns: failedRunsForTab,
joinRequests: joinRequestsForTab,
}),
[approvalsToRender, issuesToRender, showApprovalsCategory, showTouchedCategory, tab, failedRunsForTab, joinRequestsForTab],
);
const filteredWorkItems = useMemo(() => {
const q = normalizedSearchQuery.toLowerCase();
if (!q) return workItemsToRender;
return workItemsToRender.filter((item) => {
if (item.kind === "issue") {
return matchesInboxIssueSearch(item.issue, q, {
matchedIssueIds: sourceSearchMatchIds,
isolatedWorkspacesEnabled,
executionWorkspaceById,
projectWorkspaceById,
defaultProjectWorkspaceIdByProjectId,
});
}
if (item.kind === "approval") {
const a = item.approval;
const label = approvalLabel(a.type, a.payload as Record<string, unknown> | null);
if (label.toLowerCase().includes(q)) return true;
if (a.type.toLowerCase().includes(q)) return true;
return false;
}
if (item.kind === "failed_run") {
const run = item.run;
const name = agentById.get(run.agentId);
if (name?.toLowerCase().includes(q)) return true;
const msg = runFailureMessage(run);
if (msg.toLowerCase().includes(q)) return true;
const issueId = readIssueIdFromRun(run);
if (issueId) {
const issue = issueById.get(issueId);
if (issue?.title.toLowerCase().includes(q)) return true;
if (issue?.identifier?.toLowerCase().includes(q)) return true;
}
return false;
}
if (item.kind === "join_request") {
const jr = item.joinRequest;
if (jr.agentName?.toLowerCase().includes(q)) return true;
if (jr.capabilities?.toLowerCase().includes(q)) return true;
return false;
}
return false;
});
}, [
workItemsToRender,
agentById,
defaultProjectWorkspaceIdByProjectId,
executionWorkspaceById,
issueById,
isolatedWorkspacesEnabled,
normalizedSearchQuery,
sourceSearchMatchIds,
projectWorkspaceById,
]);
const archivedSearchIssues = useMemo(
() =>
tab === "mine"
? getArchivedInboxSearchIssues({
visibleIssues: visibleMineIssues,
searchableIssues: visibleTouchedIssues,
query: normalizedSearchQuery,
matchedIssueIds: sourceSearchMatchIds,
isolatedWorkspacesEnabled,
executionWorkspaceById,
projectWorkspaceById,
defaultProjectWorkspaceIdByProjectId,
})
: [],
[
defaultProjectWorkspaceIdByProjectId,
executionWorkspaceById,
isolatedWorkspacesEnabled,
normalizedSearchQuery,
sourceSearchMatchIds,
projectWorkspaceById,
tab,
visibleMineIssues,
visibleTouchedIssues,
],
);
const issueSearchSupplementResults = useMemo(
() =>
getInboxSearchSupplementIssues({
query: normalizedSearchQuery,
filteredWorkItems,
archivedSearchIssues,
remoteIssues: remoteIssueSearchResults,
issueFilters,
currentUserId,
enableAgentCreatedVisibilityFilter: false,
liveIssueIds,
issueFilterContext,
}),
[
archivedSearchIssues,
currentUserId,
filteredWorkItems,
issueFilterContext,
issueFilters,
liveIssueIds,
normalizedSearchQuery,
remoteIssueSearchResults,
],
);
const nonInboxSearchIssueIds = useMemo(
() => new Set([
...archivedSearchIssues.map((issue) => issue.id),
...issueSearchSupplementResults.map((issue) => issue.id),
]),
[archivedSearchIssues, issueSearchSupplementResults],
);
// --- Parent-child nesting for inbox issues ---
const [nestingPreferenceEnabled, setNestingPreferenceEnabled] = useState(() => loadInboxNesting());
const nestingEnabled = resolveInboxNestingEnabled(nestingPreferenceEnabled, isMobile);
useEffect(() => {
if (!shouldResetInboxWorkspaceGrouping(groupBy, isolatedWorkspacesEnabled, experimentalSettingsLoaded)) return;
setGroupBy("none");
saveInboxWorkItemGroupBy("none");
}, [experimentalSettingsLoaded, groupBy, isolatedWorkspacesEnabled]);
const toggleNesting = useCallback(() => {
setNestingPreferenceEnabled((prev) => {
const next = !prev;
saveInboxNesting(next);
return next;
});
}, []);
const [collapsedInboxParents, setCollapsedInboxParents] = useState<Set<string>>(
() => loadCollapsedInboxParentIds(selectedCompanyId),
);
const [collapsedGroupKeys, setCollapsedGroupKeys] = useState<Set<string>>(() => loadCollapsedInboxGroupKeys(selectedCompanyId));
const toggleGroupCollapse = useCallback((groupKey: string) => {
setCollapsedGroupKeys((prev) => {
const next = new Set(prev);
if (next.has(groupKey)) next.delete(groupKey);
else next.add(groupKey);
saveCollapsedInboxGroupKeys(selectedCompanyId, next);
return next;
});
}, [selectedCompanyId]);
const setGroupCollapsed = useCallback((groupKey: string, collapsed: boolean) => {
setCollapsedGroupKeys((prev) => {
if (collapsed ? prev.has(groupKey) : !prev.has(groupKey)) return prev;
const next = new Set(prev);
if (collapsed) next.add(groupKey);
else next.delete(groupKey);
saveCollapsedInboxGroupKeys(selectedCompanyId, next);
return next;
});
}, [selectedCompanyId]);
const freshGroupedSections = useMemo<InboxGroupedSection[]>(() => [
...buildGroupedInboxSections(filteredWorkItems, groupBy, inboxWorkspaceGrouping, { nestingEnabled }),
...buildGroupedInboxSections(
getInboxWorkItems({ issues: archivedSearchIssues, approvals: [] }),
groupBy,
inboxWorkspaceGrouping,
{ keyPrefix: "archived-search:", searchSection: "archived", nestingEnabled },
),
...buildGroupedInboxSections(
getInboxWorkItems({ issues: issueSearchSupplementResults, approvals: [] }),
groupBy,
inboxWorkspaceGrouping,
{ keyPrefix: "other-search:", searchSection: "other", nestingEnabled },
),
], [
archivedSearchIssues,
filteredWorkItems,
groupBy,
inboxWorkspaceGrouping,
issueSearchSupplementResults,
nestingEnabled,
]);
// --- Order pinning (PAP-16015) ---
// The freshly computed sort is only *displayed* at attention boundaries. Between
// them we reconcile the fresh sections against the last committed order so that
// archiving mid-engagement (which drops rows from the caches, and can lower a
// parent's subtree-max sort ts) can no longer reshuffle the list under the
// cursor. New items still land at their algorithmic position; archived rows hold
// their slot for the 5s undo grace before collapsing. See `inboxOrderPin.ts`.
const orderPinRef = useRef<InboxOrderPin>({ sections: [] });
// Bumped by an attention commit to force `groupedSections` to adopt the fresh order.
const [orderCommitToken, setOrderCommitToken] = useState(0);
const orderCommitRequestedRef = useRef(false);
const commitInboxOrder = useCallback(() => {
orderCommitRequestedRef.current = true;
setOrderCommitToken((token) => token + 1);
}, []);
// Distinct view = distinct pin. Switching tab/filter/search/grouping resets the
// held order so we never carry one view's layout into another.
const inboxSortViewIdentity = useMemo(
() =>
JSON.stringify([
selectedCompanyId,
tab,
groupBy,
nestingEnabled,
normalizedSearchQuery,
allCategoryFilter,
allApprovalFilter,
issueFilters,
]),
[
allApprovalFilter,
allCategoryFilter,
groupBy,
issueFilters,
nestingEnabled,
normalizedSearchQuery,
selectedCompanyId,
tab,
],
);
// Adopt the fresh order in the SAME render the view identity changes, so a
// section key shared between the two views never briefly shows the previous
// view's order before the hook's passive commit effect runs.
const previousInboxSortViewIdentityRef = useRef(inboxSortViewIdentity);
if (previousInboxSortViewIdentityRef.current !== inboxSortViewIdentity) {
previousInboxSortViewIdentityRef.current = inboxSortViewIdentity;
orderCommitRequestedRef.current = true;
}
const groupedSections = useMemo<InboxGroupedSection[]>(() => {
const nowMs = Date.now();
// An attention boundary (or a view change) fired: adopt the fresh order
// wholesale and re-pin it.
if (orderCommitRequestedRef.current) {
orderCommitRequestedRef.current = false;
orderPinRef.current = captureInboxOrderPin(freshGroupedSections);
return freshGroupedSections;
}
const { sections, pin } = reconcileInboxOrderPin(orderPinRef.current, freshGroupedSections, nowMs);
orderPinRef.current = pin;
return sections;
// orderCommitToken forces re-adoption at a commit boundary; inboxSortViewIdentity
// forces it on a view change even when the fresh sections keep their identity.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [freshGroupedSections, inboxSortViewIdentity, orderCommitToken]);
const inboxSortAttention = useInboxSortAttention({
viewIdentity: inboxSortViewIdentity,
onCommit: commitInboxOrder,
});
const noteInboxSortInteraction = inboxSortAttention.noteInteraction;
const openCreateIssueForGroup = useCallback((group: InboxGroupedSection) => {
const defaults = buildInboxIssueGroupCreateDefaults(
group.key,
groupBy,
group.displayItems,
inboxWorkspaceGrouping,
);
if (!defaults) return;
openNewIssue(defaults);
}, [groupBy, inboxWorkspaceGrouping, openNewIssue]);
const totalVisibleWorkItems = useMemo(
() => groupedSections.reduce((count, group) => count + group.displayItems.length, 0),
[groupedSections],
);
const toggleInboxParentCollapse = useCallback((parentId: string) => {
setCollapsedInboxParents((prev) => {
const next = new Set(prev);
if (next.has(parentId)) next.delete(parentId);
else next.add(parentId);
saveCollapsedInboxParentIds(selectedCompanyId, next);
return next;
});
}, [selectedCompanyId]);
const setInboxParentCollapsed = useCallback((parentId: string, collapsed: boolean) => {
setCollapsedInboxParents((prev) => {
if (prev.has(parentId) === collapsed) return prev;
const next = new Set(prev);
if (collapsed) next.add(parentId);
else next.delete(parentId);
saveCollapsedInboxParentIds(selectedCompanyId, next);
return next;
});
}, [selectedCompanyId]);
// Build flat navigation list from visible rows so keyboard traversal respects collapsed groups.
const flatNavItems = useMemo((): NavEntry[] => {
return buildInboxKeyboardNavEntries(groupedSections, collapsedGroupKeys, collapsedInboxParents);
}, [collapsedGroupKeys, collapsedInboxParents, groupedSections]);
// Read the current nav list from event handlers without recreating them (and
// without capturing a stale array), so hover can resolve the row's key.
const flatNavItemsRef = useRef(flatNavItems);
flatNavItemsRef.current = flatNavItems;
// Roll live descendant runs up to their ancestors across the loaded inbox tree
// so a parent that is not itself live can still surface "n live below".
const subtreeCounts = useMemo(() => {
const nodes: { id: string; parentId: string | null }[] = [];
const seen = new Set<string>();
const pushIssue = (issue: Issue) => {
if (seen.has(issue.id)) return;
seen.add(issue.id);
nodes.push({ id: issue.id, parentId: issue.parentId });
};
for (const group of groupedSections) {
for (const item of group.displayItems) {
if (item.kind === "issue") pushIssue(item.issue);
}
for (const children of group.childrenByIssueId.values()) {
for (const child of children) pushIssue(child);
}
}
return {
live: collectSubtreeLiveCounts(nodes, liveIssueIds),
running: collectSubtreeLiveCounts(nodes, liveIssueIds, { startedOnly: true }),
};
}, [groupedSections, liveIssueIds]);
const subtreeLiveCounts = subtreeCounts.live;
const topFlatIndex = useMemo(() => {
const map = new Map<string, number>();
flatNavItems.forEach((entry, index) => {
if (entry.type === "top") map.set(entry.itemKey, index);
});
return map;
}, [flatNavItems]);
const childFlatIndex = useMemo(() => {
const map = new Map<string, number>();
flatNavItems.forEach((entry, index) => {
if (entry.type === "child") map.set(entry.issueId, index);
});
return map;
}, [flatNavItems]);
const groupFlatIndex = useMemo(() => {
const map = new Map<string, number>();
flatNavItems.forEach((entry, index) => {
if (entry.type === "group") map.set(entry.groupKey, index);
});
return map;
}, [flatNavItems]);
const agentName = (id: string | null) => {
if (!id) return null;
return agentById.get(id) ?? null;
};
const setIssueColumns = useCallback((next: InboxIssueColumn[]) => {
const normalized = normalizeInboxIssueColumns(next);
setVisibleIssueColumns(normalized);
saveTaskCollectionPreferences(inboxCollectionPreferenceLocation(selectedCompanyId), {
viewState: filterPreferences,
columns: normalized,
});
}, [filterPreferences, selectedCompanyId]);
const toggleIssueColumn = useCallback((column: InboxIssueColumn, enabled: boolean) => {
if (enabled) {
setIssueColumns([...visibleIssueColumns, column]);
return;
}
setIssueColumns(visibleIssueColumns.filter((value) => value !== column));
}, [setIssueColumns, visibleIssueColumns]);
const updateFilterPreferences = useCallback(
(updater: (previous: StreamlinedInboxViewState) => StreamlinedInboxViewState) => {
setFilterPreferences((previous) => {
const next = updater(previous);
saveTaskCollectionPreferences(inboxCollectionPreferenceLocation(selectedCompanyId), {
viewState: next,
columns: visibleIssueColumns,
});
return next;
});
},
[selectedCompanyId, visibleIssueColumns],
);
const updateIssueFilters = useCallback((patch: Partial<IssueFilterState>) => {
updateFilterPreferences((previous) => ({
...previous,
issueFilters: { ...previous.issueFilters, ...patch },
}));
}, [updateFilterPreferences]);
useEffect(() => {
if (!experimentalSettingsLoaded || externalObjectsEnabled || issueFilters.externalObjectStatuses.length === 0) return;
updateIssueFilters({ externalObjectStatuses: [] });
}, [
experimentalSettingsLoaded,
externalObjectsEnabled,
issueFilters.externalObjectStatuses.length,
updateIssueFilters,
]);
const updateAllCategoryFilter = useCallback((value: InboxCategoryFilter) => {
updateFilterPreferences((previous) => ({ ...previous, allCategoryFilter: value }));
}, [updateFilterPreferences]);
const updateAllApprovalFilter = useCallback((value: InboxApprovalFilter) => {
updateFilterPreferences((previous) => ({ ...previous, allApprovalFilter: value }));
}, [updateFilterPreferences]);
const updateGroupBy = useCallback((nextGroupBy: InboxWorkItemGroupBy) => {
setGroupBy(nextGroupBy);
saveInboxWorkItemGroupBy(nextGroupBy);
}, []);
const approveMutation = useMutation({
mutationFn: (id: string) => approvalsApi.approve(id),
onSuccess: (_approval, id) => {
setActionError(null);
queryClient.invalidateQueries({ queryKey: queryKeys.approvals.list(selectedCompanyId!) });
navigate(`/approvals/${id}?resolved=approved`);
},
onError: (err) => {
setActionError(describeError(err, { action: "approve this request" }).body);
},
});
const rejectMutation = useMutation({
mutationFn: (id: string) => approvalsApi.reject(id),
onSuccess: () => {
setActionError(null);
queryClient.invalidateQueries({ queryKey: queryKeys.approvals.list(selectedCompanyId!) });
},
onError: (err) => {
setActionError(describeError(err, { action: "reject this request" }).body);
},
});
const approveJoinMutation = useMutation({
mutationFn: (joinRequest: JoinRequest) =>
accessApi.approveJoinRequest(selectedCompanyId!, joinRequest.id),
onSuccess: () => {
setActionError(null);
queryClient.invalidateQueries({ queryKey: queryKeys.access.joinRequests(selectedCompanyId!) });
queryClient.invalidateQueries({ queryKey: queryKeys.sidebarBadges(selectedCompanyId!) });
queryClient.invalidateQueries({ queryKey: queryKeys.agents.list(selectedCompanyId!) });
queryClient.invalidateQueries({ queryKey: queryKeys.companies.all });
},
onError: (err) => {
setActionError(describeError(err).body);
},
});
const rejectJoinMutation = useMutation({
mutationFn: (joinRequest: JoinRequest) =>
accessApi.rejectJoinRequest(selectedCompanyId!, joinRequest.id),
onSuccess: () => {
setActionError(null);
queryClient.invalidateQueries({ queryKey: queryKeys.access.joinRequests(selectedCompanyId!) });
queryClient.invalidateQueries({ queryKey: queryKeys.sidebarBadges(selectedCompanyId!) });
},
onError: (err) => {
setActionError(describeError(err).body);
},
});
const [retryingRunIds, setRetryingRunIds] = useState<Set<string>>(new Set());
const retryRequestKeys = useRef(new Map<string, string>());
const retryRunMutation = useMutation({
mutationFn: async (run: HeartbeatRun) => {
const issueId = readIssueIdFromRun(run);
if (issueId) {
let idempotencyKey = retryRequestKeys.current.get(run.id);
if (!idempotencyKey) {
idempotencyKey = crypto.randomUUID();
retryRequestKeys.current.set(run.id, idempotencyKey);
}
const result = await issuesApi.retryTask(issueId, { idempotencyKey, observedRunId: run.id }).catch(error => {
if (error instanceof ApiError && error.status >= 400 && error.status < 500)
retryRequestKeys.current.delete(run.id);
throw error;
});
queryClient.setQueryData<Issue>(queryKeys.issues.detail(issueId), current =>
current ? { ...current, interruption: result.presentation } : current);
const notStarted = taskRetryNotStartedReason(result);
if (notStarted) {
retryRequestKeys.current.delete(run.id);
await Promise.all([queryKeys.issues.listMineByMe(run.companyId), queryKeys.heartbeats(run.companyId),
queryKeys.heartbeats(run.companyId, run.agentId)].map(queryKey => queryClient.invalidateQueries({ queryKey })));
throw new Error(notStarted);
}
return { newRun: { runId: null, issueId }, originalRun: run };
}
const result = await agentsApi.retryFailedRun(
run.agentId,
run.id,
run.companyId,
);
return { newRun: result, originalRun: run };
},
onMutate: (run) => {
setRetryingRunIds((prev) => new Set(prev).add(run.id));
},
onSuccess: ({ newRun, originalRun }) => {
retryRequestKeys.current.delete(originalRun.id);
queryClient.invalidateQueries({ queryKey: queryKeys.issues.listMineByMe(originalRun.companyId) });
queryClient.invalidateQueries({ queryKey: queryKeys.heartbeats(originalRun.companyId) });
queryClient.invalidateQueries({ queryKey: queryKeys.heartbeats(originalRun.companyId, originalRun.agentId) });
if (newRun.runId)
navigate(`/agents/${originalRun.agentId}/runs/${newRun.runId}`);
else if (newRun.issueId) navigate(`/issues/${newRun.issueId}`);
},
onError: (error) => {
pushToast({
title: "Run retry failed",
body: error instanceof Error ? error.message : "Unable to retry run",
tone: "error",
});
},
onSettled: (_data, _error, run) => {
if (!run) return;
setRetryingRunIds((prev) => {
const next = new Set(prev);
next.delete(run.id);
return next;
});
},
});
const [fadingOutIssues, setFadingOutIssues] = useState<Set<string>>(new Set());
const [showMarkAllReadConfirm, setShowMarkAllReadConfirm] = useState(false);
const [fadingNonIssueItems, setFadingNonIssueItems] = useState<Set<string>>(new Set());
const [archivingNonIssueIds, setArchivingNonIssueIds] = useState<Set<string>>(new Set());
const [selectedIndex, setSelectedIndex] = useState<number>(-1);
const listRef = useRef<HTMLDivElement>(null);
// Keyboard nav scrolls the list, which fires mouseenter on whatever row lands
// under the stationary cursor — that must not steal the selection. Hover only
// selects after the pointer has physically moved since the last key nav.
const pointerMovedSinceKeyNavRef = useRef(true);
useEffect(() => {
const handlePointerMove = () => {
pointerMovedSinceKeyNavRef.current = true;
};
window.addEventListener("mousemove", handlePointerMove, { passive: true });
return () => window.removeEventListener("mousemove", handlePointerMove);
}, []);
// Which row the cursor is over, tracked WITHOUT React state so scrubbing the
// list costs zero re-renders (hover paints via CSS `:hover`, see IssueRow).
// Keyboard nav reads this to continue from the hovered row.
const hoveredIndexRef = useRef<number | null>(null);
// The hovered row's stable key, kept alongside the numeric index so a poll
// that reshapes the list can re-anchor the hover to the same row instead of
// dropping it (which stranded j/k back at the top — PAP-9679 regression).
const hoveredNavKeyRef = useRef<string | null>(null);
const setSelectedIndexFromPointer = useCallback((idx: number) => {
if (!pointerMovedSinceKeyNavRef.current) return;
noteInboxSortInteraction();
hoveredIndexRef.current = idx;
hoveredNavKeyRef.current = navEntryKey(flatNavItemsRef.current[idx]);
// Drop any keyboard selection band the moment the mouse takes over, so we
// never show two identical highlights at once. React bails out when the
// value is already -1, so continuous hovering triggers no re-render.
setSelectedIndex((prev) => (prev < 0 ? prev : -1));
}, [noteInboxSortInteraction]);
const invalidateInboxIssueQueryCaches = () => {
if (!selectedCompanyId) return;
invalidateInboxIssueQueries(queryClient, selectedCompanyId);
};
const archiveIssueMutation = useMutation({
mutationFn: (id: string) => issuesApi.archiveFromInbox(id),
onMutate: async (id) => {
// Keep the sort pinned: archiving is engagement, so defer any idle re-sort.
noteInboxSortInteraction();
setActionError(null);
setArchivingIssueIds((prev) => new Set(prev).add(id));
if (!selectedCompanyId) return { previousData: [] as InboxIssueCacheSnapshot };
beginLocalInboxArchive(selectedCompanyId, id);
await cancelInboxIssueQueries(queryClient, selectedCompanyId);
const previousData = snapshotInboxIssueCaches(queryClient, selectedCompanyId);
removeIssueFromInboxCaches(queryClient, selectedCompanyId, id);
return { companyId: selectedCompanyId, previousData };
},
onError: (err, id, context) => {
setActionError(describeError(err).body);
if (context?.companyId) clearLocalInboxArchive(context.companyId, id);
setArchivingIssueIds((prev) => {
const next = new Set(prev);
next.delete(id);
return next;
});
// Restore only this failed archive so overlapping archive mutations stay removed.
if (context?.previousData) {
restoreIssueToInboxCaches(queryClient, context.previousData, id);
}
},
onSettled: async (_data, error, id, context) => {
// Clean up archiving state and refetch to sync with server
setArchivingIssueIds((prev) => {
const next = new Set(prev);
next.delete(id);
return next;
});
if (!context?.companyId) return;
if (!error) boundLocalInboxArchive(context.companyId, id);
await invalidateInboxIssueQueries(queryClient, context.companyId);
if (!error) {
const presence = getIssuePresenceInActiveInboxCaches(queryClient, context.companyId, id);
if (presence !== "unknown") confirmLocalInboxArchive(context.companyId, id);
}
},
onSuccess: (_data, id) => {
setUndoableArchiveIssueIds((prev) => [...prev.filter((issueId) => issueId !== id), id]);
},
});
const unarchiveIssueMutation = useMutation({
mutationFn: (id: string) => issuesApi.unarchiveFromInbox(id),
onMutate: (id) => {
setActionError(null);
setUnarchivingIssueIds((prev) => new Set(prev).add(id));
if (selectedCompanyId) clearLocalInboxArchive(selectedCompanyId, id);
return { companyId: selectedCompanyId };
},
onError: (err, id, context) => {
setActionError(describeError(err).body);
if (context?.companyId) {
beginLocalInboxArchive(context.companyId, id);
boundLocalInboxArchive(context.companyId, id);
}
},
onSuccess: (_data, id) => {
setUndoableArchiveIssueIds((prev) => {
const next = prev.filter((issueId) => issueId !== id);
return next;
});
},
onSettled: (_data, _error, id) => {
setUnarchivingIssueIds((prev) => {
const next = new Set(prev);
next.delete(id);
return next;
});
invalidateInboxIssueQueryCaches();
},
});
const markReadMutation = useMutation({
mutationFn: (id: string) => issuesApi.markRead(id),
onMutate: (id) => {
setFadingOutIssues((prev) => new Set(prev).add(id));
},
onSuccess: () => {
invalidateInboxIssueQueryCaches();
},
onSettled: (_data, _error, id) => {
setTimeout(() => {
setFadingOutIssues((prev) => {
const next = new Set(prev);
next.delete(id);
return next;
});
}, 300);
},
});
const markAllReadMutation = useMutation({
mutationFn: async (issueIds: string[]) => {
await Promise.all(issueIds.map((issueId) => issuesApi.markRead(issueId)));
},
onMutate: (issueIds) => {
setFadingOutIssues((prev) => {
const next = new Set(prev);
for (const issueId of issueIds) next.add(issueId);
return next;
});
},
onSuccess: () => {
invalidateInboxIssueQueryCaches();
},
onSettled: (_data, _error, issueIds) => {
setTimeout(() => {
setFadingOutIssues((prev) => {
const next = new Set(prev);
for (const issueId of issueIds) next.delete(issueId);
return next;
});
}, 300);
},
});
const markUnreadMutation = useMutation({
mutationFn: (id: string) => issuesApi.markUnread(id),
onSuccess: () => {
invalidateInboxIssueQueryCaches();
},
});
const handleMarkNonIssueRead = useCallback((key: string) => {
setFadingNonIssueItems((prev) => new Set(prev).add(key));
markItemRead(key);
setTimeout(() => {
setFadingNonIssueItems((prev) => {
const next = new Set(prev);
next.delete(key);
return next;
});
}, 300);
}, [markItemRead]);
const handleArchiveNonIssue = useCallback((key: string) => {
noteInboxSortInteraction();
setArchivingNonIssueIds((prev) => new Set(prev).add(key));
setTimeout(() => {
if (key.startsWith("alert:")) {
dismissAlert(key);
} else {
dismissInboxItem(key);
}
setArchivingNonIssueIds((prev) => {
const next = new Set(prev);
next.delete(key);
return next;
});
}, 200);
}, [dismissAlert, dismissInboxItem, noteInboxSortInteraction]);
const nonIssueUnreadState = (key: string): NonIssueUnreadState => {
if (!canArchiveFromTab) return null;
const isRead = readItems.has(key);
const isFading = fadingNonIssueItems.has(key);
if (isFading) return "fading";
if (!isRead) return "visible";
return "hidden";
};
// Keep selection on the same logical item when the list shape changes —
// rows archived/refreshed above the selection would otherwise shift the
// numeric index onto a neighboring row (and Enter would open the wrong
// task). Falls back to clamping when the item is gone; never auto-selects
// on initial load.
const selectedNavKeyRef = useRef<string | null>(null);
useEffect(() => {
// A reshaped list invalidates the numeric hover index. Re-anchor it to the
// same row by key (the inbox polls constantly, so nulling it here silently
// broke hover→j/k sync — PAP-9679). Drop it only when the row is gone.
const hoveredKey = hoveredNavKeyRef.current;
const nextHovered =
hoveredKey === null ? -1 : flatNavItems.findIndex((entry) => navEntryKey(entry) === hoveredKey);
hoveredIndexRef.current = nextHovered >= 0 ? nextHovered : null;
if (nextHovered < 0) hoveredNavKeyRef.current = null;
setSelectedIndex((prev) => {
if (prev < 0) return resolveInboxSelectionIndex(prev, flatNavItems.length);
const prevKey = selectedNavKeyRef.current;
const keyIndex = prevKey === null
? -1
: flatNavItems.findIndex((entry) => navEntryKey(entry) === prevKey);
return keyIndex >= 0 ? keyIndex : resolveInboxSelectionIndex(prev, flatNavItems.length);
});
}, [flatNavItems]);
// Record the selected row's key when the selection moves, or when the
// recorded row has left the list (the re-anchor then falls back to the row now
// at that index, often without changing it). Recording on every list change
// would store the row a refresh inserted above the selection before the
// re-anchor runs, and move the selection onto it.
const recordedSelectedIndexRef = useRef(selectedIndex);
useEffect(() => {
const recordedKey = selectedNavKeyRef.current;
const recordedRowListed = recordedKey !== null && flatNavItems.some((entry) => navEntryKey(entry) === recordedKey);
if (selectedIndex === recordedSelectedIndexRef.current && recordedRowListed) return;
recordedSelectedIndexRef.current = selectedIndex;
selectedNavKeyRef.current = selectedIndex >= 0 ? navEntryKey(flatNavItems[selectedIndex]) : null;
}, [flatNavItems, selectedIndex]);
useEffect(() => {
setUndoableArchiveIssueIds((prev) =>
prev.filter((issueId) => guardedArchiveIssueIds.has(issueId) || unarchivingIssueIds.has(issueId)),
);
}, [guardedArchiveIssueIds, unarchivingIssueIds]);
useEffect(() => {
setUndoableArchiveIssueIds([]);
setUnarchivingIssueIds(new Set());
}, [selectedCompanyId]);
// Use refs for keyboard handler to avoid stale closures
const kbStateRef = useRef({
workItems: groupedSections,
flatNavItems,
selectedIndex,
canArchive: canArchiveFromTab,
nonInboxSearchIssueIds,
archivingIssueIds,
undoableArchiveIssueIds,
unarchivingIssueIds,
archivingNonIssueIds,
fadingOutIssues,
readItems,
});
kbStateRef.current = {
workItems: groupedSections,
flatNavItems,
selectedIndex,
canArchive: canArchiveFromTab,
nonInboxSearchIssueIds,
archivingIssueIds,
undoableArchiveIssueIds,
unarchivingIssueIds,
archivingNonIssueIds,
fadingOutIssues,
readItems,
};
const kbActionsRef = useRef({
archiveIssue: (id: string) => archiveIssueMutation.mutate(id),
undoArchiveIssue: (id: string) => unarchiveIssueMutation.mutate(id),
archiveNonIssue: handleArchiveNonIssue,
markRead: (id: string) => markReadMutation.mutate(id),
markUnreadIssue: (id: string) => markUnreadMutation.mutate(id),
markNonIssueRead: handleMarkNonIssueRead,
markNonIssueUnread: markItemUnread,
setGroupCollapsed,
setInboxParentCollapsed,
navigate,
});
kbActionsRef.current = {
archiveIssue: (id: string) => archiveIssueMutation.mutate(id),
undoArchiveIssue: (id: string) => unarchiveIssueMutation.mutate(id),
archiveNonIssue: handleArchiveNonIssue,
markRead: (id: string) => markReadMutation.mutate(id),
markUnreadIssue: (id: string) => markUnreadMutation.mutate(id),
markNonIssueRead: handleMarkNonIssueRead,
markNonIssueUnread: markItemUnread,
setGroupCollapsed,
setInboxParentCollapsed,
navigate,
};
// Keyboard shortcuts (mail-client style) — single stable listener using refs
useEffect(() => {
const handleKeyDown = (e: KeyboardEvent) => {
if (e.defaultPrevented) return;
// Don't capture when typing in inputs/textareas or with modifier keys
const target = e.target;
if (
!(target instanceof HTMLElement) ||
isKeyboardShortcutTextInputTarget(target) ||
hasBlockingShortcutDialog(document) ||
e.metaKey ||
e.ctrlKey ||
e.altKey
) {
return;
}
const st = kbStateRef.current;
const act = kbActionsRef.current;
// Navigation works on every tab; archive/undo (and a/y below) stay
// scoped to the "mine" tab, the only place items are archivable.
const undoArchiveAction = !st.canArchive ? "none" : resolveInboxUndoArchiveKeyAction({
hasUndoableArchive: st.undoableArchiveIssueIds.length > 0,
defaultPrevented: e.defaultPrevented,
key: e.key,
metaKey: e.metaKey,
ctrlKey: e.ctrlKey,
altKey: e.altKey,
target,
hasOpenDialog: hasBlockingShortcutDialog(document),
});
if (undoArchiveAction === "undo_archive") {
const issueId = st.undoableArchiveIssueIds[st.undoableArchiveIssueIds.length - 1];
if (!issueId || st.unarchivingIssueIds.has(issueId)) return;
e.preventDefault();
act.undoArchiveIssue(issueId);
return;
}
const navItems = st.flatNavItems;
const navCount = navItems.length;
if (navCount === 0) return;
// Any inbox keystroke (nav, archive, undo) is engagement: hold the sort.
noteInboxSortInteraction();
/** Resolve the nav entry at an index to an issue (for child entries) or work item. */
const resolveNavEntry = (idx: number): { issue?: Issue; item?: InboxWorkItem } => {
const entry = navItems[idx];
if (!entry) return {};
if (entry.type === "child") return { issue: entry.issue };
if (entry.type === "top") return { item: entry.item };
return {};
};
// The row a keystroke acts on: the hovered row when the mouse has moved
// since the last key nav (so "hover a row → press a/r/Enter/Arrow" acts on
// it), otherwise the keyboard selection. Hover no longer writes selection
// state, so this is what threads the pointer position into every handler.
const rawHovered = hoveredIndexRef.current;
const hoveredIndex = rawHovered != null && rawHovered >= 0 && rawHovered < navCount ? rawHovered : -1;
const fromHover = pointerMovedSinceKeyNavRef.current && hoveredIndex >= 0;
const effectiveIndex = fromHover ? hoveredIndex : st.selectedIndex;
switch (e.key) {
case "j":
case "ArrowDown": {
e.preventDefault();
pointerMovedSinceKeyNavRef.current = false;
setSelectedIndex(getInboxKeyboardSelectionIndex(effectiveIndex, navCount, "next"));
break;
}
case "k":
case "ArrowUp": {
e.preventDefault();
pointerMovedSinceKeyNavRef.current = false;
setSelectedIndex(getInboxKeyboardSelectionIndex(effectiveIndex, navCount, "previous"));
break;
}
case "ArrowLeft":
case "ArrowRight": {
if (effectiveIndex < 0 || effectiveIndex >= navCount) return;
const entry = navItems[effectiveIndex];
if (!entry) return;
if (entry.type === "group") {
e.preventDefault();
pointerMovedSinceKeyNavRef.current = false;
setSelectedIndex(effectiveIndex);
act.setGroupCollapsed(entry.groupKey, e.key === "ArrowLeft");
break;
}
// Parent tasks collapse/expand with the same keys as groups.
const { issue, item } = resolveNavEntry(effectiveIndex);
const targetIssue = issue ?? (item?.kind === "issue" ? item.issue : null);
if (!targetIssue) return;
const hasChildren = st.workItems.some(
(group) => (group.childrenByIssueId.get(targetIssue.id)?.length ?? 0) > 0,
);
if (!hasChildren) return;
e.preventDefault();
pointerMovedSinceKeyNavRef.current = false;
setSelectedIndex(effectiveIndex);
act.setInboxParentCollapsed(targetIssue.id, e.key === "ArrowLeft");
break;
}
case "a":
case "y": {
if (!st.canArchive) return;
if (effectiveIndex < 0 || effectiveIndex >= navCount) return;
e.preventDefault();
const { issue, item } = resolveNavEntry(effectiveIndex);
if (issue) {
if (!st.nonInboxSearchIssueIds.has(issue.id) && !st.archivingIssueIds.has(issue.id)) act.archiveIssue(issue.id);
} else if (item) {
if (item.kind === "issue") {
if (!st.nonInboxSearchIssueIds.has(item.issue.id) && !st.archivingIssueIds.has(item.issue.id)) {
act.archiveIssue(item.issue.id);
}
} else {
const key = getInboxWorkItemKey(item);
if (!st.archivingNonIssueIds.has(key)) act.archiveNonIssue(key);
}
}
break;
}
case "U": {
if (!st.canArchive) return;
if (effectiveIndex < 0 || effectiveIndex >= navCount) return;
e.preventDefault();
const { issue, item } = resolveNavEntry(effectiveIndex);
if (issue) {
act.markUnreadIssue(issue.id);
} else if (item) {
if (item.kind === "issue") act.markUnreadIssue(item.issue.id);
else act.markNonIssueUnread(getInboxWorkItemKey(item));
}
break;
}
case "r": {
if (!st.canArchive) return;
if (effectiveIndex < 0 || effectiveIndex >= navCount) return;
e.preventDefault();
const { issue, item } = resolveNavEntry(effectiveIndex);
if (issue) {
if (issue.isUnreadForMe && !st.fadingOutIssues.has(issue.id)) act.markRead(issue.id);
} else if (item) {
if (item.kind === "issue") {
if (item.issue.isUnreadForMe && !st.fadingOutIssues.has(item.issue.id)) act.markRead(item.issue.id);
} else {
const key = getInboxWorkItemKey(item);
if (!st.readItems.has(key)) act.markNonIssueRead(key);
}
}
break;
}
case "Enter": {
if (effectiveIndex < 0 || effectiveIndex >= navCount) return;
e.preventDefault();
const { issue, item } = resolveNavEntry(effectiveIndex);
if (issue) {
const pathId = issue.identifier ?? issue.id;
const detailState = armIssueDetailInboxQuickArchive(withIssueDetailHeaderSeed(issueLinkState, issue));
rememberIssueDetailLocationState(pathId, detailState);
void prefetchIssueDetailForNavigation(queryClient, pathId, { issue, history: true });
act.navigate(createIssueDetailPath(pathId), { state: detailState });
} else if (item) {
if (item.kind === "issue") {
const pathId = item.issue.identifier ?? item.issue.id;
const detailState = armIssueDetailInboxQuickArchive(
withIssueDetailHeaderSeed(issueLinkState, item.issue),
);
rememberIssueDetailLocationState(pathId, detailState);
void prefetchIssueDetailForNavigation(queryClient, pathId, { issue: item.issue, history: true });
act.navigate(createIssueDetailPath(pathId), { state: detailState });
} else if (item.kind === "approval") {
act.navigate(`/approvals/${item.approval.id}`);
} else if (item.kind === "failed_run") {
act.navigate(`/agents/${item.run.agentId}/runs/${item.run.id}`);
}
}
break;
}
default:
return;
}
};
window.addEventListener("keydown", handleKeyDown);
return () => window.removeEventListener("keydown", handleKeyDown);
}, [issueLinkState, noteInboxSortInteraction]);
// Scroll selected item into view
useEffect(() => {
if (selectedIndex < 0 || !listRef.current) return;
const rows = listRef.current.querySelectorAll("[data-inbox-item]");
const row = rows[selectedIndex];
if (row) row.scrollIntoView({ block: "nearest" });
}, [selectedIndex]);
const hasRunFailures = failedRuns.length > 0;
const showCompanyAlerts = shouldShowCompanyAlerts(tab) && showAlertsCategory;
const showAggregateAgentError =
showCompanyAlerts &&
!!dashboard &&
dashboard.agents.error > 0 &&
!hasRunFailures &&
!dismissedAlerts.has("alert:agent-errors");
const showBudgetAlert =
showCompanyAlerts &&
!!dashboard &&
dashboard.costs.monthBudgetCents > 0 &&
dashboard.costs.monthUtilizationPercent >= 80 &&
!dismissedAlerts.has("alert:budget");
const hasAlerts = showAggregateAgentError || showBudgetAlert;
const showWorkItemsSection = totalVisibleWorkItems > 0;
const showAlertsSection = shouldShowInboxSection({
tab,
hasItems: hasAlerts,
showOnMine: false,
showOnRecent: false,
showOnUnread: false,
showOnAll: hasAlerts,
});
const visibleSections = [
showAlertsSection ? "alerts" : null,
showWorkItemsSection ? "work_items" : null,
].filter((key): key is SectionKey => key !== null);
// Workspace names change what rows show (grouping, the Workspace column) or which rows match a
// search, so wait for them only then; otherwise rows reveal without the workspace read.
const workspaceDataAffectsRows = groupBy === "workspace"
|| (visibleIssueColumnSet.has("workspace") && availableIssueColumnSet.has("workspace"))
|| normalizedSearchQuery.length > 0;
// Approvals and join requests sort in among task rows by time, so a late arrival would push
// rows down. Wait for their first bounded attempt only; a failure or timeout reveals rows.
const approvalsAffectRows = tab !== "blocked" && (tab !== "all" || showApprovalsCategory);
const joinRequestsAffectRows = tab !== "blocked" && (tab !== "all" || showJoinRequestsCategory);
// Saved values from the last visit answer this wait on a returning visit.
const isApprovalsFirstAttemptPending = isApprovalsLoading && approvalsFailureCount === 0 && !approvalsFromSaved;
const isJoinRequestsFirstAttemptPending = isJoinRequestsLoading && joinRequestsFailureCount === 0 && !joinRequestsFromSaved;
// User names only fill row text, except when they name and order assignee groups.
const userLabelsAffectRows = groupBy === "assignee";
const isMembersFirstAttemptPending = isMembersLoading && membersFailureCount === 0;
const initialSourcesSettled =
![sourceSearchView, mineIssuesView, touchedIssuesView].some(view => view.kind === "reconnecting") &&
!isSourceSearchLoading && !isSessionLoading && !isSettingsLoading && !isDismissalsLoading && !isAgentsLoading && !isProjectsLoading &&
!(userLabelsAffectRows && isMembersFirstAttemptPending) &&
// Previous summaries stand in while a new id set loads; they may lack the new view's workspaces.
!(workspaceDataAffectsRows && workspaceLookupEnabled && (isWorkspacesLoading || isWorkspacesPlaceholder)) &&
!(joinRequestsAffectRows && isJoinRequestsFirstAttemptPending) &&
!(approvalsAffectRows && isApprovalsFirstAttemptPending) &&
!isDashboardLoading &&
!isContextIssuesLoading &&
!isContextIssuesPlaceholder &&
!isMineIssuesLoading &&
!isTouchedIssuesLoading &&
!isRunsLoading
&& (!issueFilters.liveOnly || !isLiveRunsLoading)
&& (issueFilters.externalObjectStatuses.length === 0 || externalObjectSummariesReady || !!externalObjectSummariesError);
const sourceView = tab === "mine" ? mineIssuesView : touchedIssuesView;
const listError = (sourceSearchView.kind === "error" ? sourceSearchError : null)
?? (sourceView.kind === "error" ? sourceView.error : null)
?? (issueFilters.externalObjectStatuses.length > 0 ? externalObjectSummariesError : null);
const rawOptionalSourceError = dismissalsError ?? approvalsError ?? joinRequestsError ?? runsError ?? contextIssuesError
?? (tab === "mine" ? mineIssuesError : touchedIssuesError);
// A query error means retries are over. Transient errors usually clear on their own, but a read
// that keeps hitting the inbox timeout leaves items missing, so say so and offer a retry.
const optionalReadTimeoutError = [approvalsError, joinRequestsError]
.find((error) => errorCodes(error).includes("TIMEOUT")) ?? null;
const optionalSourceError = optionalReadTimeoutError
?? (isTransientError(rawOptionalSourceError) ? null : rawOptionalSourceError);
const retryFailedSources = () => {
// Optional failures belong to the aggregate read, whose task rows stay usable.
if (tab === "mine" && (mineSnapshot?.failureError || mineSnapshot?.contextError)) {
void queryClient.refetchQueries({ queryKey: mineIssuesQueryKey, exact: true });
}
// Retry only failed reads for this company; settled rows stay visible.
void queryClient.refetchQueries({ predicate: (query) => query.state.status === "error"
&& query.queryKey.includes(selectedCompanyId), type: "active" });
};
const revealScope = JSON.stringify([currentUserId, selectedCompanyId, tab, normalizedSearchQuery, issueFilters]);
const [revealedScope, setRevealedScope] = useState<string | null>(null);
useEffect(() => {
if (initialSourcesSettled && !listError) setRevealedScope(revealScope);
}, [initialSourcesSettled, listError, revealScope]);
const allLoaded = initialSourcesSettled || revealedScope === revealScope;
useWarmTaskDetailCode(allLoaded && !listError && tab !== "blocked" && showWorkItemsSection);
// Preload the chat of the top visible tasks, in display order, so opening
// one renders its latest messages and composer from cache.
// The walk stops at the preload limit, whatever the size of the Inbox.
const preloadTaskRefs = useMemo(() => topTaskRefs(flatNavItems, inboxNavEntryTask), [flatNavItems]);
usePreloadTaskChats(selectedCompanyId, preloadTaskRefs, allLoaded && !listError && showWorkItemsSection);
const showSeparatorBefore = (key: SectionKey) => visibleSections.indexOf(key) > 0;
const { enrichIssueRow, error: rowDetailsError, retry: retryRowDetails } = useIssueRowDetails(
selectedCompanyId, listRef,
groupedSections.map((group) => group.key + ":" + group.displayItems.map(getInboxWorkItemKey).join(",") + ":" + [...group.childrenByIssueId.values()].flat().map((issue) => issue.id).join(",")).join("|")
+ ":" + [...collapsedInboxParents].join(",") + ":" + [...collapsedGroupKeys].join(","),
allLoaded && !listError && tab !== "blocked",
issues,
);
if (!selectedCompanyId) {
return <EmptyState icon={InboxIcon} message={`Select an organization to view ${surfaceLabel.toLowerCase()}.`} />;
}
const markAllReadIssues = (tab === "mine" ? visibleMineIssues : unreadTouchedIssues)
.filter((issue) => issue.isUnreadForMe && !fadingOutIssues.has(issue.id) && !archivingIssueIds.has(issue.id));
const unreadIssueIds = markAllReadIssues
.map((issue) => issue.id);
const canMarkAllRead = unreadIssueIds.length > 0;
const activeIssueFilterCount = countActiveIssueFilters(issueFilters, true);
const activeInboxScopeFilterCount = tab === "all"
? Number(allCategoryFilter !== "everything")
+ Number(showApprovalsCategory && allApprovalFilter !== "all")
: 0;
const activeFilterCount = activeIssueFilterCount + activeInboxScopeFilterCount;
const showGeneralIssueToolbarControls = tab !== "blocked";
const activeStatusFilterApplied =
issueFilters.statuses.length === 4
&& ["todo", "in_progress", "in_review", "blocked"].every((status) =>
issueFilters.statuses.includes(status as IssueFilterState["statuses"][number]),
);
const issueFilterFeedback = issueFilters.liveOnly
? "Live runs only — tasks currently connected to an agent run."
: activeStatusFilterApplied
? "Active statuses — open tasks, whether or not an agent is running."
: null;
return (
<div className="space-y-6">
<IssueRowDetailsNotice
error={optionalSourceError ?? rowDetailsError}
message={optionalSourceError ? "Some inbox items couldn’t load. Showing available items." : undefined}
retryLabel={optionalSourceError ? "Retry missing items" : undefined}
onRetry={optionalSourceError ? retryFailedSources : () => void retryRowDetails()}
/>
<InboxCollectionToolbar
streamlined={streamlinedUiEnabled}
ariaLabel={`${surfaceLabel} controls`}
context={toolbarContext ?? (
<Tabs value={tab} onValueChange={(value) => navigate(`/inbox/${value}`)}>
<PageTabBar
items={[
{ value: "mine", label: "Mine" },
{ value: "recent", label: "Recent" },
{ value: "unread", label: "Unread" },
{ value: "blocked", label: "Blocked" },
{ value: "all", label: "All" },
]}
/>
</Tabs>
)}
search={(
<div className="relative ml-auto w-full sm:w-(--sz-220px)">
<Search className="pointer-events-none absolute left-2.5 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
<Input
type="search"
placeholder={`Search ${surfaceLabel.toLowerCase()}…`}
value={searchQuery}
onChange={(e) => setSearchQuery(e.target.value)}
onKeyDown={(e) => {
if (shouldBlurPageSearchOnEnter({
key: e.key,
isComposing: e.nativeEvent.isComposing,
})) {
e.currentTarget.blur();
return;
}
if (shouldBlurPageSearchOnEscape({
key: e.key,
isComposing: e.nativeEvent.isComposing,
currentValue: e.currentTarget.value,
})) {
e.currentTarget.blur();
}
}}
className="h-8 w-full pl-8 text-xs"
data-page-search-target="true"
/>
</div>
)}
controls={(
<>
{tab === "blocked" ? (
<>
<IssueFiltersPopover
state={issueFilters}
onChange={updateIssueFilters}
activeFilterCount={activeIssueFilterCount}
agents={agents}
creators={creatorOptions}
projects={projects?.map((project) => ({ id: project.id, name: project.name }))}
labels={labels?.map((label) => ({ id: label.id, name: label.name, color: label.color }))}
currentUserId={currentUserId}
enableExternalObjectFilters={externalObjectsEnabled}
enableAgentCreatedVisibilityFilter
buttonVariant="outline"
iconOnly
presentation={streamlinedUiEnabled ? "streamlined" : "legacy"}
/>
<Popover>
<PopoverTrigger asChild>
<Button
type="button"
variant="outline"
size="icon"
className={cn("h-8 w-8 shrink-0", blockedGroupBy !== "none" && "bg-accent")}
title="Group"
>
<Layers className="h-3.5 w-3.5" />
</Button>
</PopoverTrigger>
<PopoverContent align="end" className="w-44 p-0">
<div className="space-y-0.5 p-2">
{BLOCKED_GROUP_OPTIONS.map(([value, label]) => (
<button
key={value}
type="button"
className={cn(
"flex w-full items-center justify-between rounded-sm px-2 py-1.5 text-sm",
blockedGroupBy === value ? "bg-accent/50 text-foreground" : "text-muted-foreground hover:bg-accent/50",
)}
onClick={() => setBlockedGroupBy(value)}
>
<span>{label}</span>
{blockedGroupBy === value ? <Check className="h-3.5 w-3.5" /> : null}
</button>
))}
</div>
</PopoverContent>
</Popover>
<IssueColumnPicker
availableColumns={availableIssueColumns}
visibleColumnSet={visibleIssueColumnSet}
onToggleColumn={toggleIssueColumn}
showDateGroupSeparators={filterPreferences.showDateGroupSeparators}
onToggleDateGroupSeparators={(enabled) => {
updateFilterPreferences((previous) => ({
...previous,
showDateGroupSeparators: enabled,
}));
}}
onResetColumns={() => setIssueColumns(DEFAULT_INBOX_ISSUE_COLUMNS)}
title="Choose which columns stay visible"
iconOnly
/>
<Popover>
<PopoverTrigger asChild>
<Button
type="button"
variant="outline"
size="icon"
className="h-8 w-8 shrink-0"
title="Sort"
>
<ArrowUpDown className="h-3.5 w-3.5" />
</Button>
</PopoverTrigger>
<PopoverContent align="end" className="w-48 p-0">
<div className="space-y-0.5 p-2">
{BLOCKED_SORT_OPTIONS.map(([value, label]) => (
<button
key={value}
type="button"
className={cn(
"flex w-full items-center justify-between rounded-sm px-2 py-1.5 text-sm",
blockedSortBy === value ? "bg-accent/50 text-foreground" : "text-muted-foreground hover:bg-accent/50",
)}
onClick={() => setBlockedSortBy(value)}
>
<span>{label}</span>
{blockedSortBy === value ? <Check className="h-3.5 w-3.5" /> : null}
</button>
))}
</div>
</PopoverContent>
</Popover>
</>
) : showGeneralIssueToolbarControls ? (
<>
<Button
type="button"
variant="outline"
size="icon"
className={cn("hidden h-8 w-8 shrink-0 sm:inline-flex", nestingEnabled && "bg-accent")}
onClick={toggleNesting}
title={nestingEnabled ? "Disable parent-child nesting" : "Enable parent-child nesting"}
>
<ListTree className="h-3.5 w-3.5" />
</Button>
<IssueFiltersPopover
state={issueFilters}
onChange={updateIssueFilters}
activeFilterCount={activeFilterCount}
agents={agents}
creators={creatorOptions}
projects={projects?.map((project) => ({ id: project.id, name: project.name }))}
labels={labels?.map((label) => ({ id: label.id, name: label.name, color: label.color }))}
currentUserId={currentUserId}
enableExternalObjectFilters={externalObjectsEnabled}
enableAgentCreatedVisibilityFilter
buttonVariant="outline"
iconOnly
presentation={streamlinedUiEnabled ? "streamlined" : "legacy"}
inboxScopeFilters={tab === "all" ? {
category: allCategoryFilter,
approvalStatus: allApprovalFilter,
showApprovalStatus: showApprovalsCategory,
onCategoryChange: updateAllCategoryFilter,
onApprovalStatusChange: updateAllApprovalFilter,
onClear: () => {
updateFilterPreferences((previous) => ({
...previous,
allCategoryFilter: "everything",
allApprovalFilter: "all",
}));
},
} : undefined}
/>
<Popover>
<PopoverTrigger asChild>
<Button
type="button"
variant="outline"
size="icon"
className={cn("h-8 w-8 shrink-0", groupBy !== "none" && "bg-accent")}
title="Group"
>
<Layers className="h-3.5 w-3.5" />
</Button>
</PopoverTrigger>
<PopoverContent align="end" className="w-40 p-2">
<div className="space-y-0.5">
{([
["none", "None"],
["type", "Type"],
["assignee", "Responsible"],
["project", "Project"],
...(isolatedWorkspacesEnabled ? ([["workspace", "Workspace"]] as const) : []),
] as const).map(([value, label]) => (
<button
key={value}
type="button"
className={cn(
"flex w-full items-center justify-between rounded-sm px-2 py-1.5 text-sm",
groupBy === value ? "bg-accent/50 text-foreground" : "text-muted-foreground hover:bg-accent/50",
)}
onClick={() => updateGroupBy(value)}
>
<span>{label}</span>
{groupBy === value ? <Check className="h-3.5 w-3.5" /> : null}
</button>
))}
</div>
</PopoverContent>
</Popover>
<IssueColumnPicker
availableColumns={availableIssueColumns}
visibleColumnSet={visibleIssueColumnSet}
onToggleColumn={toggleIssueColumn}
showDateGroupSeparators={filterPreferences.showDateGroupSeparators}
onToggleDateGroupSeparators={(enabled) => {
updateFilterPreferences((previous) => ({
...previous,
showDateGroupSeparators: enabled,
}));
}}
onResetColumns={() => setIssueColumns(DEFAULT_INBOX_ISSUE_COLUMNS)}
title="Choose which columns stay visible"
iconOnly
rowPresentation={streamlinedUiEnabled ? "task" : "legacy"}
/>
{canMarkAllRead && (
<>
<Button
type="button"
variant="outline"
size="sm"
className="h-8 shrink-0"
onClick={() => setShowMarkAllReadConfirm(true)}
disabled={markAllReadMutation.isPending}
>
{markAllReadMutation.isPending ? "Marking…" : "Mark all as read"}
</Button>
<Dialog open={showMarkAllReadConfirm} onOpenChange={setShowMarkAllReadConfirm}>
<DialogContent className="sm:max-w-md">
<DialogHeader>
<DialogTitle>Mark all as read?</DialogTitle>
<DialogDescription>
This will mark {unreadIssueIds.length} unread {unreadIssueIds.length === 1 ? "item" : "items"} as read.
</DialogDescription>
</DialogHeader>
<DialogFooter>
<Button variant="outline" onClick={() => setShowMarkAllReadConfirm(false)}>
Cancel
</Button>
<Button
onClick={() => {
setShowMarkAllReadConfirm(false);
markAllReadMutation.mutate(unreadIssueIds);
}}
>
Mark all as read
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
</>
)}
</>
) : null}
</>
)}
feedback={issueFilterFeedback ? (
<p className="text-xs text-muted-foreground" data-testid="inbox-filter-scope-feedback">
{issueFilterFeedback}
</p>
) : null}
/>
{listError && (
<div role="alert" className="flex items-center gap-2 text-sm text-destructive">
<p>Unable to load the inbox: {describeError(listError).body}</p>
<Button variant="outline" size="sm" onClick={() => { retryFailedSources(); if (externalObjectSummariesError) retryExternalObjectSummaries(); }}>Retry</Button>
</div>
)}
{actionError && <p className="text-sm text-destructive">{actionError}</p>}
{tab === "blocked" ? (
<div className="-mx-2 sm:mx-0">
<BlockedInboxView
companyId={selectedCompanyId!}
searchQuery={searchQuery}
agentNameById={agentById} agents={agents}
userLabelById={companyUserLabelMap}
issueLinkState={issueLinkState}
groupBy={blockedGroupBy}
sortBy={blockedSortBy}
issueFilters={issueFilters}
currentUserId={currentUserId}
liveIssueIds={liveIssueIds}
subtreeLiveCounts={subtreeLiveCounts}
workspaceFilterContext={inboxWorkspaceGrouping}
showStatusColumn={visibleIssueColumnSet.has("status") && availableIssueColumnSet.has("status")}
showIdentifierColumn={visibleIssueColumnSet.has("id") && availableIssueColumnSet.has("id")}
showUpdatedColumn={visibleIssueColumnSet.has("updated") && availableIssueColumnSet.has("updated")}
presentation={streamlinedUiEnabled ? "task" : "legacy"}
/>
</div>
) : null}
{tab !== "blocked" && !allLoaded && !listError && (
<PageSkeleton variant="inbox" collectionHeading={groupBy !== "none" ? "group" : filterPreferences.showDateGroupSeparators ? "date" : null} />
)}
{tab !== "blocked" && allLoaded && !listError && !optionalSourceError && visibleSections.length === 0 && (
<EmptyState
icon={searchQuery.trim() ? Search : InboxIcon}
message={
searchQuery.trim()
? "No inbox items match your search."
: tab === "mine"
? "Inbox zero."
: tab === "unread"
? "No new inbox items."
: tab === "recent"
? "No recent inbox items."
: "No inbox items match these filters."
}
/>
)}
{tab !== "blocked" && allLoaded && !listError && showWorkItemsSection && (
<>
{showSeparatorBefore("work_items") && <Separator />}
<div>
<div
ref={listRef}
className="-mx-2 overflow-hidden sm:mx-0"
onPointerDownCapture={noteInboxSortInteraction}
onWheelCapture={noteInboxSortInteraction}
>
{(() => {
const renderInboxIssue = ({
issue,
depth,
selected,
hasChildren = false,
isExpanded = false,
childCount = 0,
collapseParentId = null,
allowArchive = canArchiveFromTab,
}: {
issue: Issue;
depth: number;
selected: boolean;
hasChildren?: boolean;
isExpanded?: boolean;
childCount?: number;
collapseParentId?: string | null;
allowArchive?: boolean;
}) => {
issue = enrichIssueRow(issue);
const isUnread = issue.isUnreadForMe && !fadingOutIssues.has(issue.id);
const isFading = fadingOutIssues.has(issue.id);
const isArchiving = archivingIssueIds.has(issue.id);
const project = issue.projectId ? projectById.get(issue.projectId) ?? null : null;
const assigneeUserProfile = issue.assigneeUserId
? companyUserProfileMap.get(issue.assigneeUserId) ?? null
: null;
const originatingActor = deriveOriginatingActor(issue);
const originatingUserId = originatingActor?.kind === "user" ? originatingActor.id : null;
const originatingViaAgentId =
originatingActor?.kind === "user" ? originatingActor.viaAgentId ?? null : null;
const isLive = liveIssueIds.has(issue.id);
const loadedSubtreeLiveCount = subtreeLiveCounts.get(issue.id) ?? 0;
const runningDescendantCount = resolveIssueRunningDescendantCount(issue, subtreeCounts.running.get(issue.id) ?? 0);
const blockerAttention = resolveInboxIssueBlockerAttention(issue, {
isLive,
loadedSubtreeLiveCount,
});
const showStatus = visibleIssueColumnSet.has("status") && availableIssueColumnSet.has("status");
const showSubtreeLiveChip = !(
showStatus
&& issue.status === "blocked"
&& blockerAttention?.state === "covered"
);
const rowStatusIcon = (
<StatusIcon {...taskStatusIconProps(issue)} blockerAttention={blockerAttention} size="md" />
);
return (
<IssueRow
key={`issue:${issue.id}`}
issue={issue}
presentation={streamlinedUiEnabled ? "task" : "legacy"}
stableLayout
issueLinkState={issueLinkState}
treeGuides={depth}
chevronInGuide={streamlinedUiEnabled && depth > 0 && hasChildren}
selected={selected}
className={
isArchiving
? "pointer-events-none -translate-x-4 scale-(--s-0_98) opacity-0 transition-all duration-200 ease-out"
: "transition-all duration-200 ease-out"
}
leadingControl={streamlinedUiEnabled && nestingEnabled && hasChildren && collapseParentId ? (
<button
type="button"
data-slot="icon-button"
className="inline-flex h-4 w-4 shrink-0 items-center justify-center"
aria-label={isExpanded ? "Collapse sub-tasks" : "Expand sub-tasks"}
onClick={(event) => {
event.preventDefault();
event.stopPropagation();
toggleInboxParentCollapse(collapseParentId);
}}
>
<ChevronRight className={cn("h-3.5 w-3.5 transition-transform", isExpanded && "rotate-90")} />
</button>
) : streamlinedUiEnabled ? (
<span data-slot="task-row-disclosure-spacer" className={cn("h-4 w-4 shrink-0", !nestingEnabled && "hidden sm:block")} aria-hidden="true" />
) : undefined}
statusSlot={streamlinedUiEnabled ? rowStatusIcon : undefined}
metadata={streamlinedUiEnabled ? (
<InboxIssueMetaLeading
issue={issue}
isLive={isLive}
waiting={issueWaitingOf(liveIssueIds, issue.id)}
subtreeLiveCount={runningDescendantCount}
showSubtreeLiveChip={showSubtreeLiveChip}
showStatus={false}
showIdentifier={false}
/>
) : undefined}
showIdentifier={streamlinedUiEnabled
? visibleIssueColumnSet.has("id") && availableIssueColumnSet.has("id")
: undefined}
desktopMetaLeading={!streamlinedUiEnabled ? (
<>
{nestingEnabled ? (
depth === 0 && hasChildren && collapseParentId ? (
<button
type="button"
data-slot="icon-button"
className="hidden w-4 shrink-0 items-center justify-center sm:inline-flex"
onClick={(event) => {
event.preventDefault();
event.stopPropagation();
toggleInboxParentCollapse(collapseParentId);
}}
>
<ChevronRight className={cn("h-3.5 w-3.5 transition-transform", isExpanded && "rotate-90")} />
</button>
) : (
<span className="hidden w-4 shrink-0 sm:block" />
)
) : null}
<InboxIssueMetaLeading
issue={issue}
isLive={isLive}
waiting={issueWaitingOf(liveIssueIds, issue.id)}
subtreeLiveCount={runningDescendantCount}
showSubtreeLiveChip={showSubtreeLiveChip}
showStatus={showStatus}
showIdentifier={visibleIssueColumnSet.has("id") && availableIssueColumnSet.has("id")}
statusSlot={rowStatusIcon}
/>
</>
) : undefined}
titleSuffix={hasChildren && !isExpanded ? (
<span className="ml-1.5 text-xs text-muted-foreground">
({childCount} sub-task{childCount !== 1 ? "s" : ""})
</span>
) : undefined}
mobileTitleMeta={streamlinedUiEnabled ? issueActivityTimestamp(issue) : undefined}
mobileMeta={streamlinedUiEnabled ? undefined : issueActivityText(issue).toLowerCase()}
mobileLeading={!streamlinedUiEnabled ? (
depth === 0 && hasChildren && collapseParentId ? (
<button
type="button"
data-slot="icon-button"
onClick={(event) => {
event.preventDefault();
event.stopPropagation();
toggleInboxParentCollapse(collapseParentId);
}}
>
<ChevronRight className={cn("h-3.5 w-3.5 transition-transform", isExpanded && "rotate-90")} />
</button>
) : (
<StatusIcon {...taskStatusIconProps(issue)} blockerAttention={blockerAttention} size="md" />
)
) : undefined}
unreadState={isUnread ? "visible" : isFading ? "fading" : "hidden"}
showUnreadIndicator={false}
onMarkRead={() => markReadMutation.mutate(issue.id)}
onArchive={allowArchive ? () => archiveIssueMutation.mutate(issue.id) : undefined}
archiveDisabled={isArchiving}
desktopTrailing={
(streamlinedUiEnabled ? visibleTaskDataColumns : visibleTrailingIssueColumns).length > 0 ? (
<InboxIssueTrailingColumns
issue={issue}
columns={streamlinedUiEnabled ? visibleTaskDataColumns : visibleTrailingIssueColumns}
projectName={project?.name ?? null}
projectColor={project?.color ?? null}
workspaceName={resolveIssueWorkspaceName(issue, {
executionWorkspaceById,
projectWorkspaceById,
defaultProjectWorkspaceIdByProjectId,
})}
assigneeName={agentName(issue.assigneeAgentId)}
assigneeAgent={agents?.find((agent) => agent.id === issue.assigneeAgentId)}
creatorAgent={agents?.find((agent) => agent.id === issue.createdByAgentId)}
assigneeUserName={
formatAssigneeUserLabel(issue.assigneeUserId, currentUserId, companyUserLabelMap)
?? assigneeUserProfile?.label
?? null
}
assigneeUserAvatarUrl={assigneeUserProfile?.image ?? null}
creatorAgentName={agentName(issue.createdByAgentId)}
creatorUserName={originatingUserId ? (companyUserProfileMap.get(originatingUserId)?.label ?? null) : null}
creatorUserAvatarUrl={originatingUserId ? (companyUserProfileMap.get(originatingUserId)?.image ?? null) : null}
viaAgentName={originatingViaAgentId ? agentName(originatingViaAgentId) : null}
currentUserId={currentUserId}
parentIdentifier={issue.parentId ? (issueById.get(issue.parentId)?.identifier ?? null) : null}
parentTitle={issue.parentId ? (issueById.get(issue.parentId)?.title ?? null) : null}
/>
) : undefined
}
trailingMeta={streamlinedUiEnabled && showTaskTimestamp ? issueActivityTimestamp(issue) : null}
/>
);
};
let previousDateGroup: TaskDateGroup | null = null;
let previousTimestamp = Number.POSITIVE_INFINITY;
const legacyTodayCutoff = Date.now() - 24 * 60 * 60 * 1000;
return groupedSections.flatMap((group, groupIndex) => {
const elements: ReactNode[] = [];
const isGroupCollapsed = collapsedGroupKeys.has(group.key);
if (
group.searchSection !== "none"
&& group.searchSection !== groupedSections[groupIndex - 1]?.searchSection
) {
elements.push(
<div
key={`${group.searchSection}-search-divider`}
className="flex items-center gap-3 border-y border-border/70 bg-muted/30 px-4 py-2"
>
<div className="h-px flex-1 bg-border/80" />
<span className="shrink-0 text-(length:--text-micro) font-semibold uppercase tracking-wide text-muted-foreground">
{group.searchSection === "archived" ? "Archived" : "Other results"}
</span>
<div className="h-px flex-1 bg-border/80" />
</div>,
);
}
if (group.label) {
const groupNavIdx = groupFlatIndex.get(group.key) ?? -1;
const isGroupSelected = groupNavIdx >= 0 && selectedIndex === groupNavIdx;
const canCreateIssueInGroup = group.displayItems.some((item) => item.kind === "issue");
elements.push(
<div
key={`group-${group.key}`}
data-inbox-item
className={cn(groupIndex > 0 && "pt-2")}
onClick={() => {
if (groupNavIdx >= 0) setSelectedIndex(groupNavIdx);
}}
onMouseEnter={() => {
if (groupNavIdx >= 0) setSelectedIndexFromPointer(groupNavIdx);
}}
>
{/* Left inset aligns the header chevron with the nested
task chevrons. Read rows no longer reserve a
mark-read column, so inbox rows sit at pl-1 before
their chevron — same as the tasks list. */}
<div className={cn("rounded-lg px-3 sm:pl-0 sm:pr-4", isGroupSelected ? "bg-accent/50" : "hover:bg-accent/50")}>
<IssueGroupHeader
label={group.label}
collapsible
collapsed={isGroupCollapsed}
onToggle={() => toggleGroupCollapse(group.key)}
trailing={canCreateIssueInGroup ? (
<Button
variant="ghost"
size="icon-xs"
className="-mr-2 text-muted-foreground"
title={`New task in ${group.label}`}
aria-label={`New task in ${group.label}`}
onClick={(event) => {
event.stopPropagation();
openCreateIssueForGroup(group);
}}
>
<Plus className="h-3 w-3" />
</Button>
) : null}
/>
</div>
</div>,
);
}
if (isGroupCollapsed) return elements;
for (let index = 0; index < group.displayItems.length; index += 1) {
const item = group.displayItems[index]!;
const navIdx = topFlatIndex.get(`${group.key}:${getInboxWorkItemKey(item)}`) ?? 0;
const wrapItem = (key: string, isSelected: boolean, child: ReactNode) => (
<div
key={`sel-${key}`}
data-inbox-item
className="relative"
onClick={() => setSelectedIndex(navIdx)}
onMouseEnter={() => setSelectedIndexFromPointer(navIdx)}
>
{child}
</div>
);
const currentDateGroup = taskDateGroup(item.timestamp);
const dateGroupLabel = streamlinedUiEnabled
&& filterPreferences.showDateGroupSeparators
&& groupBy === "none"
? taskDateGroupSeparator(previousDateGroup, currentDateGroup)
: null;
previousDateGroup = currentDateGroup;
const showLegacyEarlierDivider = !streamlinedUiEnabled
&& groupBy === "none"
&& item.timestamp > 0
&& item.timestamp < legacyTodayCutoff
&& previousTimestamp >= legacyTodayCutoff;
previousTimestamp = item.timestamp > 0 ? item.timestamp : previousTimestamp;
if (dateGroupLabel) {
elements.push(
<div
key={`date-divider-${group.key}-${currentDateGroup}-${index}`}
className="flex items-center gap-3 px-3 py-1.5 sm:pl-0 sm:pr-4"
data-testid="inbox-date-group"
role="separator"
aria-label={dateGroupLabel}
>
<span className="h-px min-w-0 flex-1 bg-border/80" aria-hidden="true" data-date-group-rule="" />
<span
className="shrink-0 text-(length:--text-nano) font-medium uppercase tracking-wider text-muted-foreground/70"
data-date-group-label=""
>
{dateGroupLabel}
</span>
<span className="h-px min-w-0 flex-1 bg-border/80" aria-hidden="true" data-date-group-rule="" />
</div>,
);
} else if (showLegacyEarlierDivider) {
elements.push(
<div key={`earlier-divider-${group.key}-${index}`} className="my-2 flex items-center gap-3 px-4">
<div className="flex-1 border-t border-border" />
<span
className="shrink-0 text-(length:--text-micro) font-medium uppercase tracking-wider text-muted-foreground/70"
data-date-group-label=""
>
Earlier
</span>
</div>,
);
}
const isSelected = selectedIndex === navIdx;
if (item.kind === "approval") {
const approvalKey = `approval:${item.approval.id}`;
const isArchiving = archivingNonIssueIds.has(approvalKey);
const row = (
<ApprovalInboxRow
key={approvalKey}
approval={item.approval}
selected={isSelected}
requesterName={agentName(item.approval.requestedByAgentId)}
onApprove={() => approveMutation.mutate(item.approval.id)}
onReject={() => rejectMutation.mutate(item.approval.id)}
isPending={approveMutation.isPending || rejectMutation.isPending}
unreadState={nonIssueUnreadState(approvalKey)}
onMarkRead={() => handleMarkNonIssueRead(approvalKey)}
onArchive={canArchiveFromTab ? () => handleArchiveNonIssue(approvalKey) : undefined}
archiveDisabled={isArchiving}
className={
isArchiving
? "pointer-events-none -translate-x-4 scale-(--s-0_98) opacity-0 transition-all duration-200 ease-out"
: "transition-all duration-200 ease-out"
}
/>
);
elements.push(wrapItem(approvalKey, isSelected, canArchiveFromTab ? (
<SwipeToArchive
key={approvalKey}
selected={isSelected}
disabled={isArchiving}
onArchive={() => handleArchiveNonIssue(approvalKey)}
>
{row}
</SwipeToArchive>
) : <InboxRowSurface selected={isSelected}>{row}</InboxRowSurface>));
continue;
}
if (item.kind === "failed_run") {
const runKey = `run:${item.run.id}`;
const isArchiving = archivingNonIssueIds.has(runKey);
const row = (
<FailedRunInboxRow
key={runKey}
run={item.run}
selected={isSelected}
issueById={issueById}
agentName={agentName(item.run.agentId)}
issueLinkState={issueLinkState}
onDismiss={() => dismissInboxItem(runKey)}
onRetry={() => retryRunMutation.mutate(item.run)}
isRetrying={retryingRunIds.has(item.run.id)}
unreadState={nonIssueUnreadState(runKey)}
onMarkRead={() => handleMarkNonIssueRead(runKey)}
onArchive={canArchiveFromTab ? () => handleArchiveNonIssue(runKey) : undefined}
archiveDisabled={isArchiving}
className={
isArchiving
? "pointer-events-none -translate-x-4 scale-(--s-0_98) opacity-0 transition-all duration-200 ease-out"
: "transition-all duration-200 ease-out"
}
/>
);
elements.push(wrapItem(runKey, isSelected, canArchiveFromTab ? (
<SwipeToArchive
key={runKey}
selected={isSelected}
disabled={isArchiving}
onArchive={() => handleArchiveNonIssue(runKey)}
>
{row}
</SwipeToArchive>
) : <InboxRowSurface selected={isSelected}>{row}</InboxRowSurface>));
continue;
}
if (item.kind === "join_request") {
const joinKey = `join:${item.joinRequest.id}`;
const isArchiving = archivingNonIssueIds.has(joinKey);
const row = (
<JoinRequestInboxRow
key={joinKey}
joinRequest={item.joinRequest}
selected={isSelected}
onApprove={() => approveJoinMutation.mutate(item.joinRequest)}
onReject={() => rejectJoinMutation.mutate(item.joinRequest)}
isPending={approveJoinMutation.isPending || rejectJoinMutation.isPending}
unreadState={nonIssueUnreadState(joinKey)}
onMarkRead={() => handleMarkNonIssueRead(joinKey)}
onArchive={canArchiveFromTab ? () => handleArchiveNonIssue(joinKey) : undefined}
archiveDisabled={isArchiving}
className={
isArchiving
? "pointer-events-none -translate-x-4 scale-(--s-0_98) opacity-0 transition-all duration-200 ease-out"
: "transition-all duration-200 ease-out"
}
/>
);
elements.push(wrapItem(joinKey, isSelected, canArchiveFromTab ? (
<SwipeToArchive
key={joinKey}
selected={isSelected}
disabled={isArchiving}
onArchive={() => handleArchiveNonIssue(joinKey)}
>
{row}
</SwipeToArchive>
) : <InboxRowSurface selected={isSelected}>{row}</InboxRowSurface>));
continue;
}
const issue = item.issue;
const childIssues = group.childrenByIssueId.get(issue.id) ?? [];
const hasChildren = childIssues.length > 0;
const isExpanded = hasChildren && !collapsedInboxParents.has(issue.id);
const canArchiveIssue = canArchiveFromTab && group.searchSection === "none";
const renderChildIssueRows = (
children: Issue[],
depth: number,
seen: ReadonlySet<string>,
): ReactNode[] =>
children.flatMap((child) => {
if (seen.has(child.id)) return [];
const nextSeen = new Set(seen);
nextSeen.add(child.id);
const childNavIdx = childFlatIndex.get(child.id) ?? -1;
const isChildSelected = selectedIndex === childNavIdx;
const grandchildIssues = group.childrenByIssueId.get(child.id) ?? [];
const childHasChildren = grandchildIssues.length > 0;
const childIsExpanded = childHasChildren && !collapsedInboxParents.has(child.id);
const childRow = renderInboxIssue({
issue: child,
depth,
selected: isChildSelected,
hasChildren: childHasChildren,
isExpanded: childIsExpanded,
childCount: grandchildIssues.length,
collapseParentId: child.id,
allowArchive: canArchiveIssue,
});
const isChildArchiving = archivingIssueIds.has(child.id);
const row = (
<div
key={`sel-issue:${child.id}`}
data-inbox-item
className="relative"
onClick={() => {
if (childNavIdx >= 0) setSelectedIndex(childNavIdx);
}}
onMouseEnter={() => {
if (childNavIdx >= 0) setSelectedIndexFromPointer(childNavIdx);
}}
>
{canArchiveIssue ? (
<SwipeToArchive
key={`issue:${child.id}`}
selected={isChildSelected}
disabled={isChildArchiving}
onArchive={() => archiveIssueMutation.mutate(child.id)}
>
{childRow}
</SwipeToArchive>
) : <InboxRowSurface selected={isChildSelected}>{childRow}</InboxRowSurface>}
</div>
);
return childIsExpanded
? [row, ...renderChildIssueRows(grandchildIssues, depth + 1, nextSeen)]
: [row];
});
const parentRow = renderInboxIssue({
issue,
depth: 0,
selected: isSelected,
hasChildren,
isExpanded,
childCount: childIssues.length,
collapseParentId: issue.id,
allowArchive: canArchiveIssue,
});
elements.push(wrapItem(`issue:${issue.id}`, isSelected, canArchiveIssue ? (
<SwipeToArchive
key={`issue:${issue.id}`}
selected={isSelected}
disabled={archivingIssueIds.has(issue.id)}
onArchive={() => archiveIssueMutation.mutate(issue.id)}
>
{parentRow}
</SwipeToArchive>
) : <InboxRowSurface selected={isSelected}>{parentRow}</InboxRowSurface>));
if (isExpanded) {
elements.push(...renderChildIssueRows(childIssues, 1, new Set([issue.id])));
}
}
return elements;
});
})()}
</div>
</div>
</>
)}
{allLoaded && !listError && showAlertsSection && (
<>
{showSeparatorBefore("alerts") && <Separator />}
<div>
<h3 className="mb-3 text-sm font-semibold uppercase tracking-wide text-muted-foreground">
Alerts
</h3>
<div className="divide-y divide-border border border-border">
{showAggregateAgentError && (
<div className="group/alert relative flex items-center gap-3 px-4 py-3 transition-colors hover:bg-accent/50">
<Link
to="/agents"
className="flex flex-1 cursor-pointer items-center gap-3 no-underline text-inherit"
>
<AlertTriangle className="h-4 w-4 shrink-0 text-red-600 dark:text-red-400" />
<span className="text-sm">
<span className="font-medium">{dashboard!.agents.error}</span>{" "}
{dashboard!.agents.error === 1 ? "agent has" : "agents have"} errors
</span>
</Link>
<button
type="button"
onClick={() => dismissAlert("alert:agent-errors")}
className="rounded-md p-1 text-muted-foreground opacity-0 transition-opacity hover:bg-accent hover:text-foreground group-hover/alert:opacity-100"
aria-label="Dismiss"
>
<X className="h-3.5 w-3.5" />
</button>
</div>
)}
{showBudgetAlert && (
<div className="group/alert relative flex items-center gap-3 px-4 py-3 transition-colors hover:bg-accent/50">
<Link
to="/costs"
className="flex flex-1 cursor-pointer items-center gap-3 no-underline text-inherit"
>
<AlertTriangle className="h-4 w-4 shrink-0 text-yellow-400" />
<span className="text-sm">
Budget at{" "}
<span className="font-medium">{dashboard!.costs.monthUtilizationPercent}%</span>{" "}
utilization this month
</span>
</Link>
<button
type="button"
onClick={() => dismissAlert("alert:budget")}
className="rounded-md p-1 text-muted-foreground opacity-0 transition-opacity hover:bg-accent hover:text-foreground group-hover/alert:opacity-100"
aria-label="Dismiss"
>
<X className="h-3.5 w-3.5" />
</button>
</div>
)}
</div>
</div>
</>
)}
</div>
);
}