Files
PaperClipAI/ui/src/components/SidebarRecentTasks.test.tsx
T
DottaandClaude Opus 5.5 7329eaf353 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>
2026-11-10 08:00:13 -06:00

574 lines
20 KiB
TypeScript

// @vitest-environment jsdom
import { act, type ReactNode } 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 { TooltipProvider } from "@/components/ui/tooltip";
import { SidebarRecentTasks } from "./SidebarRecentTasks";
import {
getRecentTasksStorageKey,
readRecentTasks,
recordRecentTask,
pruneRecentTasks,
} from "@/lib/recent-tasks";
import { queryKeys } from "@/lib/queryKeys";
const mockAuthApi = vi.hoisted(() => ({ getSession: vi.fn() }));
const mockAgentsApi = vi.hoisted(() => ({ wakeup: vi.fn() }));
const mockIssuesApi = vi.hoisted(() => ({
get: vi.fn(),
summaries: vi.fn(),
update: vi.fn(),
archiveFromInbox: vi.fn(),
getTreeControlState: vi.fn(),
createTreeHold: vi.fn(),
releaseTreeHold: vi.fn(),
chatBootstrap: vi.fn(async () => ({ items: [] })),
}));
vi.mock("@/api/agents", () => ({ agentsApi: mockAgentsApi }));
vi.mock("@/api/auth", () => ({ authApi: mockAuthApi }));
vi.mock("@/api/issues", () => ({ issuesApi: mockIssuesApi }));
vi.mock("@/lib/router", () => ({
NavLink: ({ children, to, className, ...props }: {
children: ReactNode;
to: string;
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: false,
setSidebarOpen: vi.fn(),
}),
}));
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
describe("SidebarRecentTasks", () => {
let container: HTMLDivElement;
let root: Root;
beforeEach(() => {
window.localStorage.clear();
Object.values(mockAgentsApi).forEach((mock) => mock.mockReset());
Object.values(mockIssuesApi).forEach((mock) => mock.mockReset());
mockIssuesApi.summaries.mockImplementation(async (_company: string, ids: string[]) => {
const rows = await Promise.all(ids.map(id => mockIssuesApi.get.getMockImplementation()?.(id)));
return rows.filter(row => row && !row.hiddenAt);
});
container = document.createElement("div");
document.body.appendChild(container);
root = createRoot(container);
mockAuthApi.getSession.mockResolvedValue({
session: { id: "session-1", userId: "user-1" },
user: { id: "user-1", name: "Board", email: "board@example.test", image: null },
});
});
afterEach(() => {
act(() => root.unmount());
container.remove();
vi.clearAllMocks();
vi.useRealTimers();
});
async function render() {
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
await act(async () => {
root.render(
<QueryClientProvider client={queryClient}>
<TooltipProvider>
<SidebarRecentTasks companyId="company-1" liveIssueIds={new Set(["issue-1"])} />
</TooltipProvider>
</QueryClientProvider>,
);
});
await act(async () => {
for (let index = 0; index < 5; index += 1) {
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
}
});
return queryClient;
}
async function openActions(taskTitle: string) {
const actions = container.querySelector<HTMLButtonElement>(
`button[aria-label="More actions for ${taskTitle}"]`,
);
await act(async () => {
actions?.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true }));
await Promise.resolve();
});
}
function menuItem(label: string) {
return Array.from(document.body.querySelectorAll<HTMLElement>('[role="menuitem"]'))
.find((item) => item.textContent?.trim() === label);
}
function setInputValue(input: HTMLInputElement, value: string) {
const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set;
setter?.call(input, value);
input.dispatchEvent(new Event("input", { bubbles: true }));
}
it("hides the section when there are no recent tasks", async () => {
await render();
expect(container.textContent).not.toContain("Recent Tasks");
expect(container.textContent).not.toContain("Open or create a task");
});
it("renders refreshed task text and live state without shifting for a status icon", async () => {
recordRecentTask({
id: "issue-1",
companyId: "company-1",
title: "Initial title",
identifier: "PAP-1",
status: "todo",
updatedAt: new Date(1),
}, "user-1");
mockIssuesApi.get.mockResolvedValue({
id: "issue-1",
companyId: "company-1",
title: "Refreshed title",
identifier: "PAP-1",
status: "in_progress",
hiddenAt: null,
updatedAt: new Date(2),
});
const queryClient = await render();
await act(async () => {
for (let index = 0; index < 5; index += 1) {
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
}
});
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();
expect(link?.textContent).toContain("Refreshed title");
expect(link?.textContent).toContain("1 live");
expect(link?.querySelector('[aria-label="In Progress"]')).toBeNull();
expect(link?.querySelector('[data-slot="recent-task-icon-spacer"]')).toBeNull();
expect(link?.querySelector('[data-slot="sidebar-nav-icon"]')).toBeNull();
expect(link?.firstElementChild?.textContent).toBe("Refreshed title");
const actions = container.querySelector<HTMLButtonElement>(
'button[aria-label="More actions for Refreshed title"]',
);
expect(actions).not.toBeNull();
expect(actions?.className).toContain("opacity-0");
});
it("keeps rows stable during alternating activity and applies the final order after quiet", async () => {
const tasks = [1, 2, 3].map((id) => ({
id: `issue-${id}`,
companyId: "company-1",
title: `Task ${id}`,
identifier: `PAP-${id}`,
status: "done" as const,
hiddenAt: null,
projectId: null,
updatedAt: new Date(id),
}));
tasks.forEach((task) => recordRecentTask(task, "user-1"));
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"));
// 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();
for (let index = 0; index < 6; index += 1) {
const task = tasks[index % 2]!;
await act(async () => {
queryClient.setQueryData(queryKeys.issues.detail(task.id), {
...task, title: `Updated ${task.id}`, updatedAt: new Date(100 + index),
});
await vi.advanceTimersByTimeAsync(0);
});
await act(async () => { await vi.advanceTimersByTimeAsync(500); });
expect(order()).toEqual(originalOrder);
expect(container.textContent).toContain(`Updated ${task.id}`);
}
await act(async () => { await vi.advanceTimersByTimeAsync(499); });
expect(order()).toEqual(originalOrder);
await act(async () => { await vi.advanceTimersByTimeAsync(1); });
expect(order()).toEqual(["/issues/PAP-2", "/issues/PAP-1", "/issues/PAP-3"]);
expect(mockIssuesApi.get).not.toHaveBeenCalled();
expect(mockIssuesApi.summaries).toHaveBeenCalledTimes(1);
queryClient.clear();
});
it("adds and removes tasks immediately while an activity reorder is pending", async () => {
const task = (id: string, recordedAt: number) => ({
id, companyId: "company-1", title: id, identifier: id,
status: "todo" as const, updatedAt: new Date(recordedAt),
});
recordRecentTask(task("first", 1), "user-1");
recordRecentTask(task("second", 2), "user-1");
mockIssuesApi.get.mockImplementation(async (id: string) => task(id, 0));
const queryClient = await render();
vi.useFakeTimers();
act(() => recordRecentTask(task("first", 3), "user-1"));
expect(container.querySelector("a")?.getAttribute("href")).toBe("/issues/second");
await act(async () => {
recordRecentTask(task("new", 4), "user-1");
await vi.advanceTimersByTimeAsync(0);
});
expect(container.querySelector("a")?.getAttribute("href")).toBe("/issues/new");
act(() => pruneRecentTasks(getRecentTasksStorageKey("company-1", "user-1"), "company-1", new Set(["second"])));
expect(container.querySelector('a[href="/issues/second"]')).toBeNull();
await act(async () => { await vi.advanceTimersByTimeAsync(2_000); });
expect(container.querySelector('a[href="/issues/second"]')).toBeNull();
queryClient.clear();
});
it("opens the compact task actions menu from the ellipsis button", async () => {
recordRecentTask({
id: "issue-1",
companyId: "company-1",
title: "Menu task",
identifier: "PAP-1",
status: "todo",
updatedAt: new Date(1),
}, "user-1");
mockIssuesApi.get.mockResolvedValue({
id: "issue-1",
companyId: "company-1",
title: "Menu task",
identifier: "PAP-1",
status: "todo",
hiddenAt: null,
updatedAt: new Date(1),
});
await render();
await openActions("Menu task");
const menu = document.body.querySelector('[data-slot="dropdown-menu-content"]');
expect(menu?.textContent).toContain("Rename");
expect(menu?.textContent).toContain("Archive");
expect(menu?.textContent).toContain("Pause/Restart");
});
it("keeps an idle Slack conversation in recent history and labels it Idle", async () => {
const issue = {
id: "issue-1", companyId: "company-1", title: "Slack conversation", identifier: "PAP-1",
status: "in_review" as const, externalConversationState: "waiting" as const,
updatedAt: new Date(1), hiddenAt: null,
};
recordRecentTask(issue, "user-1");
mockIssuesApi.get.mockResolvedValue(issue);
await render();
expect(container.textContent).toContain("Slack conversation");
expect(container.textContent).toContain("Idle");
});
it("archives a task from the inbox without hiding or removing the recent task", async () => {
const issue = {
id: "issue-1",
companyId: "company-1",
title: "Archive me",
identifier: "PAP-1",
status: "todo" as const,
hiddenAt: null,
updatedAt: new Date(1),
};
recordRecentTask(issue, "user-1");
mockIssuesApi.get.mockResolvedValue(issue);
mockIssuesApi.archiveFromInbox.mockResolvedValue({
id: issue.id,
archivedAt: new Date(2),
});
await render();
await openActions("Archive me");
await act(async () => {
menuItem("Archive")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(mockIssuesApi.archiveFromInbox).toHaveBeenCalledWith("issue-1");
expect(mockIssuesApi.update).not.toHaveBeenCalled();
expect(container.textContent).toContain("Recent Tasks");
expect(container.querySelector('a[href="/issues/PAP-1"]')?.textContent).toContain(
"Archive me",
);
expect(readRecentTasks(
getRecentTasksStorageKey("company-1", "user-1"),
"company-1",
)).toHaveLength(1);
});
it("refreshes task activity after a rename", async () => {
const issue = {
id: "issue-1",
companyId: "company-1",
title: "Old title",
identifier: "PAP-1",
status: "todo" as const,
hiddenAt: null,
updatedAt: new Date(1),
};
const renamedIssue = { ...issue, title: "New title", updatedAt: new Date(2) };
recordRecentTask(issue, "user-1");
mockIssuesApi.get.mockResolvedValue(issue);
mockIssuesApi.update.mockResolvedValue(renamedIssue);
const queryClient = await render();
const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries");
await openActions("Old title");
await act(async () => {
menuItem("Rename")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
});
const input = document.body.querySelector<HTMLInputElement>('input[aria-label="Task name"]');
expect(input).not.toBeNull();
await act(async () => {
setInputValue(input!, "New title");
await Promise.resolve();
});
await act(async () => {
input?.closest("form")?.dispatchEvent(new SubmitEvent("submit", { bubbles: true, cancelable: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(mockIssuesApi.update).toHaveBeenCalledWith("issue-1", { title: "New title" });
expect(invalidateQueries).toHaveBeenCalledWith({
queryKey: queryKeys.issues.activity("issue-1"),
});
});
it("pauses a running task or restarts its active pause hold", async () => {
const issue = {
id: "issue-1",
companyId: "company-1",
title: "Toggle work",
identifier: "PAP-1",
status: "in_progress" as const,
assigneeAgentId: "agent-1",
hiddenAt: null,
updatedAt: new Date(1),
};
recordRecentTask(issue, "user-1");
mockIssuesApi.get.mockResolvedValue(issue);
mockIssuesApi.getTreeControlState
.mockResolvedValueOnce({ activePauseHold: null })
.mockResolvedValueOnce({
activePauseHold: {
holdId: "hold-1",
rootIssueId: "issue-1",
issueId: "issue-1",
isRoot: true,
mode: "pause",
reason: null,
releasePolicy: { strategy: "manual" },
},
});
mockIssuesApi.createTreeHold.mockResolvedValue({ hold: {}, preview: {} });
mockIssuesApi.releaseTreeHold.mockResolvedValue({});
mockAgentsApi.wakeup.mockResolvedValue({ id: "run-1" });
await render();
await openActions("Toggle work");
await act(async () => {
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(mockIssuesApi.createTreeHold).toHaveBeenCalledWith("issue-1", {
mode: "pause",
reason: "Paused from Recent Tasks.",
releasePolicy: { strategy: "manual" },
});
await openActions("Toggle work");
await act(async () => {
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(mockIssuesApi.releaseTreeHold).toHaveBeenCalledWith("issue-1", "hold-1", {
reason: "Restarted from Recent Tasks.",
});
expect(mockAgentsApi.wakeup).toHaveBeenCalledWith(
"agent-1",
{
source: "assignment",
triggerDetail: "manual",
reason: "recent_task_restart",
payload: { issueId: "issue-1" },
},
"company-1",
);
});
it("retries only the wake after a remount when restart releases the hold before wakeup fails", async () => {
const issue = {
id: "issue-1",
companyId: "company-1",
title: "Retry restart",
identifier: "PAP-1",
status: "in_progress" as const,
assigneeAgentId: "agent-1",
hiddenAt: null,
updatedAt: new Date(1),
};
recordRecentTask(issue, "user-1");
mockIssuesApi.get.mockResolvedValue(issue);
mockIssuesApi.getTreeControlState
.mockResolvedValueOnce({
activePauseHold: {
holdId: "hold-1",
rootIssueId: "issue-1",
issueId: "issue-1",
isRoot: true,
mode: "pause",
reason: null,
releasePolicy: { strategy: "manual" },
},
})
.mockResolvedValueOnce({ activePauseHold: null });
mockIssuesApi.releaseTreeHold.mockResolvedValue({});
mockAgentsApi.wakeup
.mockRejectedValueOnce(new Error("Wake failed"))
.mockResolvedValueOnce({ id: "run-1" });
await render();
await openActions("Retry restart");
await act(async () => {
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
await act(async () => root.unmount());
root = createRoot(container);
await render();
await openActions("Retry restart");
await act(async () => {
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(mockIssuesApi.releaseTreeHold).toHaveBeenCalledTimes(1);
expect(mockIssuesApi.createTreeHold).not.toHaveBeenCalled();
expect(mockAgentsApi.wakeup).toHaveBeenCalledTimes(2);
expect(mockAgentsApi.wakeup).toHaveBeenLastCalledWith(
"agent-1",
{
source: "assignment",
triggerDetail: "manual",
reason: "recent_task_restart_retry",
payload: { issueId: "issue-1" },
},
"company-1",
);
});
it("synchronizes recent tasks written by another tab", async () => {
mockIssuesApi.get.mockImplementation(() => new Promise(() => {}));
await render();
const storageKey = getRecentTasksStorageKey("company-1", "user-1");
const entries = [{
id: "issue-2",
companyId: "company-1",
title: "Cross-tab task",
identifier: "PAP-2",
status: "todo" as const,
recordedAt: 2,
}];
await act(async () => {
window.localStorage.setItem(storageKey, JSON.stringify(entries));
window.dispatchEvent(new StorageEvent("storage", { key: storageKey }));
await Promise.resolve();
});
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 () => {
const issue = {
id: "issue-1", companyId: "company-1", title: "Retry after upgrade", identifier: "PAP-1",
status: "in_progress" as const, assigneeAgentId: "agent-1", hiddenAt: null, updatedAt: new Date(1),
};
window.localStorage.setItem("paperclip.recentTasks:company-1:user-1", JSON.stringify([{ ...issue, recordedAt: 1 }]));
window.localStorage.setItem("paperclip.recentTasks:company-1:user-1:restart-wake-retry", JSON.stringify([issue.id]));
mockIssuesApi.get.mockResolvedValue(issue);
mockIssuesApi.getTreeControlState.mockResolvedValue({ activePauseHold: null });
mockAgentsApi.wakeup.mockResolvedValue({ id: "run-1" });
await render();
await openActions("Retry after upgrade");
await act(async () => {
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(mockIssuesApi.createTreeHold).not.toHaveBeenCalled();
expect(mockIssuesApi.releaseTreeHold).not.toHaveBeenCalled();
expect(mockAgentsApi.wakeup).toHaveBeenCalledWith("agent-1", expect.objectContaining({
reason: "recent_task_restart_retry",
}), "company-1");
expect(window.localStorage.getItem("paperclip.recentTasks:company-1:user-1:restart-wake-retry")).toBeNull();
});
it("prunes tasks that become hidden", async () => {
recordRecentTask({
id: "issue-hidden",
companyId: "company-1",
title: "Hidden task",
identifier: "PAP-3",
status: "todo",
updatedAt: new Date(3),
}, "user-1");
mockIssuesApi.get.mockResolvedValue({
id: "issue-hidden",
companyId: "company-1",
title: "Hidden task",
identifier: "PAP-3",
status: "todo",
hiddenAt: new Date(),
updatedAt: new Date(4),
});
await render();
await act(async () => {
await Promise.resolve();
await new Promise((resolve) => window.setTimeout(resolve, 0));
});
expect(container.querySelector('a[href="/issues/PAP-3"]')).toBeNull();
expect(readRecentTasks(
getRecentTasksStorageKey("company-1", "user-1"),
"company-1",
)).toEqual([]);
});
});