Files
PaperClipAI/ui/src/components/SidebarRecentTasks.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

351 lines
13 KiB
TypeScript

import { useState, type FormEvent } from "react";
import { useQueryClient } from "@tanstack/react-query";
import { Archive, MoreHorizontal, Pencil, RefreshCw } from "lucide-react";
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 { useOptionalToastActions } from "@/context/ToastContext";
import {
pruneRecentTasks,
recordRecentTask,
type RecentTaskEntry,
} from "@/lib/recent-tasks";
import { Button } from "@/components/ui/button";
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle,
} from "@/components/ui/dialog";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
import { Input } from "@/components/ui/input";
import { StatusIcon } from "./StatusIcon";
import { SidebarSection } from "./SidebarSection";
import { RecentTaskNavItem } from "./RecentTaskNavItem";
import { useLocation } from "@/lib/router";
import { taskStatusIconProps } from "@/lib/task-status-presentation";
const RECENT_TASK_MENU_ITEM_CLASS =
"h-(--profile-popover-row-height) gap-(--profile-popover-row-gap) rounded-lg px-2.5 py-0 text-(length:--text-compact) font-medium leading-(--profile-popover-label-line-height) focus:bg-accent/50 focus:text-foreground";
const RESTART_WAKE_RETRY_STORAGE_SUFFIX = ":restart-wake-retry";
function restartWakeRetryStorageKey(companyId: string, userId: string | null) {
// Action retry state must survive changes to the recent-task snapshot format.
return `paperclip.recentTasks:${companyId}:${userId ?? "__local_board__"}${RESTART_WAKE_RETRY_STORAGE_SUFFIX}`;
}
function readRestartWakeRetryIssueIds(storageKey: string | null) {
if (!storageKey) return new Set<string>();
try {
const parsed = JSON.parse(window.localStorage.getItem(storageKey) ?? "[]") as unknown;
return new Set(Array.isArray(parsed) ? parsed.filter((value): value is string => typeof value === "string") : []);
} catch {
return new Set<string>();
}
}
function setRestartWakeRetryPending(storageKey: string | null, issueId: string, pending: boolean) {
if (!storageKey) return;
const issueIds = readRestartWakeRetryIssueIds(storageKey);
if (pending) issueIds.add(issueId);
else issueIds.delete(issueId);
try {
if (issueIds.size > 0) window.localStorage.setItem(storageKey, JSON.stringify([...issueIds]));
else window.localStorage.removeItem(storageKey);
} catch {
// Recent Tasks remains usable when browser storage is unavailable.
}
}
function errorMessage(error: unknown, fallback: string) {
return error instanceof Error && error.message.trim() ? error.message : fallback;
}
export function SidebarRecentTasks({
companyId,
liveIssueIds,
}: {
companyId: string | null | undefined;
liveIssueIds: ReadonlySet<string>;
}) {
const { userId, settled } = useAccountIdentity();
if (!companyId || !settled) return null;
return (
<RecentTasksList
key={`${companyId}:${userId ?? "__local_board__"}`}
companyId={companyId}
userId={userId}
liveIssueIds={liveIssueIds}
/>
);
}
function RecentTasksList({
companyId,
userId,
liveIssueIds,
}: {
companyId: string;
userId: string | null;
liveIssueIds: ReadonlySet<string>;
}) {
const { entries, storageKey } = useRecentTasks({ companyId, userId });
const { pathname } = useLocation();
const queryClient = useQueryClient();
const toastActions = useOptionalToastActions();
const [renameEntry, setRenameEntry] = useState<RecentTaskEntry | null>(null);
const [renameValue, setRenameValue] = useState("");
const [pendingAction, setPendingAction] = useState<"rename" | "archive" | "pause" | null>(null);
const restartRetryStorageKey = restartWakeRetryStorageKey(companyId, userId);
useRecentTaskOpenWarmup({ companyId, userId, tasks: entries, navigationKey: pathname });
if (entries.length === 0) return null;
const refreshIssueQueries = async (issueId: string) => {
await Promise.all([
queryClient.invalidateQueries({ queryKey: queryKeys.issues.detail(issueId) }),
queryClient.invalidateQueries({ queryKey: queryKeys.issues.list(companyId) }),
queryClient.invalidateQueries({ queryKey: queryKeys.issues.activity(issueId) }),
]);
};
const beginRename = (entry: RecentTaskEntry) => {
setRenameEntry(entry);
setRenameValue(entry.title);
};
const submitRename = async (event: FormEvent<HTMLFormElement>) => {
event.preventDefault();
const nextTitle = renameValue.trim();
if (!renameEntry || !nextTitle || nextTitle === renameEntry.title) {
setRenameEntry(null);
return;
}
setPendingAction("rename");
try {
const updated = await issuesApi.update(renameEntry.id, { title: nextTitle });
queryClient.setQueryData(queryKeys.issues.detail(renameEntry.id), updated);
recordRecentTask(updated, userId, Date.now());
await refreshIssueQueries(renameEntry.id);
setRenameEntry(null);
toastActions?.pushToast({ title: "Task renamed", tone: "success" });
} catch (error) {
toastActions?.pushToast({
title: "Task rename failed",
body: errorMessage(error, "Unable to rename this task."),
tone: "error",
});
} finally {
setPendingAction(null);
}
};
const archiveTask = async (entry: RecentTaskEntry) => {
setPendingAction("archive");
try {
await issuesApi.archiveFromInbox(entry.id);
if (storageKey) pruneRecentTasks(storageKey, companyId, new Set([entry.id]));
await refreshIssueQueries(entry.id);
await queryClient.invalidateQueries({
queryKey: queryKeys.sidebarBadges(companyId),
});
toastActions?.pushToast({ title: "Task archived from inbox", tone: "success" });
} catch (error) {
toastActions?.pushToast({
title: "Task archive failed",
body: errorMessage(error, "Unable to archive this task from the inbox."),
tone: "error",
});
} finally {
setPendingAction(null);
}
};
const toggleTaskPause = async (entry: RecentTaskEntry) => {
setPendingAction("pause");
try {
const state = await issuesApi.getTreeControlState(entry.id);
if (state.activePauseHold?.isRoot) {
const restartIssue = await issuesApi.get(entry.id);
setRestartWakeRetryPending(restartRetryStorageKey, entry.id, true);
await issuesApi.releaseTreeHold(entry.id, state.activePauseHold.holdId, {
reason: "Restarted from Recent Tasks.",
});
if (restartIssue.assigneeAgentId) {
const wakeResult = await agentsApi.wakeup(
restartIssue.assigneeAgentId,
{
source: "assignment",
triggerDetail: "manual",
reason: "recent_task_restart",
payload: { issueId: restartIssue.id },
},
restartIssue.companyId,
);
if (!("id" in wakeResult)) {
throw new Error(wakeResult.message ?? "The assignee wake was skipped.");
}
}
setRestartWakeRetryPending(restartRetryStorageKey, entry.id, false);
toastActions?.pushToast({ title: "Task restarted", tone: "success" });
} else if (state.activePauseHold) {
throw new Error("This task is paused by a parent task. Restart it from the pause root.");
} else if (readRestartWakeRetryIssueIds(restartRetryStorageKey).has(entry.id)) {
const restartIssue = await issuesApi.get(entry.id);
if (restartIssue.assigneeAgentId) {
const wakeResult = await agentsApi.wakeup(
restartIssue.assigneeAgentId,
{
source: "assignment",
triggerDetail: "manual",
reason: "recent_task_restart_retry",
payload: { issueId: restartIssue.id },
},
restartIssue.companyId,
);
if (!("id" in wakeResult)) {
throw new Error(wakeResult.message ?? "The assignee wake was skipped.");
}
}
setRestartWakeRetryPending(restartRetryStorageKey, entry.id, false);
toastActions?.pushToast({ title: "Task restarted", tone: "success" });
} else {
await issuesApi.createTreeHold(entry.id, {
mode: "pause",
reason: "Paused from Recent Tasks.",
releasePolicy: { strategy: "manual" },
});
toastActions?.pushToast({ title: "Task paused", tone: "success" });
}
await queryClient.invalidateQueries({
queryKey: ["issues", "tree-control-state", entry.id],
});
await queryClient.invalidateQueries({ queryKey: queryKeys.issues.summaries(companyId) });
} catch (error) {
toastActions?.pushToast({
title: "Task pause update failed",
body: errorMessage(error, "Unable to pause or restart this task."),
tone: "error",
});
} finally {
setPendingAction(null);
}
};
const renderTaskRow = (entry: RecentTaskEntry) => (
<div key={entry.id} className="sidebar-action-row group/recent-task relative">
<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"
? <span className="text-xs text-muted-foreground">Idle</span> : undefined}
className="sidebar-action-link pointer-coarse:pr-8"
liveCount={liveIssueIds.has(entry.id) ? 1 : undefined}
/>
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon-xs"
aria-label={`More actions for ${entry.title}`}
className="sidebar-action-menu absolute right-2 top-(--pct-50) z-10 -translate-y-(--pct-50) text-muted-foreground pointer-events-none opacity-0 transition-opacity hover:bg-sidebar-accent dark:hover:bg-sidebar-accent hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 pointer-coarse:pointer-events-auto pointer-coarse:opacity-100 pointer-coarse:before:hidden group-hover/recent-task:pointer-events-auto group-hover/recent-task:opacity-100 group-focus-within/recent-task:pointer-events-auto group-focus-within/recent-task:opacity-100 data-[state=open]:pointer-events-auto data-[state=open]:bg-sidebar-accent data-[state=open]:text-foreground data-[state=open]:opacity-100"
>
<MoreHorizontal aria-hidden="true" />
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent
side="right"
align="start"
className="w-(--profile-popover-width) rounded-xl p-1.5 shadow-(--shadow-profile-popover)"
>
<DropdownMenuItem
className={RECENT_TASK_MENU_ITEM_CLASS}
onSelect={() => beginRename(entry)}
>
<Pencil aria-hidden="true" />
Rename
</DropdownMenuItem>
<DropdownMenuItem
className={RECENT_TASK_MENU_ITEM_CLASS}
disabled={pendingAction !== null}
onSelect={() => void archiveTask(entry)}
>
<Archive aria-hidden="true" />
Archive
</DropdownMenuItem>
<DropdownMenuItem
className={RECENT_TASK_MENU_ITEM_CLASS}
disabled={pendingAction !== null}
onSelect={() => void toggleTaskPause(entry)}
>
<RefreshCw aria-hidden="true" />
Pause/Restart
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
</div>
);
return (
<>
<SidebarSection label="Recent Tasks">
{entries.map(renderTaskRow)}
</SidebarSection>
<Dialog
open={renameEntry !== null}
onOpenChange={(open) => {
if (!open && pendingAction !== "rename") setRenameEntry(null);
}}
>
<DialogContent className="sm:max-w-md">
<form className="grid gap-4" onSubmit={(event) => void submitRename(event)}>
<DialogHeader>
<DialogTitle>Rename task</DialogTitle>
<DialogDescription>Choose a short, clear name for this task.</DialogDescription>
</DialogHeader>
<Input
autoFocus
aria-label="Task name"
value={renameValue}
disabled={pendingAction === "rename"}
onChange={(event) => setRenameValue(event.target.value)}
/>
<DialogFooter>
<Button
type="button"
variant="outline"
disabled={pendingAction === "rename"}
onClick={() => setRenameEntry(null)}
>
Cancel
</Button>
<Button
type="submit"
disabled={pendingAction === "rename" || !renameValue.trim()}
>
{pendingAction === "rename" ? "Saving..." : "Save"}
</Button>
</DialogFooter>
</form>
</DialogContent>
</Dialog>
</>
);
}