perf(ui): open sidebar Recents tasks from cache (#20450)

## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - The board UI sidebar has a Recents list of the tasks a person opened
last
> - The Recents list renders from a local snapshot, but its links had no
warm-up. A click waited for the task-detail code and about nine
first-frame reads
> - Task lists (Inbox, Tasks) already warm a task on hover, press and
click, and #20355 added a batched `chat-bootstrap` read that had no UI
consumer
> - The hosted database is CPU-bound, so a fix must add at most one read
per page load and must not compete with the page's own reads
> - This pull request gives Recents the same open-intent prefetch as
task lists, warms the task-detail code, and preloads the top ten recent
tasks with one `chat-bootstrap` request after the page is idle
> - The benefit is that a click on a recent task shows its chat from
cache, without a wait for the API

## Linked Issues or Issue Description

Refs #20355 (server read this PR consumes). Builds on #20389, #20398 and
#20419.

**Is your feature request related to a problem?**
Opening a task from the sidebar's Recents was slower than opening it
from a task list. The Recents links had no prefetch. The task page
waited for its first-frame reads after the click.

**Describe the solution you'd like**
Recents links use the task lists' open-intent prefetch. When the page is
idle, one batched request loads the first frame of the most recent tasks
into the task page's caches.

**Describe alternatives you've considered**
Per-task prefetch of every recent task. That makes up to ten times nine
requests per page load, which the hosted database cannot afford.

**Additional context**
I searched open PRs and remote branches for "chat-bootstrap" and
"instant task opens". The only related work is the server-side branches
that merged as #20355. There is no other in-flight UI consumer of
`chat-bootstrap`.

## What Changed

- `ui/src/hooks/useIssueNavigationPrefetch.ts`: the open-intent handlers
from `IssueLinkQuicklook` move into one hook (light warm on pass-over;
`history: true` on a resting hover or focus, a mouse or pen press, and a
click). `IssueLinkQuicklook` now uses the hook. Its behavior does not
change.
- `ui/src/components/RecentTaskNavItem.tsx`: one Recents link wrapper
that applies the hook. The classic list (`SidebarRecentTasks`), the
Coordinator task rows and `DesignSidebar` use it. `SidebarNavItem`
accepts the handlers through a new optional `linkHandlers` prop.
- Classic Recents links now open `/issues/<identifier>` (Coordinator
already did). The old UUID link remounted the task page after a redirect
to the identifier route.
- `ui/src/hooks/useRecentTaskOpenWarmup.ts`: when Recents shows a task,
it fires the task-detail code warm-up (`useWarmTaskDetailCode`). After
two frames, a visible tab, no fetching queries and an idle callback, it
sends one `issues/chat-bootstrap?ids=` request for the ten most recent
tasks. It skips tasks whose first frame is cached and fresh. It sends no
request for an empty list or a hidden tab. It sends at most one request
per account per page load. Unmount or an account change aborts the
request.
- `ui/src/lib/issueChatBootstrapCache.ts`: `seedIssueChatBootstrap`
writes each field under the keys the task page reads, for the requested
ref, the id and the identifier: core issue, recent comments, comment
input facts (one batch, through the new `seedIssueIdBatch`), recent
activity, the recent run window (through the new shared
`buildRecentIssueRunWindow`), interactions, attachments, live runs and
active run. An explicit `null` active run is stored. A missing field is
not stored. It does not replace data that is as new or newer, data with
a read in flight, or data with a pending invalidation. Keys whose page
merges observed history (comments, activity, runs, input facts) are
filled only when empty. Items for another company are ignored.
- The seed fills the `?view=core` key, not the full detail key.
`seedIssueDetailCache` is not used: the core payload cannot stand in for
the detail read's related data, and seeding it there would suppress that
read.
- `issuesApi.chatBootstrap` client method.
- `tests/perf/collections/recent-task-open.spec.ts` and its README
section.

## Verification

Local disposable instance (`local_trusted`, production UI build,
embedded PostgreSQL, collection fixture plus 12 comments on each of 8
recent tasks, streamlined UI with the Coordinator sidebar). Journey:
open Projects with 8 Recents, wait for network idle plus 3 s, click a
recent task, measure until its latest comment is on screen. Each run
uses a fresh browser context (empty HTTP cache and storage apart from
Recents). Median of 5 runs, same server and fixture for both arms:

| Arm | Click to first chat frame | Idle page API requests |
| --- | --- | --- |
| `master` (b6f4008f9b), loopback | 227 ms (first run: 249 ms) | 24
(range 21–25) |
| This PR, loopback | 134 ms | 22 (range 21–27) |
| `master`, +150 ms on each API response | 455 ms | 19 |
| This PR, +150 ms on each API response | 135 ms | 20 (+1
`chat-bootstrap`) |

With added latency, the first frame no longer depends on API latency.

- `PAPERCLIP_COLLECTION_PERF_BASE_URL=http://127.0.0.1:<port> pnpm exec
playwright test --config tests/perf/collections/playwright.config.ts
recent-task-open.spec.ts recent-task-summaries.spec.ts`: 5 passed. On
`master` the two assertion cases fail (0 `chat-bootstrap` requests; 10
first-frame reads after the click).
- Reads that still follow a click on a preloaded task: full detail (`GET
/issues/:id`), `work-products`, `documents`, `feedback-votes`,
`tree-control/state`, `tree-holds`, `runner-goal`, `browsers`, and the
`read` mark. The `chat-bootstrap` payload does not cover them. None
gates the chat's first frame (the frame shows at 135 ms while every API
response waits 150 ms).
- Unit tests: `RecentTaskNavItem.test.tsx` (intent levels, href),
`useRecentTaskOpenWarmup.test.tsx` (one request for the top ten, code
warm-up, wait for page reads, hidden tab, fresh entries skipped, once
per account, user isolation, abort on unmount),
`issueChatBootstrapCache.test.ts` (each key in the endpoint shape,
`null` versus missing fields, company isolation, no downgrade of newer,
in-flight or invalidated data, merge keys filled only when empty).
- `ui` Vitest: `src/components src/hooks src/lib src/api` 694 files
passed; `src/pages src/App src/context` 188 files passed. `pnpm
check:token-gates`: clean. `pnpm verify` exits 2 because a `tests/` file
is a global CI input; required CI supplies the broad coverage.

