@saadnvd1/agent-os 0.3.592 → 0.3.595

package/app/api/bus/resurrect/route.test.ts

@@ -0,0 +1,47 @@
+import { NextRequest } from "next/server";
+import { describe, expect, it, vi } from "vitest";
+
+const resurrect = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/resurrect", () => ({ resurrectSession: resurrect }));
+
+const { db } = await import("@/lib/db");
+const { seedWorkspace } = await import("@/lib/orchestrator/testing");
+const { POST } = await import("./route");
+
+const call = (body: object) =>
+  POST(
+    new NextRequest("http://localhost/api/bus/resurrect", {
+      method: "POST",
+      body: JSON.stringify(body),
+    })
+  );
+
+describe("POST /api/bus/resurrect (aos resurrect)", () => {
+  it("runs only from inside a session", async () => {
+    const res = await call({ session: "x" });
+    expect(res.status).toBe(409);
+    expect((await res.json()).error).toMatch(/inside an AgentOS session/);
+  });
+
+  it("reaches only the caller's workspace, and lists what ended with no session", async () => {
+    const mine = seedWorkspace("Bus mine");
+    const other = seedWorkspace("Bus other");
+    db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
+      mine.task
+    );
+    db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
+      other.task
+    );
+    const list = await (await call({ from: mine.chat })).json();
+    expect(list.sessions.map((s: { id: string }) => s.id)).toEqual([mine.task]);
+
+    const refused = await call({ from: mine.chat, session: other.task });
+    expect(refused.status).toBe(409);
+    expect(resurrect).not.toHaveBeenCalled();
+
+    resurrect.mockResolvedValueOnce({ text: "back" });
+    const ok = await call({ from: mine.chat, session: mine.task });
+    expect((await ok.json()).summary).toBe("back");
+    expect(resurrect).toHaveBeenCalledWith(mine.task);
+  });
+});

