Files
PaperClipAI/ui/src/components/SidebarRecentTasks.test.tsx
T
4434714824 Fix sidebar Recents task order and archive visibility (#22251)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work.
> - The sidebar gives people quick access to tasks, chats, and projects
they recently opened.
> - Expanding a parent or project in Recents can show tasks the person
never opened.
> - Archiving a task from the inbox leaves it in Recents.
> - This change gives each recent task its own row and removes tasks
archived for the current viewer.
> - People can reopen an individual task and keep saved shortcuts above
More.

## Linked Issues or Issue Description

**What existing behavior does this improve?**

Recents in the Standard and Classic sidebars.

**Subsystem affected**

Board navigation and task summaries.

**Current behavior**

Opening a parent or project can show other tasks beneath it. A recent
subtask moves its parent group when reopened. Archiving a task leaves
its recent link visible.

**Proposed behavior**

Show each visited task in its own row, in recent activity order. Keep
canceled and completed tasks eligible. Remove tasks archived for the
current viewer from Recents. Preserve saved pins.

**Reason and benefit**

People can find the task they opened by its own position in the list.
Archiving removes its recent link without removing a saved shortcut.

**Breaking changes**

The Recents rows no longer expand into task lists. Project links still
open the project. The navigation summary adds an optional personal
archive flag.

Related work: #22219, #22024, #21904, and #20450.

## What Changed

- Render task, agent chat, and project rows directly in Standard
Recents. Keep the existing controls to pin each kind of row.
- Render standalone task rows with the existing Classic action menus.
Remove sidebar child loading and refresh code.
- Derive the viewer’s archive state using the existing inbox rule.
Filter archived tasks out of Recents while retaining authorized pinned
shortcuts.
- Cover independent parent and child order, canceled and archived tasks,
pin retention, and the Classic Archive action.

## Verification

- Reproduced the empty Recents row after cancellation before the fix.
- On the rebased branch, 424 focused UI and live-update tests and the UI
typecheck passed on macOS.
- Ran 77 issue-summary and OpenAPI integration tests with embedded
PostgreSQL on macOS. The Runner source SDK registry check passed on the
pushed revision.
- The updated sidebar test renders 402 recent rows. A deliberate
repeated task lookup made the input-read guard fail. The restored
implementation passed.
- The paused-assignee browser test checks the task detail heading in
each interface. Both variants reproduced the CI locator failure locally
and passed with the scoped locator.
- All 17 focused Storybook browser checks passed in Chromium on macOS.
- Run `pnpm verify` for local selection. The product documentation
change requests broader GitHub CI coverage.
- Open a parent task and a child task in either sidebar. Reopen the
child and check that its row moves ahead of the parent. Cancel the child
and check that it stays visible. Archive it and check that its recent
row disappears.

- On commit `8051038099`, [GitHub
CI](https://github.com/paperclipai/paperclip/actions/runs/44421716811)
passed, including the required verification and end-to-end checks.
-
[Greptile](https://github.com/paperclipai/paperclip/pull/22251#issuecomment-6994494812)
rated the same commit 5/5. Its review thread is resolved.

## Risks

- Recents uses the same viewer-specific archive rule as the inbox.
Archiving prunes the local recent entry. A restored task can enter
Recents again when opened.
- Task summaries still return authorized tasks for saved pins. Child and
unread counts remain in the existing API response for older clients.
- The change requires no database migration.

## Model Used

- OpenAI GPT-6 via Codex with shell, GitHub CLI, Vitest, and Chromium.

## 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
- [x] All Paperclip CI gates are green
- [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

---------

Co-authored-by: Scott Tong <1504818+scotttong@users.noreply.github.com>
Co-authored-by: Paperclip <noreply@paperclip.ing>
2026-11-18 16:04:42 -08:00

601 lines
22 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(),
listCompact: vi.fn(async (_company: string, _filters?: { parentId?: string }) => [] as unknown[]),
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", () => ({
useLocation: () => ({ pathname: "/PAP/issues" }),
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: () => ({
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).map(row => ({ ...row, isParticipantForMe: true }));
});
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("keeps actions on independent parent and child rows in recent order", async () => {
const parent = { id: "parent", companyId: "company-1", title: "Parent", identifier: "PAP-1", status: "todo" as const, updatedAt: new Date(1), subtaskCount: 1, isParticipantForMe: true };
const child = { ...parent, id: "child", parentId: parent.id, title: "Child", identifier: "PAP-2", subtaskCount: 0 };
recordRecentTask(parent, "user-1", 1);
recordRecentTask(child, "user-1", 2);
mockIssuesApi.summaries.mockResolvedValue([parent, child]);
await render();
const links = [...container.querySelectorAll("a")];
expect(links.map(link => link.getAttribute("href"))).toEqual(["/issues/PAP-2", "/issues/PAP-1"]);
expect(links[0]!.parentElement?.parentElement).toBe(links[1]!.parentElement?.parentElement);
expect(mockIssuesApi.listCompact).not.toHaveBeenCalled();
expect(container.querySelector('[aria-label="More actions for Parent"]')).not.toBeNull();
await openActions("Child");
expect(menuItem("Rename")).toBeDefined();
expect(menuItem("Archive")).toBeDefined();
expect(menuItem("Pause/Restart")).toBeDefined();
});
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("refreshes background activity without changing the personal 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", task.updatedAt.getTime()));
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(originalOrder);
expect(mockIssuesApi.get).not.toHaveBeenCalled();
expect(mockIssuesApi.summaries).toHaveBeenCalledTimes(1);
queryClient.clear();
});
it("adds verified tasks and removes tasks while a personal 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", 1);
recordRecentTask(task("second", 2), "user-1", 2);
mockIssuesApi.get.mockImplementation(async (id: string) => task(id, 0));
const queryClient = await render();
vi.useFakeTimers();
act(() => recordRecentTask(task("first", 3), "user-1", 3));
expect(container.querySelector("a")?.getAttribute("href")).toBe("/issues/second");
await act(async () => {
recordRecentTask(task("new", 4), "user-1", 4);
await vi.advanceTimersByTimeAsync(10);
});
await act(async () => { await vi.advanceTimersByTimeAsync(10); });
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("removes a recent task after archiving it from the inbox", 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.querySelector('a[href="/issues/PAP-1"]')).toBeNull();
expect(readRecentTasks(
getRecentTasksStorageKey("company-1", "user-1"),
"company-1",
)).toEqual([]);
});
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) };
const newer = { ...issue, id: "issue-2", identifier: "PAP-2", title: "Newer work" };
recordRecentTask(issue, "user-1", 10);
recordRecentTask(newer, "user-1", 20);
mockIssuesApi.get.mockImplementation(async (id: string) => id === issue.id ? issue : newer);
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" });
const stored = readRecentTasks(getRecentTasksStorageKey("company-1", "user-1"), "company-1");
expect(stored.map(entry => entry.id)).toEqual(["issue-1", "issue-2"]);
expect(stored[0]?.recordedAt).toBeGreaterThan(20);
expect(stored[0]?.title).toBe("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.mockResolvedValue({
id: "issue-2", companyId: "company-1", title: "Cross-tab task", identifier: "PAP-2",
status: "todo", updatedAt: new Date(2),
});
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 new Promise(resolve => setTimeout(resolve, 10));
});
await act(async () => { await new Promise(resolve => setTimeout(resolve, 10)); });
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([]);
});
});