## Risks

- Low to medium. One extra read per page load when Recents has tasks
without a fresh cached first frame. The read starts only after the
page's own queries settle, and the server reads at most two tasks at a
time.
- A live event that arrives while the preload is in flight, for a task
with no cached keys, can leave seeded data up to 30 s old until the next
live event or the next open after the stale time. Inbox hover prefetch
has the same window.
- Classic Recents links now use the identifier route instead of the UUID
route. The task page already redirected UUID links to this route.
- `tests/perf/collections` is a manual suite. CI does not run it.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, in Claude Code with
tool use (shell, file edits, browser automation through Playwright).
Standard context window.

## 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
- [ ] 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>
This commit is contained in:
DottaandClaude Opus 5.5 authored and GitHub committed 2026-11-10 08:00:13 -06:00
1 parent c9226de30b
commit 7329eaf353
19 files changed
+1079 -43

No files matched your search

+7 -1
View File
@@ -7,6 +7,7 @@ import { issuesApi } from "@/api/issues";
import { instanceSettingsApi } from "@/api/instanceSettings";
import { useAgentChatNavigation } from "@/hooks/useAgentChatNavigation";
import { useRecentTasks } from "@/hooks/useRecentTasks";
import { useRecentTaskOpenWarmup } from "@/hooks/useRecentTaskOpenWarmup";
import { usePinnedNavigation } from "@/hooks/usePinnedNavigation";
import { useDialogActions } from "@/context/DialogContext";
import { useSidebar } from "@/context/SidebarContext";
@@ -15,6 +16,7 @@ import { Link, useLocation } from "@/lib/router";
import { agentRouteRef, cn, projectRouteRef, SIDEBAR_RAIL_HIDDEN_LABEL } from "@/lib/utils";
import { SidebarCompanyMenu } from "./SidebarCompanyMenu";
import { SidebarNavItem } from "./SidebarNavItem";
import { RecentTaskNavItem } from "./RecentTaskNavItem";
import { SidebarSection } from "./SidebarSection";
import { TruncatedTextMarqueeProvider } from "./TruncatedText";
import { useScrollbarWhileScrolling } from "./side-panel/use-scrollbar-while-scrolling";
@@ -28,6 +30,8 @@ import { agentChatPinKey } from "./AgentChatPin";
import { PinnedNavigationList, type PinnedNavigationItem } from "./PinnedNavigationList";
import { companyProjectsQuery } from "@/lib/company-projects-query";
const NO_RECENT_TASKS: never[] = [];
const moreDestinations = [
{ label: "Search", to: "/search", icon: Search },
{ label: "Dashboard", to: "/dashboard", icon: LayoutDashboard },
@@ -119,6 +123,8 @@ export function CoordinatorSidebar({ children }: { children?: ReactNode }) {
const { entries: recentTasks } = useRecentTasks({ companyId, userId });
const { collapsed, peeking, isMobile, setSidebarOpen } = useSidebar();
const rail = collapsed && !peeking;
// Warm opens only while the Recents list is on screen.
useRecentTaskOpenWarmup({ companyId, userId, tasks: !rail && session.isSuccess ? recentTasks : NO_RECENT_TASKS });
const { openNewIssue } = useDialogActions();
const location = useLocation();
const attentionCount = useCoordinatorAttentionCount(companyId);
@@ -193,7 +199,7 @@ export function CoordinatorSidebar({ children }: { children?: ReactNode }) {
{!rail && session.isSuccess && recents.length > 0 && <div className="design-sidebar-recents"><SidebarSection label="Recents">
<RecentNavigationList>
{recents.map(item => item.kind === "task"
? <SidebarNavItem className="design-sidebar-item" key={item.id} to={`/issues/${item.task.identifier ?? item.id}`} label={item.task.title} iconNode={<StatusIcon {...taskStatusIconProps(item.task)} />} />
? <RecentTaskNavItem className="design-sidebar-item" key={item.id} task={item.task} label={item.task.title} iconNode={<StatusIcon {...taskStatusIconProps(item.task)} />} />
: item.kind === "chat"
? <SidebarNavItem className="design-sidebar-item" key={item.id} to={`/chats/${encodeURIComponent(agentRouteRef(item.agent))}`} label={item.agent.name} iconNode={<AgentAvatar agent={item.agent} size={20} />} />
: <ProjectRecent key={item.id} project={item.project} />)}
@@ -2,6 +2,7 @@ import { useAccountIdentity } from "@/api/companies-query";
import { useCompany } from "@/context/CompanyContext";
import { useDialogActions } from "@/context/DialogContext";
import { useRecentTasks } from "@/hooks/useRecentTasks";
import { useRecentTaskOpenWarmup } from "@/hooks/useRecentTaskOpenWarmup";
import { DesignSidebar } from "./DesignSidebar";
/** Data adapter only; the visual subject is Components / Sidebar. */
@@ -10,5 +11,6 @@ export function DesignSandboxSidebar() {
const { userId } = useAccountIdentity();
const { openNewIssue } = useDialogActions();
const { entries } = useRecentTasks({ companyId: selectedCompanyId, userId });
useRecentTaskOpenWarmup({ companyId: selectedCompanyId, userId, tasks: entries });
return <DesignSidebar recentTasks={entries} onNewTask={() => openNewIssue()} />;
}
+2 -1
View File
@@ -5,6 +5,7 @@ import { SidebarAccountMenu } from "./SidebarAccountMenu";
import { SidebarCompanyMenu } from "./SidebarCompanyMenu";
import { SidebarNavExpandedProvider, SidebarNavItem } from "./SidebarNavItem";
import { SidebarSection } from "./SidebarSection";
import { RecentTaskNavItem, recentTaskPathRef } from "./RecentTaskNavItem";
import { TruncatedTextMarqueeProvider } from "./TruncatedText";
import { Button } from "./ui/button";
import { FlyoutAppearanceProvider } from "./ui/flyout";
@@ -47,7 +48,7 @@ export function DesignSidebar({ onNewTask, recentTasks = [] }: { onNewTask: () =
{companyRecentTasks.length > 0 ? <div className="design-sidebar-recents">
<SidebarSection label="Recent Tasks">
<div onScroll={handleRecentScroll} className="design-sidebar-recent-list scrollbar-while-scrolling" role="region" aria-label="Recent tasks" tabIndex={0}>
{companyRecentTasks.map(issue => <SidebarNavItem key={issue.id} className="design-sidebar-item" to={`${root}/issues/${issue.identifier}`} label={issue.title} />)}
{companyRecentTasks.map(issue => <RecentTaskNavItem key={issue.id} task={issue} className="design-sidebar-item" to={`${root}/issues/${recentTaskPathRef(issue)}`} label={issue.title} />)}
</div>
</SidebarSection>
</div> : null}
+10 -30
View File
@@ -8,8 +8,8 @@ import { createIssueDetailPath, withIssueDetailHeaderSeed } from "@/lib/issueDet
import {
getIssueDetailQueryOptions,
ISSUE_DETAIL_STALE_TIME_MS,
prefetchIssueDetailForNavigation,
} from "@/lib/issueDetailCache";
import { ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS, useIssueNavigationPrefetch } from "@/hooks/useIssueNavigationPrefetch";
import { queryKeys } from "@/lib/queryKeys";
import { cn } from "@/lib/utils";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
@@ -219,8 +219,7 @@ export function IssueQuicklookCard({
);
}
/** How long a hover rests on a task link before its full chat history is warmed. */
export const ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS = 120;
export { ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS };
export const IssueLinkQuicklook = React.forwardRef<
HTMLAnchorElement,
@@ -366,26 +365,7 @@ export const IssueLinkQuicklook = React.forwardRef<
});
const detailPath = createIssueDetailPath(issuePathId);
// A pointer, a touch or keyboard focus that passes over a row warms only the
// issue and its recent comments. A hover or focus that rests on the link, a
// mouse or pen press, or a click also warms the rest of the chat's first
// frame, so the open renders from cache. A touch can start a scroll, so it
// warms the full set only on the click.
const historyPrefetchTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
const cancelHistoryPrefetch = React.useCallback(() => {
if (historyPrefetchTimerRef.current) clearTimeout(historyPrefetchTimerRef.current);
historyPrefetchTimerRef.current = null;
}, []);
React.useEffect(() => cancelHistoryPrefetch, [cancelHistoryPrefetch]);
const handlePrefetch = React.useCallback((history = true) => {
if (history) cancelHistoryPrefetch();
void prefetchIssueDetailForNavigation(queryClient, issuePathId, { issue: issuePrefetch, history });
}, [cancelHistoryPrefetch, issuePathId, issuePrefetch, queryClient]);
const handleDwellPrefetch = React.useCallback(() => {
handlePrefetch(false);
cancelHistoryPrefetch();
historyPrefetchTimerRef.current = setTimeout(() => handlePrefetch(true), ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS);
}, [cancelHistoryPrefetch, handlePrefetch]);
const prefetchHandlers = useIssueNavigationPrefetch(issuePathId, issuePrefetch);
const link = (
<RouterDom.Link
ref={setTriggerRef}
@@ -393,34 +373,34 @@ export const IssueLinkQuicklook = React.forwardRef<
state={prefetchedState}
className={className}
onMouseEnter={(event) => {
handleDwellPrefetch();
prefetchHandlers.onMouseEnter(event);
onMouseEnter?.(event);
}}
onMouseLeave={(event) => {
cancelHistoryPrefetch();
prefetchHandlers.onMouseLeave(event);
onMouseLeave?.(event);
}}
onPointerDown={(event) => {
handlePrefetch(event.pointerType !== "touch" && event.button === 0);
prefetchHandlers.onPointerDown(event);
onPointerDown?.(event);
}}
onFocus={(event) => {
handleDwellPrefetch();
prefetchHandlers.onFocus(event);
openNow();
onFocus?.(event);
}}
onBlur={(event) => {
cancelHistoryPrefetch();
prefetchHandlers.onBlur(event);
// Let clicks inside the portaled quicklook content finish before closing.
setTimeout(() => close(), 0);
onBlur?.(event);
}}
onTouchStart={(event) => {
handlePrefetch(false);
prefetchHandlers.onTouchStart(event);
onTouchStart?.(event);
}}
onClickCapture={(event) => {
handlePrefetch();
prefetchHandlers.onClickCapture(event);
onClickCapture?.(event);
}}
onClick={(event) => {
@@ -0,0 +1,105 @@
// @vitest-environment jsdom
import type { ReactNode } from "react";
import { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS } from "@/hooks/useIssueNavigationPrefetch";
import { RecentTaskNavItem } from "./RecentTaskNavItem";
const prefetches = vi.hoisted(() => [] as Array<{ ref: string; history: boolean }>);
const setSidebarOpen = vi.hoisted(() => vi.fn());
vi.mock("@/lib/issueDetailCache", () => ({
prefetchIssueDetailForNavigation: (_client: unknown, ref: string, options?: { history?: boolean }) => {
prefetches.push({ ref, history: options?.history === true });
return Promise.resolve();
},
}));
vi.mock("@/lib/router", () => ({
NavLink: ({ children, to, className, end: _end, state: _state, ...props }: {
children: ReactNode; to: string; end?: boolean; state?: unknown;
className?: string | ((state: { isActive: boolean }) => string);
}) => (
<a href={to} className={typeof className === "function" ? className({ isActive: false }) : className} {...props}>{children}</a>
),
}));
vi.mock("@/context/SidebarContext", () => ({
useSidebar: () => ({ collapsed: false, peeking: false, isMobile: true, setSidebarOpen }),
}));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
let container: HTMLDivElement;
let root: Root;
const queryClient = new QueryClient();
function renderItem(task: { id: string; identifier: string | null }, to?: string) {
prefetches.length = 0;
act(() => {
root.render(<QueryClientProvider client={queryClient}><RecentTaskNavItem task={task} to={to} label="Recent task" /></QueryClientProvider>);
});
return container.querySelector("a") as HTMLAnchorElement;
}
const hover = (link: HTMLAnchorElement, type: "mouseover" | "mouseout") =>
act(() => { link.dispatchEvent(new MouseEvent(type, { bubbles: true, relatedTarget: document.body })); });
const press = (link: HTMLAnchorElement, pointerType: string) =>
act(() => { link.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true, button: 0, pointerType })); });
beforeEach(() => {
vi.useFakeTimers();
container = document.createElement("div");
document.body.appendChild(container);
root = createRoot(container);
});
afterEach(() => {
act(() => root.unmount());
container.remove();
vi.useRealTimers();
setSidebarOpen.mockClear();
});
describe("RecentTaskNavItem", () => {
it("opens and warms the identifier route, falling back to the id", () => {
expect(renderItem({ id: "id-1", identifier: "PAP-1" }).getAttribute("href")).toBe("/issues/PAP-1");
expect(renderItem({ id: "id-2", identifier: null }).getAttribute("href")).toBe("/issues/id-2");
expect(renderItem({ id: "id-1", identifier: "PAP-1" }, "/PAP/issues/PAP-1").getAttribute("href")).toBe("/PAP/issues/PAP-1");
});
it("warms only the light set when a pointer passes over, and the chat's first frame when it rests", () => {
const link = renderItem({ id: "id-1", identifier: "PAP-1" });
hover(link, "mouseover");
act(() => { vi.advanceTimersByTime(ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS - 1); });
hover(link, "mouseout");
act(() => { vi.advanceTimersByTime(1_000); });
expect(prefetches).toEqual([{ ref: "PAP-1", history: false }]);
hover(link, "mouseover");
act(() => { vi.advanceTimersByTime(ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS); });
expect(prefetches.at(-1)).toEqual({ ref: "PAP-1", history: true });
});
it("warms the first frame on a mouse press, keyboard focus that rests, and a click", () => {
const link = renderItem({ id: "id-1", identifier: "PAP-1" });
press(link, "mouse");
expect(prefetches).toEqual([{ ref: "PAP-1", history: true }]);
prefetches.length = 0;
act(() => { link.focus(); });
act(() => { vi.advanceTimersByTime(ISSUE_HISTORY_HOVER_PREFETCH_DELAY_MS); });
expect(prefetches).toEqual([{ ref: "PAP-1", history: false }, { ref: "PAP-1", history: true }]);
prefetches.length = 0;
act(() => { link.click(); });
expect(prefetches).toEqual([{ ref: "PAP-1", history: true }]);
// The sidebar's own click handling still runs.
expect(setSidebarOpen).toHaveBeenCalledWith(false);
});
it("keeps a touch that may start a scroll to the light set", () => {
const link = renderItem({ id: "id-1", identifier: "PAP-1" });
press(link, "touch");
act(() => { link.dispatchEvent(new TouchEvent("touchstart", { bubbles: true })); });
act(() => { vi.advanceTimersByTime(1_000); });
expect(prefetches.length).toBeGreaterThan(0);
expect(prefetches.every((prefetch) => !prefetch.history)).toBe(true);
});
});
+26
View File
@@ -0,0 +1,26 @@
import type { ComponentProps } from "react";
import { useIssueNavigationPrefetch } from "@/hooks/useIssueNavigationPrefetch";
import { SidebarNavItem } from "./SidebarNavItem";
/** The route reference a Recents link opens: the identifier when the task has one. */
export function recentTaskPathRef(task: { id: string; identifier: string | null }) {
return task.identifier ?? task.id;
}
/**
* A Recents task link. It warms the task on open intent the same way task
* lists do, under the reference the task page reads.
*/
export function RecentTaskNavItem({
task,
to,
...props
}: Omit<ComponentProps<typeof SidebarNavItem>, "to" | "linkHandlers"> & {
task: { id: string; identifier: string | null };
/** Defaults to the board-relative task path. */
to?: string;
}) {
const pathRef = recentTaskPathRef(task);
const linkHandlers = useIssueNavigationPrefetch(pathRef);
return <SidebarNavItem {...props} to={to ?? `/issues/${pathRef}`} linkHandlers={linkHandlers} />;
}
+5
View File
@@ -1,5 +1,6 @@
import { createContext, useContext, type ReactNode } from "react";
import { NavLink } from "@/lib/router";
import type { IssueNavigationPrefetchHandlers } from "@/hooks/useIssueNavigationPrefetch";
import { SIDEBAR_SCROLL_RESET_STATE } from "../lib/navigation-scroll";
import { cn, SIDEBAR_RAIL_HIDDEN_LABEL } from "../lib/utils";
import { useSidebar } from "../context/SidebarContext";
@@ -66,6 +67,8 @@ interface SidebarNavItemProps {
trailingLabel?: string;
/** Rendered inside the right-aligned status cluster, before the live dot. */
liveAccessory?: ReactNode;
/** Extra link handlers, such as a task's open-intent prefetch. */
linkHandlers?: Partial<IssueNavigationPrefetchHandlers>;
}
export function SidebarNavItem({
@@ -87,6 +90,7 @@ export function SidebarNavItem({
trailing,
trailingLabel,
liveAccessory,
linkHandlers,
}: SidebarNavItemProps) {
const { isMobile, setSidebarOpen, collapsed, peeking } = useSidebar();
// A contextual takeover forces full labels even when the saved global app
@@ -120,6 +124,7 @@ export function SidebarNavItem({
state={SIDEBAR_SCROLL_RESET_STATE}
end={end}
aria-label={railAriaLabel}
{...linkHandlers}
onClick={() => { if (isMobile) setSidebarOpen(false); }}
className={({ isActive }) =>
cn(
@@ -24,6 +24,7 @@ const mockIssuesApi = vi.hoisted(() => ({
getTreeControlState: vi.fn(),
createTreeHold: vi.fn(),
releaseTreeHold: vi.fn(),
chatBootstrap: vi.fn(async () => ({ items: [] })),
}));
vi.mock("@/api/agents", () => ({ agentsApi: mockAgentsApi }));
@@ -158,7 +159,7 @@ describe("SidebarRecentTasks", () => {
}
});
const link = container.querySelector('a[href="/issues/issue-1"]');
const link = container.querySelector('a[href="/issues/PAP-1"]');
expect(mockIssuesApi.get).not.toHaveBeenCalled();
expect(mockIssuesApi.summaries).toHaveBeenCalledTimes(1);
expect(queryClient.getQueryData(["issues", "detail", "issue-1"])).toBeUndefined();
@@ -190,7 +191,8 @@ describe("SidebarRecentTasks", () => {
mockIssuesApi.get.mockImplementation(async (id: string) => tasks.find((task) => task.id === id));
const queryClient = await render();
const order = () => Array.from(container.querySelectorAll("a")).map((link) => link.getAttribute("href"));
const originalOrder = ["/issues/issue-3", "/issues/issue-2", "/issues/issue-1"];
// Links open the identifier route the task page settles on.
const originalOrder = ["/issues/PAP-3", "/issues/PAP-2", "/issues/PAP-1"];
expect(order()).toEqual(originalOrder);
vi.useFakeTimers();
@@ -210,7 +212,7 @@ describe("SidebarRecentTasks", () => {
await act(async () => { await vi.advanceTimersByTimeAsync(499); });
expect(order()).toEqual(originalOrder);
await act(async () => { await vi.advanceTimersByTimeAsync(1); });
expect(order()).toEqual(["/issues/issue-2", "/issues/issue-1", "/issues/issue-3"]);
expect(order()).toEqual(["/issues/PAP-2", "/issues/PAP-1", "/issues/PAP-3"]);
expect(mockIssuesApi.get).not.toHaveBeenCalled();
expect(mockIssuesApi.summaries).toHaveBeenCalledTimes(1);
queryClient.clear();
@@ -309,7 +311,7 @@ describe("SidebarRecentTasks", () => {
expect(mockIssuesApi.archiveFromInbox).toHaveBeenCalledWith("issue-1");
expect(mockIssuesApi.update).not.toHaveBeenCalled();
expect(container.textContent).toContain("Recent Tasks");
expect(container.querySelector('a[href="/issues/issue-1"]')?.textContent).toContain(
expect(container.querySelector('a[href="/issues/PAP-1"]')?.textContent).toContain(
"Archive me",
);
expect(readRecentTasks(
@@ -507,7 +509,7 @@ describe("SidebarRecentTasks", () => {
await Promise.resolve();
});
expect(container.querySelector('a[href="/issues/issue-2"]')?.textContent).toContain("Cross-tab task");
expect(container.querySelector('a[href="/issues/PAP-2"]')?.textContent).toContain("Cross-tab task");
});
it("preserves pending restart wake retries from before the snapshot storage migration", async () => {
@@ -562,7 +564,7 @@ describe("SidebarRecentTasks", () => {
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(container.querySelector('a[href="/issues/issue-hidden"]')).toBeNull();
expect(container.querySelector('a[href="/issues/PAP-3"]')).toBeNull();
expect(readRecentTasks(
getRecentTasksStorageKey("company-1", "user-1"),
"company-1",
+5 -3
View File
@@ -5,6 +5,7 @@ import { agentsApi } from "@/api/agents";
import { issuesApi } from "@/api/issues";
import { queryKeys } from "@/lib/queryKeys";
import { useRecentTasks } from "@/hooks/useRecentTasks";
import { useRecentTaskOpenWarmup } from "@/hooks/useRecentTaskOpenWarmup";
import { useAccountIdentity } from "@/api/companies-query";
import { useSidebar } from "@/context/SidebarContext";
import { useOptionalToastActions } from "@/context/ToastContext";
@@ -30,7 +31,7 @@ import {
import { Input } from "@/components/ui/input";
import { StatusIcon } from "./StatusIcon";
import { SidebarSection } from "./SidebarSection";
import { SidebarNavItem } from "./SidebarNavItem";
import { RecentTaskNavItem } from "./RecentTaskNavItem";
import { taskStatusIconProps } from "@/lib/task-status-presentation";
const RECENT_TASK_MENU_ITEM_CLASS =
@@ -111,6 +112,7 @@ function RecentTasksList({
const [renameValue, setRenameValue] = useState("");
const [pendingAction, setPendingAction] = useState<"rename" | "archive" | "pause" | null>(null);
const restartRetryStorageKey = restartWakeRetryStorageKey(companyId, userId);
useRecentTaskOpenWarmup({ companyId, userId, tasks: entries });
if (entries.length === 0) return null;
@@ -250,8 +252,8 @@ function RecentTasksList({
<SidebarSection label="Recent Tasks">
{entries.map((entry) => (
<div key={entry.id} className="sidebar-action-row group/recent-task relative">
<SidebarNavItem
to={`/issues/${entry.id}`}
<RecentTaskNavItem
task={entry}
label={entry.title}
iconNode={entry.displayStatus === "monitoring" && !liveIssueIds.has(entry.id) ? <StatusIcon {...taskStatusIconProps(entry)} /> : undefined}
trailing={entry.status === "in_review" && entry.externalConversationState === "waiting"