package/app/api/bus/resurrect/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDoneTarget } from "@/lib/done";
+import { scopeOf } from "@/lib/done/bulk";
+import { resurrectSession } from "@/lib/resurrect";
+import { endedSessions, resolveEnded } from "@/lib/resurrect/find";
+
+// `aos resurrect [session]`, from inside a session: reaches only the
+// caller's workspace (or its project when it has none). Without a session it
+// lists the dropped and done ones that can come back.
+export async function POST(request: NextRequest) {
+  try {
+    const { from = null, session } = await request.json();
+    if (typeof from !== "string" || !from)
+      throw new Error("aos resurrect runs from inside an AgentOS session");
+    const scope = scopeOf(getDoneTarget(from));
+    if (typeof session !== "string" || !session.trim()) {
+      const ended = endedSessions(scope, { limit: 15 });
+      return NextResponse.json({
+        sessions: ended,
+        summary: ended.length
+          ? ended
+              .map(
+                (e) =>
+                  `${e.id.slice(0, 8)}  ${e.kind.padEnd(8)}  ${e.projectName ? `${e.projectName}/` : ""}${e.name}`
+              )
+              .join("\n")
+          : "Nothing dropped, done or archived to restore.",
+      });
+    }
+    const outcome = await resurrectSession(resolveEnded(session, scope));
+    return NextResponse.json({ summary: outcome.text, outcome });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/app/api/sessions/[id]/pause/route.ts

@@ -89,8 +89,11 @@ export async function DELETE(
 ) {
   const { id } = await params;
   try {
-    await resumeNow(id, "person");
-    return NextResponse.json({ pause: pauseViewOf(id) });
+    const out = await resumeNow(id, "person");
+    return NextResponse.json({
+      pause: pauseViewOf(id),
+      ...(out.outcome === "held" && { note: out.note }),
+    });
   } catch (error) {
     return fail(error);
   }

package/app/api/sessions/[id]/resurrect/route.test.ts

@@ -0,0 +1,32 @@
+import { NextRequest } from "next/server";
+import { describe, expect, it, vi } from "vitest";
+
+const resurrect = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/resurrect", () => ({ resurrectSession: resurrect }));
+
+const { POST } = await import("./route");
+
+const call = (id: string) =>
+  POST(
+    new NextRequest(`http://localhost/api/sessions/${id}/resurrect`, {
+      method: "POST",
+    }),
+    { params: Promise.resolve({ id }) }
+  );
+
+describe("POST /api/sessions/:id/resurrect", () => {
+  it("answers with the outcome", async () => {
+    resurrect.mockResolvedValueOnce({ id: "s1", text: "back" });
+    const res = await call("s1");
+    expect(res.status).toBe(200);
+    expect((await res.json()).outcome).toEqual({ id: "s1", text: "back" });
+    expect(resurrect).toHaveBeenCalledWith("s1", { device: null });
+  });
+
+  it("answers a refusal with 409 and the reason", async () => {
+    resurrect.mockRejectedValueOnce(new Error("its PR #3 was merged"));
+    const res = await call("s2");
+    expect(res.status).toBe(409);
+    expect(await res.json()).toEqual({ error: "its PR #3 was merged" });
+  });
+});

package/app/api/sessions/[id]/resurrect/route.ts

@@ -0,0 +1,24 @@
+import { NextRequest, NextResponse } from "next/server";
+import { resurrectSession } from "@/lib/resurrect";
+import { callingDevice } from "@/lib/security/device-me";
+import { db, queries, type Session } from "@/lib/db";
+
+// POST /api/sessions/:id/resurrect - bring a dropped, done or archived
+// session back: same id, same conversation, its status as it was. A refusal
+// (merged PR, conversation gone, project removed) is a 409 with the reason.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const id = (await params).id;
+    const outcome = await resurrectSession(id, {
+      device: callingDevice(request),
+    });
+    const session = queries.getSession(db).get(id) as Session | undefined;
+    return NextResponse.json({ outcome, session });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/app/api/sessions/ended/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { endedSessions, type EndedKind } from "@/lib/resurrect/find";
+
+const KINDS = new Set(["dropped", "done", "archived"]);
+
+// GET /api/sessions/ended[?workspace=id][&kind=dropped|done|archived][&limit=n]
+// - what can be restored, most recently ended first.
+export async function GET(request: NextRequest) {
+  const q = request.nextUrl.searchParams;
+  const workspace = q.get("workspace");
+  const kind = q.get("kind");
+  const limit = Math.min(Math.max(Number(q.get("limit")) || 50, 1), 200);
+  return NextResponse.json({
+    sessions: endedSessions(workspace ? { workspaceId: workspace } : null, {
+      limit,
+      kind: kind && KINDS.has(kind) ? (kind as EndedKind) : undefined,
+    }),
+  });
+}

package/components/Archived/ArchivedRow.tsx

@@ -3,7 +3,7 @@
 import { ArchiveRestore, ExternalLink, Loader2 } from "lucide-react";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
-import { useUnarchiveSession } from "@/data/done";
+import { useResurrectSession } from "@/data/done";
 import type { ArchivedView } from "@/lib/done/archive";
 import { fromSqliteTime } from "@/lib/session-meta";
 
@@ -24,7 +24,7 @@ function when(at: string): string {
 }
 
 export function ArchivedRow({ session }: { session: ArchivedView }) {
-  const unarchive = useUnarchiveSession();
+  const restore = useResurrectSession();
   const kind = session.taskStatus ? STATUS[session.taskStatus] : "Session";
 
   return (
@@ -70,20 +70,24 @@ export function ArchivedRow({ session }: { session: ArchivedView }) {
               ? "Puts the entry back in the sidebar; its worktree was removed"
               : undefined
           }
-          disabled={unarchive.isPending}
+          disabled={restore.isPending}
           onClick={() =>
-            unarchive.mutate(session.id, {
-              onSuccess: () => toast.success(`${session.name} is back`),
+            restore.mutate(session.id, {
+              onSuccess: (outcome) => toast.success(outcome.text),
               onError: (e) => toast.error(e.message),
             })
           }
         >
-          {unarchive.isPending ? (
+          {restore.isPending ? (
             <Loader2 className="h-3.5 w-3.5 animate-spin" />
           ) : (
             <ArchiveRestore className="h-3.5 w-3.5" />
           )}
-          {session.worktreeRemoved ? "Restore entry" : "Unarchive"}
+          {session.taskStatus === "dropped"
+            ? "Restore"
+            : session.worktreeRemoved
+              ? "Restore entry"
+              : "Unarchive"}
         </Button>
       )}
     </div>

package/components/Chat/PausedBanner.tsx

@@ -28,7 +28,7 @@ export function PausedBanner({ sessionId }: { sessionId: string }) {
         className="h-4 w-4 shrink-0 text-amber-600 dark:text-amber-400"
       />
       <p className="min-w-0 flex-1 text-sm">
-        {pauseSubtitle({ state, until })}
+        {pauseSubtitle({ state, until, note: session.pause_note })}
         <span className="text-muted-foreground block text-xs">
           Messages you send now are held and delivered together when it resumes.
         </span>

package/components/Providers.tsx

@@ -4,6 +4,7 @@ import { useState, useEffect } from "react";
 import { QueryClientProvider } from "@tanstack/react-query";
 import { ThemeProvider as NextThemesProvider, useTheme } from "next-themes";
 import { TooltipProvider } from "@/components/ui/tooltip";
+import { HoverTip } from "@/components/ui/HoverTip";
 import { createQueryClient } from "@/lib/query-client";
 import { parseTheme, getAllThemes } from "@/lib/theme-config";
 
@@ -41,7 +42,10 @@ export function Providers({ children }: { children: React.ReactNode }) {
         themes={getAllThemes()}
       >
         <ThemeClassHandler>
-          <TooltipProvider delayDuration={200}>{children}</TooltipProvider>
+          <TooltipProvider delayDuration={200}>
+            {children}
+            <HoverTip />
+          </TooltipProvider>
         </ThemeClassHandler>
       </NextThemesProvider>
     </QueryClientProvider>

package/components/SessionList/LiveLine.tsx

@@ -52,7 +52,7 @@ export function LiveLine({ compacting, prStage }: LiveInput) {
                 href={prStage.url}
                 target="_blank"
                 rel="noreferrer"
-                title={pr}
+                data-tip={pr}
                 aria-label={pr}
                 onClick={(e) => e.stopPropagation()}
                 className={cn(

package/components/SessionList/OrchestratorPinRow.tsx

@@ -16,6 +16,7 @@ import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { RowRename, UnreadDot } from "./RowParts";
 import { QuickChangeRow } from "./QuickChangeRow";
+import { NestRail } from "./RowParts";
 
 // A workspace's orchestrator, pinned above its sessions and titled with the
 // workspace's name: what it's doing and how many asks wait on you, on a line
@@ -54,7 +55,7 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
 
   const content = (
     <RowFrame
-      title={`${label}\n${summary}`}
+      data-tip={`${label}\n${summary}`}
       onActivate={() => !renaming && ctx.onSelect(session.id)}
       className={
         active
@@ -172,9 +173,13 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
           {menu("context")}
         </CM.ContextMenuContent>
       </CM.ContextMenu>
-      {row.quick?.map((q) => (
-        <QuickChangeRow key={q.session.id} row={q} />
-      ))}
+      {!!row.quick?.length && (
+        <NestRail>
+          {row.quick.map((q) => (
+            <QuickChangeRow key={q.session.id} row={q} />
+          ))}
+        </NestRail>
+      )}
     </>
   );
 }, sameProps);
@@ -190,7 +195,7 @@ export function OrchestratorStartRow({
 }) {
   return (
     <RowFrame
-      title={`${name}\nStart orchestrator`}
+      data-tip={`${name}\nStart orchestrator`}
       onActivate={() => orchestratorOpenActions.request(workspaceId)}
       className="hover:bg-muted/50 border-dashed"
     >

package/components/SessionList/QuickChangeRow.tsx

@@ -42,7 +42,7 @@ export function QuickChangeRow({ row }: { row: SidebarRow }) {
   );
   const openPr = pr ? () => window.open(pr, "_blank") : undefined;
   return (
-    <div className="ml-5">
+    <div>
       <RowShell
         title={`Quick change: ${session.name}\n${label}`}
         onActivate={openPr}

package/components/SessionList/RowParts.tsx

@@ -1,7 +1,9 @@
 "use client";
 
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useRef, useState, type ReactNode } from "react";
+import { ClipboardList, Pencil } from "lucide-react";
 import { NEED_LABEL, type SidebarRow } from "@/lib/sidebar/shelves";
+import { rowKindBadge, type RowKindBadge } from "@/lib/sidebar/row-badge";
 import { cn } from "@/lib/utils";
 
 // Amber when it needs you, red when it failed, green while it works, and a
@@ -26,7 +28,8 @@ export function RowDot({ row }: { row: SidebarRow }) {
   );
 }
 
-// What it needs from you, stalled, or a purple dot when it changed since you looked.
+// What it needs from you, stalled, its plan step, or a purple dot when it
+// changed since you looked.
 export function RowBadge({ row }: { row: SidebarRow }) {
   if (row.need) {
     const asks = row.status?.asks ?? 0;
@@ -50,10 +53,42 @@ export function RowBadge({ row }: { row: SidebarRow }) {
         Stalled
       </span>
     );
+  const kind = rowKindBadge(row);
+  if (kind) return <KindBadge badge={kind} />;
   if (row.unread) return <UnreadDot />;
   return null;
 }
 
+// Planning in blue, a plan waiting for approval in the primary colour:
+// an icon and a word, never colour alone.
+function KindBadge({ badge }: { badge: RowKindBadge }) {
+  const Icon = badge.kind === "planning" ? Pencil : ClipboardList;
+  return (
+    <span
+      data-tip={badge.tip}
+      className={cn(
+        "flex shrink-0 items-center gap-1 rounded-md px-1.5 py-0.5 text-[11px] font-semibold whitespace-nowrap",
+        badge.kind === "planning"
+          ? "bg-blue-500/15 text-blue-700 dark:text-blue-400"
+          : "bg-primary/15 text-primary"
+      )}
+    >
+      <Icon aria-hidden className="h-3 w-3" />
+      {badge.label}
+    </span>
+  );
+}
+
+// What belongs to the row above it (a conductor's workers, an
+// orchestrator's quick changes), behind a thin rule.
+export function NestRail({ children }: { children: ReactNode }) {
+  return (
+    <div className="border-foreground/10 ml-3.5 border-l pl-1.5">
+      {children}
+    </div>
+  );
+}
+
 export function UnreadDot() {
   return (
     <span

package/components/SessionList/RowShell.tsx

@@ -11,9 +11,11 @@ export type RowMenuKind = "dropdown" | "context";
 
 // Every sidebar row's frame: a leading mark, title over subtitle, what's on
 // the right (hidden under the ⋯ on hover), and the same menu on ⋯ and on
-// right-click. Session rows and queued tasks both draw through it.
+// right-click. Session rows and queued tasks both draw through it. The
+// title is its hover tip (lib/hover-tip), or tipKey's when one resolves.
 export function RowShell({
   title,
+  tipKey,
   highlight,
   onClick,
   onActivate,
@@ -26,6 +28,7 @@ export function RowShell({
   menuButton = true,
 }: {
   title: string;
+  tipKey?: string;
   highlight?: "selected" | "active" | null;
   onClick?: (e: React.MouseEvent) => void;
   // Enter or Space on the row; without it the row isn't a button.
@@ -45,7 +48,8 @@ export function RowShell({
     <div
       role={onActivate ? "button" : undefined}
       tabIndex={onActivate ? 0 : undefined}
-      title={title}
+      data-tip={title}
+      data-tip-key={tipKey}
       onClick={onClick}
       onKeyDown={(e) => {
         if (!onActivate || e.target !== e.currentTarget) return;

package/components/SessionList/RowSubtitle.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { Repeat, Layers } from "lucide-react";
+import { Repeat, Layers, Pause } from "lucide-react";
 import { HostBadge } from "@/components/Hosts";
 import { rowGroup } from "@/lib/recipes/chip";
 import type { Session } from "@/lib/db";
@@ -21,10 +21,12 @@ export function RowSubtitle({
   session,
   detail,
   live,
+  hideHost = false,
 }: {
   session: Session;
   detail?: string | null;
   live?: LiveInput;
+  hideHost?: boolean;
 }) {
   const ctx = useRowContext();
   // What its processes use, on a busy session: "3.1 cores · 4.2 GB".
@@ -61,28 +63,34 @@ export function RowSubtitle({
   return (
     <span className="flex min-w-0 items-center gap-1.5">
       {pause ? (
-        <span className="min-w-0 truncate text-xs text-amber-600 dark:text-amber-400">
-          {pauseSubtitle({
-            state: pause,
-            until: session.paused_until
-              ? Date.parse(`${session.paused_until.replace(" ", "T")}Z`)
-              : null,
-          })}
+        <span className="flex min-w-0 items-center gap-1 text-xs text-amber-600 dark:text-amber-400">
+          <Pause aria-hidden className="h-3 w-3 shrink-0" />
+          <span className="truncate">
+            {pauseSubtitle({
+              state: pause,
+              until: session.paused_until
+                ? Date.parse(`${session.paused_until.replace(" ", "T")}Z`)
+                : null,
+              note: session.pause_note,
+            })}
+          </span>
         </span>
       ) : (
         <LiveLine {...live} />
       )}
       {group && (
         <span
-          className="text-muted-foreground/70 hidden min-w-0 shrink items-center gap-1 truncate text-xs @[14rem]:flex"
-          title={group.kind === "recipe" ? "A recipe run" : "A piece of a plan"}
+          className="text-muted-foreground/70 flex min-w-0 shrink-0 items-center gap-1 truncate text-xs @[14rem]:shrink"
+          data-tip={`${group.kind === "recipe" ? "Recipe run" : "Plan piece"}: ${group.text}`}
         >
           {group.kind === "recipe" ? (
             <Repeat aria-hidden className="h-3 w-3 shrink-0" />
           ) : (
             <Layers aria-hidden className="h-3 w-3 shrink-0" />
           )}
-          <span className="truncate">{group.text}</span>
+          <span className="sr-only truncate @[14rem]:not-sr-only">
+            {group.text}
+          </span>
         </span>
       )}
       {(project || detail || usage || session.placed_note) && (
@@ -97,7 +105,7 @@ export function RowSubtitle({
             .join(" · ")}
         </span>
       )}
-      <HostBadge hostId={session.host_id} />
+      {!hideHost && <HostBadge hostId={session.host_id} />}
     </span>
   );
 }

package/components/SessionList/SessionRow.tsx

@@ -12,6 +12,7 @@ import {
 import { compactTimeAgo } from "@/lib/session-meta";
 import { wakeLabel } from "@/lib/sidebar/snooze";
 import { sameRow, type SidebarRow } from "@/lib/sidebar/shelves";
+import { rowKindBadge } from "@/lib/sidebar/row-badge";
 import { useMinuteTick } from "@/hooks/useMinuteTick";
 import { selectionStore, selectionActions } from "@/stores/sessionSelection";
 import { cn } from "@/lib/utils";
@@ -19,7 +20,7 @@ import { QuickChangeRow } from "./QuickChangeRow";
 import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { RowShell, type RowMenuKind } from "./RowShell";
-import { RowBadge, RowDot, RowRename } from "./RowParts";
+import { NestRail, RowBadge, RowDot, RowRename } from "./RowParts";
 import { RowSubtitle } from "./RowSubtitle";
 import { OrchestratorAsks } from "./OrchestratorAsks";
 
@@ -29,11 +30,12 @@ import { OrchestratorAsks } from "./OrchestratorAsks";
 export const SessionRow = memo(function SessionRow({
   row,
   muted = false,
-  nested = false,
+  inMachineShelf = false,
 }: {
   row: SidebarRow;
   muted?: boolean;
-  nested?: boolean;
+  // Under its machine's own shelf, which already names the machine.
+  inMachineShelf?: boolean;
 }) {
   const ctx = useRowContext();
   const { selectedIds } = useSnapshot(selectionStore);
@@ -69,9 +71,10 @@ export const SessionRow = memo(function SessionRow({
   );
 
   return (
-    <div className={cn(nested && "pl-5")}>
+    <div>
       <RowShell
         title={session.name}
+        tipKey={`session:${session.id}`}
         highlight={selected ? "selected" : active ? "active" : null}
         onClick={onClick}
         onActivate={() => ctx.onSelect(session.id)}
@@ -89,7 +92,7 @@ export const SessionRow = memo(function SessionRow({
         aside={
           <>
             {viaName && (
-              <span title={`Started by ${viaName}`} className="shrink-0">
+              <span data-tip={`Started by ${viaName}`} className="shrink-0">
                 <Workflow
                   aria-label={`Via orchestrator: ${viaName}`}
                   className="text-muted-foreground/60 h-3 w-3"
@@ -104,7 +107,7 @@ export const SessionRow = memo(function SessionRow({
         trailing={
           <>
             <RowBadge row={row} />
-            {!row.need && <RowTime row={row} />}
+            {!row.need && !rowKindBadge(row) && <RowTime row={row} />}
           </>
         }
         menu={menu}
@@ -132,6 +135,7 @@ export const SessionRow = memo(function SessionRow({
         )}
         <RowSubtitle
           session={session}
+          hideHost={inMachineShelf}
           detail={row.status?.detail}
           live={
             row.need
@@ -143,21 +147,28 @@ export const SessionRow = memo(function SessionRow({
       {session.role === "orchestrator" && row.need && (
         <OrchestratorAsks workspaceId={session.workspace_id} />
       )}
-      {row.workers.map((worker) => (
-        <SessionRow key={worker.session.id} row={worker} muted={muted} nested />
-      ))}
-      {row.quick?.map((q) => (
-        <QuickChangeRow key={q.session.id} row={q} />
-      ))}
+      {(row.workers.length > 0 || !!row.quick?.length) && (
+        <NestRail>
+          {row.workers.map((worker) => (
+            <SessionRow key={worker.session.id} row={worker} muted={muted} />
+          ))}
+          {row.quick?.map((q) => (
+            <QuickChangeRow key={q.session.id} row={q} />
+          ))}
+        </NestRail>
+      )}
     </div>
   );
 }, sameRowProps);
 
-function sameRowProps(
-  a: { row: SidebarRow; muted?: boolean; nested?: boolean },
-  b: { row: SidebarRow; muted?: boolean; nested?: boolean }
-) {
-  return a.muted === b.muted && a.nested === b.nested && sameRow(a.row, b.row);
+type RowProps = { row: SidebarRow; muted?: boolean; inMachineShelf?: boolean };
+
+function sameRowProps(a: RowProps, b: RowProps) {
+  return (
+    a.muted === b.muted &&
+    a.inMachineShelf === b.inMachineShelf &&
+    sameRow(a.row, b.row)
+  );
 }
 
 // Snoozed: when it wakes. Otherwise when it last did something.

package/components/SessionList/SessionRowMenu.tsx

@@ -34,7 +34,11 @@ import { schedulesUiActions } from "@/stores/schedulesUi";
 import { recipesUiActions } from "@/stores/recipesUi";
 import { rowGroup } from "@/lib/recipes/chip";
 import { finishActions } from "@/lib/sidebar/row-actions";
-import { useArchiveAction, useDoneAction } from "./useDoneAction";
+import {
+  useArchiveAction,
+  useDoneAction,
+  useResurrectAction,
+} from "./useDoneAction";
 import { useShelfActions } from "./useShelfActions";
 import {
   PAUSE_PRESETS,
@@ -106,6 +110,7 @@ function FinishItems({
 }) {
   const markDone = useDoneAction();
   const archive = useArchiveAction();
+  const restore = useResurrectAction();
   const actions = finishActions(session, plain);
   return (
     <>
@@ -115,6 +120,12 @@ function FinishItems({
           Done
         </Item>
       )}
+      {actions.includes("restore") && (
+        <Item onClick={() => restore(session)}>
+          <RotateCcw className={icon} />
+          Restore
+        </Item>
+      )}
       {actions.includes("archive") && (
         <Item onClick={() => archive(session)}>
           <Archive className={icon} />